diff --git a/Android.bp b/Android.bp
index fd0ed55..9982616 100644
--- a/Android.bp
+++ b/Android.bp
@@ -89,6 +89,7 @@
     required: [
         "libframesequence",
         "libgiftranscode",
+        "com.android.messaging.allowlist",
     ],
     optimize: {
         obfuscate: true,
@@ -96,9 +97,15 @@
         enabled: true,
     },
 
-    certificate: "platform",
-
     sdk_version: "current",
 
     product_specific: true,
 }
+
+prebuilt_etc {
+    name: "com.android.messaging.allowlist",
+    product_specific: true,
+    sub_dir: "sysconfig",
+    src: "com.android.messaging.allowlist.xml",
+    filename_from_src: true,
+}
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index fffcdab..3c7b4db 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -18,7 +18,7 @@
     package="com.android.messaging"
     android:installLocation="internalOnly">
 
-    <uses-sdk android:minSdkVersion="19" android:targetSdkVersion="24" />
+    <uses-sdk android:minSdkVersion="19" android:targetSdkVersion="29" />
 
     <!-- Application holds CPU wakelock while working in background -->
     <uses-permission android:name="android.permission.WAKE_LOCK" />
@@ -59,8 +59,10 @@
     <application
         android:name="com.android.messaging.BugleApplication"
         android:allowBackup="false"
-        android:icon="@drawable/ic_launcher"
+        android:appCategory="social"
+        android:icon="@mipmap/ic_launcher"
         android:label="@string/app_name"
+        android:requestLegacyExternalStorage="true"
         android:theme="@style/BugleTheme"
         android:supportsRtl="true">
 
@@ -71,7 +73,7 @@
             android:screenOrientation="user"
             android:label="@string/app_name"
             android:exported="true"
-            android:theme="@style/BugleTheme.ConversationListActivity">
+            android:theme="@style/LaunchTheme">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />
diff --git a/com.android.messaging.allowlist.xml b/com.android.messaging.allowlist.xml
new file mode 100644
index 0000000..6bc77a8
--- /dev/null
+++ b/com.android.messaging.allowlist.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     Copyright (C) 2019-2020 The LineageOS Project
+
+     Licensed under the Apache License, Version 2.0 (the "License");
+     you may not use this file except in compliance with the License.
+     You may obtain a copy of the License at
+
+          http://www.apache.org/licenses/LICENSE-2.0
+
+     Unless required by applicable law or agreed to in writing, software
+     distributed under the License is distributed on an "AS IS" BASIS,
+     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+     See the License for the specific language governing permissions and
+     limitations under the License.
+-->
+<config>
+    <allow-in-power-save package="com.android.messaging" />
+</config>
diff --git a/res/color/tab_text_color.xml b/res/color/tab_text_color.xml
index dec20dd..498d1e4 100644
--- a/res/color/tab_text_color.xml
+++ b/res/color/tab_text_color.xml
@@ -16,7 +16,7 @@
 -->
 <selector xmlns:android="http://schemas.android.com/apk/res/android">
     <item
-        android:color="@android:color/white"
+        android:color="@android:color/system_accent1_50"
         android:state_selected="true"/>
     <item
         android:color="@color/translucent_white" />
diff --git a/res/drawable-hdpi/ic_checkmark_circle_blue.png b/res/drawable-hdpi/ic_checkmark_circle_blue.png
deleted file mode 100644
index 7932c30..0000000
--- a/res/drawable-hdpi/ic_checkmark_circle_blue.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_failed_light.png b/res/drawable-hdpi/ic_failed_light.png
deleted file mode 100644
index 3614fbe..0000000
--- a/res/drawable-hdpi/ic_failed_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_launcher.png b/res/drawable-hdpi/ic_launcher.png
deleted file mode 100644
index 5e4e62f..0000000
--- a/res/drawable-hdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_notifications_off_dark.png b/res/drawable-hdpi/ic_notifications_off_dark.png
deleted file mode 100644
index 9bcdc62..0000000
--- a/res/drawable-hdpi/ic_notifications_off_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_notifications_off_light.png b/res/drawable-hdpi/ic_notifications_off_light.png
deleted file mode 100644
index 433b6a9..0000000
--- a/res/drawable-hdpi/ic_notifications_off_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_notifications_off_small_light.png b/res/drawable-hdpi/ic_notifications_off_small_light.png
deleted file mode 100644
index fbd0ad5..0000000
--- a/res/drawable-hdpi/ic_notifications_off_small_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_notifications_on_dark.png b/res/drawable-hdpi/ic_notifications_on_dark.png
deleted file mode 100644
index 21e48a5..0000000
--- a/res/drawable-hdpi/ic_notifications_on_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-hdpi/ic_notifications_on_light.png b/res/drawable-hdpi/ic_notifications_on_light.png
deleted file mode 100644
index 6b39fec..0000000
--- a/res/drawable-hdpi/ic_notifications_on_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_checkmark_circle_blue.png b/res/drawable-mdpi/ic_checkmark_circle_blue.png
deleted file mode 100644
index 6cf348e..0000000
--- a/res/drawable-mdpi/ic_checkmark_circle_blue.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_failed_light.png b/res/drawable-mdpi/ic_failed_light.png
deleted file mode 100644
index 02a4d0b..0000000
--- a/res/drawable-mdpi/ic_failed_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_launcher.png b/res/drawable-mdpi/ic_launcher.png
deleted file mode 100644
index ef6a3c5..0000000
--- a/res/drawable-mdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_notifications_off_dark.png b/res/drawable-mdpi/ic_notifications_off_dark.png
deleted file mode 100644
index 4a5a7e9..0000000
--- a/res/drawable-mdpi/ic_notifications_off_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_notifications_off_light.png b/res/drawable-mdpi/ic_notifications_off_light.png
deleted file mode 100644
index 33e0b4a..0000000
--- a/res/drawable-mdpi/ic_notifications_off_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_notifications_off_small_light.png b/res/drawable-mdpi/ic_notifications_off_small_light.png
deleted file mode 100644
index 4bd9563..0000000
--- a/res/drawable-mdpi/ic_notifications_off_small_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_notifications_on_dark.png b/res/drawable-mdpi/ic_notifications_on_dark.png
deleted file mode 100644
index 77a2a7d..0000000
--- a/res/drawable-mdpi/ic_notifications_on_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-mdpi/ic_notifications_on_light.png b/res/drawable-mdpi/ic_notifications_on_light.png
deleted file mode 100644
index eae03a5..0000000
--- a/res/drawable-mdpi/ic_notifications_on_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_checkmark_circle_blue.png b/res/drawable-xhdpi/ic_checkmark_circle_blue.png
deleted file mode 100644
index ae0ac2d..0000000
--- a/res/drawable-xhdpi/ic_checkmark_circle_blue.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_failed_light.png b/res/drawable-xhdpi/ic_failed_light.png
deleted file mode 100644
index 33d3436..0000000
--- a/res/drawable-xhdpi/ic_failed_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_launcher.png b/res/drawable-xhdpi/ic_launcher.png
deleted file mode 100644
index ad1acb4..0000000
--- a/res/drawable-xhdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_notifications_off_dark.png b/res/drawable-xhdpi/ic_notifications_off_dark.png
deleted file mode 100644
index 4f3b924..0000000
--- a/res/drawable-xhdpi/ic_notifications_off_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_notifications_off_light.png b/res/drawable-xhdpi/ic_notifications_off_light.png
deleted file mode 100644
index 16ae132..0000000
--- a/res/drawable-xhdpi/ic_notifications_off_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_notifications_off_small_light.png b/res/drawable-xhdpi/ic_notifications_off_small_light.png
deleted file mode 100644
index e54fc52..0000000
--- a/res/drawable-xhdpi/ic_notifications_off_small_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_notifications_on_dark.png b/res/drawable-xhdpi/ic_notifications_on_dark.png
deleted file mode 100644
index 40f2909..0000000
--- a/res/drawable-xhdpi/ic_notifications_on_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xhdpi/ic_notifications_on_light.png b/res/drawable-xhdpi/ic_notifications_on_light.png
deleted file mode 100644
index 3c44f93..0000000
--- a/res/drawable-xhdpi/ic_notifications_on_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_checkmark_circle_blue.png b/res/drawable-xxhdpi/ic_checkmark_circle_blue.png
deleted file mode 100644
index d40bb93..0000000
--- a/res/drawable-xxhdpi/ic_checkmark_circle_blue.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_failed_light.png b/res/drawable-xxhdpi/ic_failed_light.png
deleted file mode 100644
index 7612138..0000000
--- a/res/drawable-xxhdpi/ic_failed_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_launcher.png b/res/drawable-xxhdpi/ic_launcher.png
deleted file mode 100644
index de56e98..0000000
--- a/res/drawable-xxhdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_notifications_off_dark.png b/res/drawable-xxhdpi/ic_notifications_off_dark.png
deleted file mode 100644
index 27d3754..0000000
--- a/res/drawable-xxhdpi/ic_notifications_off_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_notifications_off_light.png b/res/drawable-xxhdpi/ic_notifications_off_light.png
deleted file mode 100644
index a2aedec..0000000
--- a/res/drawable-xxhdpi/ic_notifications_off_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_notifications_off_small_light.png b/res/drawable-xxhdpi/ic_notifications_off_small_light.png
deleted file mode 100644
index 2a90e07..0000000
--- a/res/drawable-xxhdpi/ic_notifications_off_small_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_notifications_on_dark.png b/res/drawable-xxhdpi/ic_notifications_on_dark.png
deleted file mode 100644
index e64da6b..0000000
--- a/res/drawable-xxhdpi/ic_notifications_on_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_notifications_on_light.png b/res/drawable-xxhdpi/ic_notifications_on_light.png
deleted file mode 100644
index f8f7d15..0000000
--- a/res/drawable-xxhdpi/ic_notifications_on_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_checkmark_circle_blue.png b/res/drawable-xxxhdpi/ic_checkmark_circle_blue.png
deleted file mode 100644
index 0c2a7d5..0000000
--- a/res/drawable-xxxhdpi/ic_checkmark_circle_blue.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_failed_light.png b/res/drawable-xxxhdpi/ic_failed_light.png
deleted file mode 100644
index 53d374c..0000000
--- a/res/drawable-xxxhdpi/ic_failed_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_launcher.png b/res/drawable-xxxhdpi/ic_launcher.png
deleted file mode 100644
index 9ac88b4..0000000
--- a/res/drawable-xxxhdpi/ic_launcher.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_notifications_off_dark.png b/res/drawable-xxxhdpi/ic_notifications_off_dark.png
deleted file mode 100644
index 10ac318..0000000
--- a/res/drawable-xxxhdpi/ic_notifications_off_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_notifications_off_light.png b/res/drawable-xxxhdpi/ic_notifications_off_light.png
deleted file mode 100644
index 8eb5782..0000000
--- a/res/drawable-xxxhdpi/ic_notifications_off_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_notifications_off_small_light.png b/res/drawable-xxxhdpi/ic_notifications_off_small_light.png
deleted file mode 100644
index 3756943..0000000
--- a/res/drawable-xxxhdpi/ic_notifications_off_small_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_notifications_on_dark.png b/res/drawable-xxxhdpi/ic_notifications_on_dark.png
deleted file mode 100644
index 3896212..0000000
--- a/res/drawable-xxxhdpi/ic_notifications_on_dark.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_notifications_on_light.png b/res/drawable-xxxhdpi/ic_notifications_on_light.png
deleted file mode 100644
index 47794fd..0000000
--- a/res/drawable-xxxhdpi/ic_notifications_on_light.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable/ic_checkmark_circle_blue.xml b/res/drawable/ic_checkmark_circle_blue.xml
new file mode 100644
index 0000000..9f6b53b
--- /dev/null
+++ b/res/drawable/ic_checkmark_circle_blue.xml
@@ -0,0 +1,14 @@
+<!--
+  SPDX-FileCopyrightText: The LineageOS Project
+  SPDX-License-Identifier: Apache-2.0
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="42dp"
+    android:height="42dp"
+    android:viewportWidth="42"
+    android:viewportHeight="42">
+    <path
+        android:fillColor="@color/lineage_accent"
+        android:fillType="evenOdd"
+        android:pathData="M21 42C32.598 42 42 32.598 42 21C42 9.40201 32.598 0 21 0C9.40198 0 0 9.40201 0 21C0 32.598 9.40198 42 21 42ZM14.275 19.8751L12.85 21.3001L18.5499 27.0001L29.15 16.4001L27.725 14.9751L18.5499 24.1501L14.275 19.8751Z" />
+</vector>
diff --git a/res/drawable/ic_failed_light.xml b/res/drawable/ic_failed_light.xml
new file mode 100644
index 0000000..c322be3
--- /dev/null
+++ b/res/drawable/ic_failed_light.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2022 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:pathData="M22,12C22,17.5228 17.5228,22 12,22C6.4771,22 2,17.5228 2,12C2,6.4771 6.4771,2 12,2C13.6465,2 15.2001,2.3979 16.5698,3.1029L20.8695,2.028C21.5353,1.8615 22.1384,2.4646 21.972,3.1304L20.8971,7.4301C21.602,8.7998 22,10.3534 22,12ZM15.74,17L17,15.74L13.26,12L17,8.26L15.74,7L12,10.74L8.26,7L7,8.26L10.74,12L7,15.74L8.26,17L12,13.26L15.74,17Z"
+      android:fillColor="#000000"
+      android:fillType="evenOdd"/>
+</vector>
diff --git a/res/drawable/ic_launcher_background.xml b/res/drawable/ic_launcher_background.xml
new file mode 100644
index 0000000..fb36b7e
--- /dev/null
+++ b/res/drawable/ic_launcher_background.xml
@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2022 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+  <path
+      android:pathData="M0,0h108v108h-108z"
+      android:fillColor="#359944"/>
+  <path
+      android:pathData="M54,76C66.15,76 76,66.15 76,54C76,49.769 74.806,45.817 72.736,42.463L74.327,36.098C74.693,34.634 73.366,33.307 71.902,33.673L65.537,35.264C62.183,33.194 58.231,32 54,32C41.85,32 32,41.85 32,54C32,66.15 41.85,76 54,76Z"
+      android:fillColor="#ffffff"
+      android:fillType="evenOdd"/>
+</vector>
diff --git a/res/drawable/ic_launcher_foreground.xml b/res/drawable/ic_launcher_foreground.xml
new file mode 100644
index 0000000..d0dcbf4
--- /dev/null
+++ b/res/drawable/ic_launcher_foreground.xml
@@ -0,0 +1,34 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2022 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:aapt="http://schemas.android.com/aapt"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+  <group>
+    <clip-path
+        android:pathData="M0,0h108v108h-108z"/>
+    <path
+        android:pathData="M54,66C60.75,66 66,63.627 66,57C66,47.373 60.75,42 54,42C47.25,42 42,47.373 42,57C42,63.627 47.25,66 54,66ZM54,57.5C57.057,57.5 60.055,56.942 62,56C61.125,58.603 59.333,62 54,62C48.667,62 46.875,58.603 46,56C47.945,56.942 50.943,57.5 54,57.5Z"
+        android:fillColor="#143721"
+        android:fillType="evenOdd"/>
+    <path
+        android:pathData="M28.54,28.54m-72,0a72,72 0,1 1,144 0a72,72 0,1 1,-144 0"
+        android:fillAlpha="0.6">
+      <aapt:attr name="android:fillColor">
+        <gradient
+            android:gradientRadius="72"
+            android:centerX="28.54"
+            android:centerY="28.54"
+            android:type="radial">
+          <item android:offset="0" android:color="#19FFFFFF"/>
+          <item android:offset="1" android:color="#00FFFFFF"/>
+        </gradient>
+      </aapt:attr>
+    </path>
+  </group>
+</vector>
diff --git a/res/drawable/ic_launcher_monochrome.xml b/res/drawable/ic_launcher_monochrome.xml
new file mode 100644
index 0000000..9cf5e2c
--- /dev/null
+++ b/res/drawable/ic_launcher_monochrome.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2022 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="108dp"
+    android:height="108dp"
+    android:viewportWidth="108"
+    android:viewportHeight="108">
+  <path
+      android:pathData="M69.465,42.887L70.916,37.083L65.113,38.534L64.033,37.861C61.123,36.048 57.688,35 54,35C43.507,35 35,43.507 35,54C35,64.493 43.507,73 54,73C64.493,73 73,64.493 73,54C73,50.311 71.952,46.876 70.138,43.966L69.465,42.887ZM76,54C76,66.15 66.15,76 54,76C41.85,76 32,66.15 32,54C32,41.85 41.85,32 54,32C58.265,32 62.248,33.214 65.619,35.315L71.805,33.769C73.27,33.403 74.597,34.729 74.23,36.194L72.684,42.38C74.786,45.752 76,49.734 76,54Z"
+      android:fillColor="#ffffffff"
+      android:fillType="evenOdd"/>
+  <path
+      android:pathData="M54,65.733C60.6,65.733 65.733,63.414 65.733,56.933C65.733,47.52 60.6,42.267 54,42.267C47.4,42.267 42.267,47.52 42.267,56.933C42.267,63.414 47.4,65.733 54,65.733ZM54,56.933C56.802,56.933 59.551,56.387 61.333,55.467C60.532,58.012 58.889,61.333 54,61.333C49.111,61.333 47.468,58.012 46.667,55.467C48.449,56.387 51.198,56.933 54,56.933Z"
+      android:fillColor="#ffffffff"
+      android:fillType="evenOdd"/>
+</vector>
diff --git a/res/drawable/ic_message.xml b/res/drawable/ic_message.xml
new file mode 100644
index 0000000..dcab3ac
--- /dev/null
+++ b/res/drawable/ic_message.xml
@@ -0,0 +1,24 @@
+<!--
+  ~ Copyright (C) 2021 The Android Open Source Project
+  ~
+  ~ Licensed under the Apache License, Version 2.0 (the "License");
+  ~ you may not use this file except in compliance with the License.
+  ~ You may obtain a copy of the License at
+  ~
+  ~      http://www.apache.org/licenses/LICENSE-2.0
+  ~
+  ~ Unless required by applicable law or agreed to in writing, software
+  ~ distributed under the License is distributed on an "AS IS" BASIS,
+  ~ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  ~ See the License for the specific language governing permissions and
+  ~ limitations under the License.
+  -->
+<vector xmlns:android="http://schemas.android.com/apk/res/android" xmlns:aapt="http://schemas.android.com/aapt"
+    android:viewportWidth="48"
+    android:viewportHeight="48"
+    android:width="24dp"
+    android:height="24dp">
+    <path
+        android:pathData="M40 4H8C5.79 4 4.02 5.79 4.02 8L4 44l8 -8h28c2.21 0 4 -1.79 4 -4V8c0 -2.21 -1.79 -4 -4 -4zM12 18h24v4H12v-4zm16 10H12v-4h16v4zm8 -12H12v-4h24v4z"
+        android:fillColor="#fff" />
+</vector>
diff --git a/res/drawable/ic_sms_light.xml b/res/drawable/ic_sms_light.xml
new file mode 100644
index 0000000..66058ae
--- /dev/null
+++ b/res/drawable/ic_sms_light.xml
@@ -0,0 +1,15 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2022 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+  <path
+      android:pathData="M11.9999,21.9998C6.4771,21.9998 1.9999,17.5226 1.9999,11.9998C1.9999,10.3532 2.3979,8.7996 3.1029,7.4298L2.028,3.1302C1.8615,2.4644 2.4646,1.8613 3.1304,2.0277L7.4301,3.1026C8.7998,2.3977 10.3534,1.9998 11.9999,1.9998C17.5228,1.9998 21.9999,6.4769 21.9999,11.9998C21.9999,17.5226 17.5228,21.9998 11.9999,21.9998ZM11.9999,17.9998C15.3749,17.9998 17.9999,16.8135 17.9999,13.4998C17.9999,8.6861 15.3749,5.9998 11.9999,5.9998C8.6249,5.9998 5.9999,8.6861 5.9999,13.4998C5.9999,16.8135 8.6249,17.9998 11.9999,17.9998ZM11.9999,13.7498C13.5283,13.7498 15.0275,13.4705 15.9999,12.9998C15.5627,14.3011 14.6666,15.9998 11.9999,15.9998C9.3333,15.9998 8.4372,14.3011 7.9999,12.9998C8.9723,13.4705 10.4716,13.7498 11.9999,13.7498Z"
+      android:fillColor="#000000"
+      android:fillType="evenOdd"/>
+</vector>
diff --git a/res/drawable/message_bubble_incoming_no_arrow.xml b/res/drawable/message_bubble_incoming_no_arrow.xml
index d234508..050da48 100644
--- a/res/drawable/message_bubble_incoming_no_arrow.xml
+++ b/res/drawable/message_bubble_incoming_no_arrow.xml
@@ -16,5 +16,5 @@
 -->
 <shape xmlns:android="http://schemas.android.com/apk/res/android">
     <solid android:color="@color/color_filter_base_color" />
-    <corners android:radius="3dp" />
+    <corners android:radius="28dp" />
 </shape>
diff --git a/res/drawable/message_bubble_outgoing_no_arrow.xml b/res/drawable/message_bubble_outgoing_no_arrow.xml
index d234508..050da48 100644
--- a/res/drawable/message_bubble_outgoing_no_arrow.xml
+++ b/res/drawable/message_bubble_outgoing_no_arrow.xml
@@ -16,5 +16,5 @@
 -->
 <shape xmlns:android="http://schemas.android.com/apk/res/android">
     <solid android:color="@color/color_filter_base_color" />
-    <corners android:radius="3dp" />
+    <corners android:radius="28dp" />
 </shape>
diff --git a/res/drawable/msg_bubble_input_rounded.xml b/res/drawable/msg_bubble_input_rounded.xml
new file mode 100644
index 0000000..e66d863
--- /dev/null
+++ b/res/drawable/msg_bubble_input_rounded.xml
@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2023 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+
+<shape
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:shape="rectangle">
+
+    <solid android:color="@color/compose_send_text_background_color" />
+    <corners android:radius="28dp" />
+</shape>
diff --git a/res/layout/compose_message_view.xml b/res/layout/compose_message_view.xml
index 8bb8249..e6e94ca 100644
--- a/res/layout/compose_message_view.xml
+++ b/res/layout/compose_message_view.xml
@@ -17,6 +17,7 @@
 <com.android.messaging.ui.conversation.ComposeMessageView
     xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
     android:id="@+id/message_compose_view_container"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
@@ -110,6 +111,8 @@
                         android:layout_height="wrap_content"
                         android:layout_gravity="center_vertical"
                         android:src="@drawable/ic_attachment_dark"
+                        android:minHeight="48dp"
+                        android:minWidth="48dp"
                         android:paddingTop="@dimen/compose_message_attachment_padding_topBottom"
                         android:paddingBottom="@dimen/compose_message_attachment_padding_topBottom"
                         android:contentDescription="@string/attachMediaButtonContentDescription" />
@@ -121,7 +124,7 @@
                         android:layout_width="0dp"
                         android:layout_weight="1"
                         android:layout_gravity="center"
-                        android:background="@drawable/msg_bubble_input"
+                        android:background="@drawable/msg_bubble_input_rounded"
                         android:hint="@string/compose_message_view_hint_text"
                         android:imeOptions="actionSend|flagNoEnterAction|flagNoExtractUi" />
 
diff --git a/res/layout/conversation_list_fragment.xml b/res/layout/conversation_list_fragment.xml
index 7fa2a9a..27c9357 100644
--- a/res/layout/conversation_list_fragment.xml
+++ b/res/layout/conversation_list_fragment.xml
@@ -46,7 +46,7 @@
         android:background="@drawable/fab_new_message_bg"
         android:elevation="@dimen/fab_elevation"
         android:scaleType="center"
-        android:src="@drawable/ic_add_white"
+        android:src="@drawable/ic_message"
         android:stateListAnimator="@animator/fab_anim"
         android:contentDescription="@string/start_new_conversation"/>
 
diff --git a/res/layout/conversation_list_item_view.xml b/res/layout/conversation_list_item_view.xml
index 636616b..c89e470 100644
--- a/res/layout/conversation_list_item_view.xml
+++ b/res/layout/conversation_list_item_view.xml
@@ -37,7 +37,6 @@
             android:layout_height="wrap_content"
             android:gravity="center_vertical|left"
             android:visibility="gone"
-            android:src="@drawable/ic_archive_small_dark"
             android:importantForAccessibility="no"
             android:contentDescription="@null"/>
         <FrameLayout
@@ -50,7 +49,6 @@
             android:layout_height="wrap_content"
             android:layout_gravity="center_vertical|right"
             android:visibility="gone"
-            android:src="@drawable/ic_archive_small_dark"
             android:importantForAccessibility="no"
             android:contentDescription="@null"/>
     </LinearLayout>
@@ -123,17 +121,6 @@
                             android:layout_height="wrap_content"
                             android:layout_weight="1"
                             android:background="@android:color/transparent">
-                        <ImageView
-                            android:id="@+id/conversation_notification_bell"
-                            style="@style/ConversationListNotificationBellPaddingStyle"
-                            android:layout_width="wrap_content"
-                            android:layout_height="wrap_content"
-                            android:src="@drawable/ic_notifications_off_small_light"
-                            android:visibility="gone"
-                            android:importantForAccessibility="no"
-                            android:contentDescription="@null"
-                            android:layout_gravity="center_vertical"
-                            android:background="@android:color/transparent" />
                         <TextView
                             android:id="@+id/conversation_name"
                             style="@style/ConversationListItemViewConversationNameStyle"
diff --git a/res/layout/conversation_message_view.xml b/res/layout/conversation_message_view.xml
index daad600..25d3840 100644
--- a/res/layout/conversation_message_view.xml
+++ b/res/layout/conversation_message_view.xml
@@ -72,7 +72,8 @@
             android:id="@+id/message_text_and_info"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:orientation="vertical">
+            android:orientation="vertical"
+            android:forceDarkAllowed="false">
 
             <LinearLayout
                 android:id="@+id/message_title_layout"
diff --git a/res/layout/people_options_item_view.xml b/res/layout/people_options_item_view.xml
index 8821eec..8895037 100644
--- a/res/layout/people_options_item_view.xml
+++ b/res/layout/people_options_item_view.xml
@@ -40,25 +40,5 @@
             android:ellipsize="end"
             style="@style/ParticipantListItem"
             android:layout_gravity="center_vertical" />
-
-        <TextView
-            android:id="@+id/subtitle"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:singleLine="true"
-            android:maxLines="1"
-            android:ellipsize="end"
-            style="@style/ParticipantListItemDetail"
-            android:layout_gravity="center_vertical" />
-
     </LinearLayout>
-
-    <androidx.appcompat.widget.SwitchCompat
-        android:id="@+id/switch_button"
-        android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:focusable="false"
-        android:clickable="false"
-        android:visibility="gone" />
-
 </com.android.messaging.ui.conversationsettings.PeopleOptionsItemView>
diff --git a/res/layout/widget_conversation.xml b/res/layout/widget_conversation.xml
index 2c7edee..9037a6f 100644
--- a/res/layout/widget_conversation.xml
+++ b/res/layout/widget_conversation.xml
@@ -39,7 +39,7 @@
             android:freezesText="true" />
         <ImageView
             android:id="@+id/launcher_icon"
-            android:src="@drawable/ic_launcher"
+            android:src="@mipmap/ic_launcher"
             android:layout_height="wrap_content"
             android:layout_width="0dip"
             android:layout_weight = "1"
diff --git a/res/layout/widget_conversation_list_item.xml b/res/layout/widget_conversation_list_item.xml
index e0115a2..c1a140a 100644
--- a/res/layout/widget_conversation_list_item.xml
+++ b/res/layout/widget_conversation_list_item.xml
@@ -67,18 +67,6 @@
                 android:layout_alignParentTop="true"
                 android:gravity="center_vertical"
                 android:background="@android:color/transparent">
-                <ImageView
-                    android:id="@+id/conversation_notification_bell"
-                    style="@style/ConversationListNotificationBellPaddingStyle"
-                    android:layout_width="wrap_content"
-                    android:layout_height="wrap_content"
-                    android:src="@drawable/ic_notifications_off_small_light"
-                    android:visibility="gone"
-                    android:importantForAccessibility="no"
-                    android:contentDescription="@null"
-                    android:layout_gravity="center_vertical"
-                    android:background="@android:color/transparent" />
-
                 <TextView android:id="@+id/from"
                     style="@style/WidgetConversationListItemFrom"
                     android:layout_width="0dp"
diff --git a/res/menu/conversation_list_fragment_select_menu.xml b/res/menu/conversation_list_fragment_select_menu.xml
index 8704691..9247923 100644
--- a/res/menu/conversation_list_fragment_select_menu.xml
+++ b/res/menu/conversation_list_fragment_select_menu.xml
@@ -37,18 +37,6 @@
         android:title="@string/action_delete"
         appcompat:showAsAction="collapseActionView|always"/>
     <item
-        android:id="@+id/action_notification_off"
-        android:icon="@drawable/ic_notifications_off_dark"
-        android:orderInCategory="70"
-        android:title="@string/action_notification_off"
-        appcompat:showAsAction="collapseActionView|always"/>
-    <item
-        android:id="@+id/action_notification_on"
-        android:icon="@drawable/ic_notifications_on_dark"
-        android:orderInCategory="80"
-        android:title="@string/action_notification_on"
-        appcompat:showAsAction="collapseActionView|always"/>
-    <item
         android:id="@+id/action_add_contact"
         android:icon="@drawable/ic_person_add_dark"
         android:orderInCategory="90"
diff --git a/res/mipmap-anydpi/ic_launcher.xml b/res/mipmap-anydpi/ic_launcher.xml
new file mode 100644
index 0000000..b58c81f
--- /dev/null
+++ b/res/mipmap-anydpi/ic_launcher.xml
@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+     SPDX-FileCopyrightText: 2022 The LineageOS Project
+     SPDX-License-Identifier: Apache-2.0
+-->
+<adaptive-icon xmlns:android="http://schemas.android.com/apk/res/android">
+    <background android:drawable="@drawable/ic_launcher_background"/>
+    <foreground android:drawable="@drawable/ic_launcher_foreground"/>
+    <monochrome android:drawable="@drawable/ic_launcher_monochrome"/>
+</adaptive-icon>
diff --git a/res/values-af/cm_strings.xml b/res/values-af/cm_strings.xml
new file mode 100644
index 0000000..7dda79d
--- /dev/null
+++ b/res/values-af/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Sleep om uit te vee</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Vee na regs om gesprek uit te vee</string>
+</resources>
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 901bd27..2659068 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Vee uit"</string>
     <string name="action_archive" msgid="5437034800324083170">"Argiveer"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Deargiveer"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Skakel kennisgewings af"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Skakel kennisgewings aan"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Voeg kontak by"</string>
     <string name="action_download" msgid="7786338136368564146">"Laai af"</string>
     <string name="action_send" msgid="377635240181672039">"Stuur"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Gevorderd"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Ontfout"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Kennisgewings"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Klank"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Kennisgewings"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Stil"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibreer"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Geblokkeer"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-afleweringverslae"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Versoek \'n afleweringsverslag vir elke SMS wat jy stuur"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index bea9e6f..2cbd6d5 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"ሰርዝ"</string>
     <string name="action_archive" msgid="5437034800324083170">"በማህደር አስቀምጥ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ከማህደር አስወጣ"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"ማሳወቂያዎችን አጥፋ"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"ማሳወቂያዎችን አብራ"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"እውቂያ አክል"</string>
     <string name="action_download" msgid="7786338136368564146">"አውርድ"</string>
     <string name="action_send" msgid="377635240181672039">"ላክ"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"ኤምኤምኤስ"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"የላቀ"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"አርም"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"ማሳወቂያዎች"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ድምፅ"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"ማሳወቂያዎች"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"ፀጥታ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"ንዘር"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ታግዷል"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"የኤስኤምኤስ መላክ ሪፖርቶች"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ለሚልኩት እያንዳንዱ ኤስኤምኤስ የመላኪያ ሪፖርት ጠይቅ"</string>
diff --git a/res/values-ar/cm_strings.xml b/res/values-ar/cm_strings.xml
new file mode 100644
index 0000000..2ab26e9
--- /dev/null
+++ b/res/values-ar/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">تمرير لإجراء حذف</string>
+    <string name="swipe_to_delete_conversation_pref_summary">تمرير إلى اليمين لحذف محادثة</string>
+    <string name="notification_channel_messages_title">الرسائل</string>
+</resources>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index 1a0f4b9..9e1292e 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -183,8 +183,6 @@
     <string name="action_delete" msgid="4076795795307486019">"حذف"</string>
     <string name="action_archive" msgid="5437034800324083170">"أرشيف"</string>
     <string name="action_unarchive" msgid="139681611159869493">"إزالة من الأرشيف"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"إيقاف الإشعارات"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"تشغيل الإشعارات"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"إضافة جهة اتصال"</string>
     <string name="action_download" msgid="7786338136368564146">"تنزيل"</string>
     <string name="action_send" msgid="377635240181672039">"إرسال"</string>
@@ -330,10 +328,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"رسالة وسائط متعددة"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"إعدادات متقدمة"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"تصحيح الأخطاء"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"الإشعارات"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"الصوت"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"الإشعارات"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"صامت"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"اهتزاز"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"محظور"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"‏تقارير تسليم الرسائل القصيرة SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"‏طلب تقرير تسليم لكل رسالة قصيرة SMS ترسلها"</string>
diff --git a/res/values-as/cm_strings.xml b/res/values-as/cm_strings.xml
new file mode 100644
index 0000000..c9471e3
--- /dev/null
+++ b/res/values-as/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">মচি পেলাবলৈ স্ৱাইপ কৰক</string>
+    <string name="swipe_to_delete_conversation_pref_summary">কথোপকথন মচিবলৈ সোঁ ফাললৈ স্ৱাইপ কৰক</string>
+</resources>
diff --git a/res/values-ast-rES/cm_strings.xml b/res/values-ast-rES/cm_strings.xml
new file mode 100644
index 0000000..6429a71
--- /dev/null
+++ b/res/values-ast-rES/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Eslizar pa desaniciar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Esliza a la derecha pa desaniciar una conversación</string>
+    <string name="notification_channel_messages_title">Mensaxes</string>
+</resources>
diff --git a/res/values-az/cm_strings.xml b/res/values-az/cm_strings.xml
new file mode 100644
index 0000000..a564547
--- /dev/null
+++ b/res/values-az/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Silmək üçün sürüşdür</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Yazışmanı silmək üçün sağa sürüşdür</string>
+    <string name="notification_channel_messages_title">Mesajlar</string>
+</resources>
diff --git a/res/values-az/strings.xml b/res/values-az/strings.xml
index 56b4274..d9682b1 100644
--- a/res/values-az/strings.xml
+++ b/res/values-az/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Sil"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arxiv"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Arxivdən çıxarın"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Bildirişləri deaktiv edin"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Bildirişləri aktivləşdirin"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Kontakt əlavə edin"</string>
     <string name="action_download" msgid="7786338136368564146">"Endirin"</string>
     <string name="action_send" msgid="377635240181672039">"Göndər"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Qabaqcıl"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Sazlama"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Bildirişlər"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Səs"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Bildirişlər"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Səssiz"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Titrət"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloklanmış"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS çatdırma xətaları"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Hər göndərdiyiniz SMS üçün çatdırılma raportu tələb edin"</string>
diff --git a/res/values-be/cm_strings.xml b/res/values-be/cm_strings.xml
new file mode 100644
index 0000000..b66b254
--- /dev/null
+++ b/res/values-be/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Правядзіце для выдалення</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Правядзіце ўправа для выдалення размовы</string>
+    <string name="notification_channel_messages_title">Паведамленні</string>
+</resources>
diff --git a/res/values-bg/cm_strings.xml b/res/values-bg/cm_strings.xml
new file mode 100644
index 0000000..e2db6fe
--- /dev/null
+++ b/res/values-bg/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Бързо изтриване</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Плъзнете от ляво надясно за да изтриете кореспонденцията</string>
+    <string name="notification_channel_messages_title">Съобщения</string>
+</resources>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index c1b8401..4ebf407 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Изтриване"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архивиране"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Деархивиране"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Изключване на известията"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Включване на известията"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Добавяне на контакт"</string>
     <string name="action_download" msgid="7786338136368564146">"Изтегляне"</string>
     <string name="action_send" msgid="377635240181672039">"Изпращане"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Разширени"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Отстраняване на грешки"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Известия"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Звук"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Известия"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Тих режим"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Вибриране"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Блокирано"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Отчети за получаване на SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Заявяване на отчет за доставка за всеки изпратен от вас SMS"</string>
diff --git a/res/values-bn/strings.xml b/res/values-bn/strings.xml
index 96af70b..62ac250 100644
--- a/res/values-bn/strings.xml
+++ b/res/values-bn/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"মুছুন"</string>
     <string name="action_archive" msgid="5437034800324083170">"সংরক্ষণ করুন"</string>
     <string name="action_unarchive" msgid="139681611159869493">"সংরক্ষণাগারমুক্ত করুন"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"বিজ্ঞপ্তিগুলি বন্ধ করুন"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"বিজ্ঞপ্তি চালু করুন"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"পরিচিতি যোগ করুন"</string>
     <string name="action_download" msgid="7786338136368564146">"ডাউনলোড করুন"</string>
     <string name="action_send" msgid="377635240181672039">"পাঠান"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"উন্নত"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ডিবাগ"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"বিজ্ঞপ্তিগুলি"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"আওয়াজ"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"বিজ্ঞপ্তিগুলি"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"নীরব"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"কম্পন"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"অবরুদ্ধ"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS বিতরণের প্রতিবেদনগুলি"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"আপনি যে SMS পাঠাবেন তার প্রতিটির জন্য পৌঁছে দেওয়ার প্রতিবেদনের অনুরোধ করুন"</string>
diff --git a/res/values-bs/cm_strings.xml b/res/values-bs/cm_strings.xml
new file mode 100644
index 0000000..e2894c1
--- /dev/null
+++ b/res/values-bs/cm_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="notification_channel_messages_title">Poruke</string>
+</resources>
diff --git a/res/values-ca/cm_strings.xml b/res/values-ca/cm_strings.xml
new file mode 100644
index 0000000..c25e591
--- /dev/null
+++ b/res/values-ca/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Llisca per esborrar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Llisca cap a la dreta per esborrar una conversa</string>
+    <string name="notification_channel_messages_title">Missatges</string>
+</resources>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 9f09908..fc034ce 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Suprimeix"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arxiu"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Treu de l\'arxiu"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desactiva les notificacions"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activa les notificacions"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Afegeix un contacte"</string>
     <string name="action_download" msgid="7786338136368564146">"Baixa"</string>
     <string name="action_send" msgid="377635240181672039">"Envia"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avançada"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Depuració"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificacions"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"So"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificacions"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silenci"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibració"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"S\'ha bloquejat"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Informes d\'entrega de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Sol·licita un informe d\'entrega per a cada SMS enviat"</string>
diff --git a/res/values-cs/cm_strings.xml b/res/values-cs/cm_strings.xml
new file mode 100644
index 0000000..bbdafdf
--- /dev/null
+++ b/res/values-cs/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Odsunutím smazat</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Odsunutím vpravo smazat konverzaci</string>
+    <string name="notification_channel_messages_title">Zprávy</string>
+</resources>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 7e58112..cbdce82 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Smazat"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archivovat"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Vyjmout z archivu"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Vypnout oznámení"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Zapnout oznámení"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Přidat kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Stáhnout"</string>
     <string name="action_send" msgid="377635240181672039">"Odeslat"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Rozšířená nastavení"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Ladit"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Oznámení"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Zvuk"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Oznámení"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Tichý režim"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrace"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Zablokováno"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Zprávy o doručení SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"U každé odeslané SMS požadovat potvrzení o doručení"</string>
diff --git a/res/values-cy/cm_strings.xml b/res/values-cy/cm_strings.xml
new file mode 100644
index 0000000..d4bf111
--- /dev/null
+++ b/res/values-cy/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Llusgo i ddileu</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Llusgo sgwrs i\'r dde yn ei dileu</string>
+    <string name="notification_channel_messages_title">Negeseuon</string>
+</resources>
diff --git a/res/values-da/cm_strings.xml b/res/values-da/cm_strings.xml
new file mode 100644
index 0000000..33aa1a7
--- /dev/null
+++ b/res/values-da/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Stryg for at slette</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Stryg mod højre, for at slette en samtale</string>
+    <string name="notification_channel_messages_title">Beskeder</string>
+</resources>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 6d441da..a45c04f 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Slet"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arkivér"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Fjern fra arkiv"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Deaktiver underretninger"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Aktivér underretninger"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Tilføj kontaktperson"</string>
     <string name="action_download" msgid="7786338136368564146">"Download"</string>
     <string name="action_send" msgid="377635240181672039">"Send"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"Mms"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avanceret"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Fejlretning"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Underretninger"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Lyd"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Underretninger"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Lydløs"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrer"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokeret"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-leveringsrapporter"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Anmod om leveringsrapporter for alle de sms-beskeder, du sender"</string>
diff --git a/res/values-de/cm_strings.xml b/res/values-de/cm_strings.xml
new file mode 100644
index 0000000..86de44b
--- /dev/null
+++ b/res/values-de/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Zum Löschen wischen</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Nach rechts wischen, um eine Konversation zu löschen</string>
+    <string name="notification_channel_messages_title">Nachrichten</string>
+</resources>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 4537b8b..3df718e 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Löschen"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archivieren"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Aus Archiv entfernen"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Benachrichtigungen deaktivieren"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Benachrichtigungen aktivieren"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Kontakt hinzufügen"</string>
     <string name="action_download" msgid="7786338136368564146">"Herunterladen"</string>
     <string name="action_send" msgid="377635240181672039">"Senden"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Erweitert"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Fehlersuche"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Benachrichtigungen"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ton"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Benachrichtigungen"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Lautlos"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrieren"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blockiert"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-Zustellberichte"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Zustellbestätigung für jede gesendete SMS anfordern"</string>
diff --git a/res/values-el/cm_strings.xml b/res/values-el/cm_strings.xml
new file mode 100644
index 0000000..003d1a6
--- /dev/null
+++ b/res/values-el/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Ολίσθηση για διαγραφή</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Σύρετε προς τα δεξιά για να διαγράψετε μια συζήτηση</string>
+    <string name="notification_channel_messages_title">Μηνύματα</string>
+</resources>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index d74a84b..1a88c39 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Διαγραφή"</string>
     <string name="action_archive" msgid="5437034800324083170">"Αρχειοθέτηση"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Κατάργηση αρχειοθέτησης"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Απενεργοποίηση ειδοποιήσεων"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Ενεργοποίηση ειδοποιήσεων"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Προσθήκη επαφής"</string>
     <string name="action_download" msgid="7786338136368564146">"Λήψη"</string>
     <string name="action_send" msgid="377635240181672039">"Αποστολή"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Σύνθετες ρυθμίσεις"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Εντοπισμός σφαλμάτων"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Ειδοποιήσεις"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ήχος"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Ειδοποιήσεις"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Σίγαση"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Δόνηση"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Αποκλεισμένο"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Αναφορές παράδοσης SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Αίτηση αναφοράς παράδοσης για κάθε SMS που στέλνετε"</string>
diff --git a/res/values-en-rAU/cm_strings.xml b/res/values-en-rAU/cm_strings.xml
new file mode 100644
index 0000000..9266637
--- /dev/null
+++ b/res/values-en-rAU/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Swipe to delete</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Swipe to the right to delete a conversation</string>
+    <string name="notification_channel_messages_title">Messages</string>
+</resources>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index 3a642fb..1e481ce 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Delete"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archive"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Unarchive"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Turn off notifications"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Turn on notifications"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Add contact"</string>
     <string name="action_download" msgid="7786338136368564146">"Download"</string>
     <string name="action_send" msgid="377635240181672039">"Send"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Advanced"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Debug"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifications"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Sound"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifications"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silent"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrate"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blocked"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS delivery reports"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Request a delivery report for each SMS that you send"</string>
diff --git a/res/values-en-rCA/cm_strings.xml b/res/values-en-rCA/cm_strings.xml
new file mode 100644
index 0000000..9266637
--- /dev/null
+++ b/res/values-en-rCA/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Swipe to delete</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Swipe to the right to delete a conversation</string>
+    <string name="notification_channel_messages_title">Messages</string>
+</resources>
diff --git a/res/values-en-rGB/cm_strings.xml b/res/values-en-rGB/cm_strings.xml
new file mode 100644
index 0000000..9266637
--- /dev/null
+++ b/res/values-en-rGB/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Swipe to delete</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Swipe to the right to delete a conversation</string>
+    <string name="notification_channel_messages_title">Messages</string>
+</resources>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 3a642fb..1e481ce 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Delete"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archive"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Unarchive"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Turn off notifications"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Turn on notifications"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Add contact"</string>
     <string name="action_download" msgid="7786338136368564146">"Download"</string>
     <string name="action_send" msgid="377635240181672039">"Send"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Advanced"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Debug"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifications"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Sound"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifications"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silent"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrate"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blocked"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS delivery reports"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Request a delivery report for each SMS that you send"</string>
diff --git a/res/values-en-rIN/cm_strings.xml b/res/values-en-rIN/cm_strings.xml
new file mode 100644
index 0000000..9266637
--- /dev/null
+++ b/res/values-en-rIN/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Swipe to delete</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Swipe to the right to delete a conversation</string>
+    <string name="notification_channel_messages_title">Messages</string>
+</resources>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 3a642fb..1e481ce 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Delete"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archive"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Unarchive"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Turn off notifications"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Turn on notifications"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Add contact"</string>
     <string name="action_download" msgid="7786338136368564146">"Download"</string>
     <string name="action_send" msgid="377635240181672039">"Send"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Advanced"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Debug"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifications"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Sound"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifications"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silent"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrate"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blocked"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS delivery reports"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Request a delivery report for each SMS that you send"</string>
diff --git a/res/values-es-rMX/cm_strings.xml b/res/values-es-rMX/cm_strings.xml
new file mode 100644
index 0000000..722a825
--- /dev/null
+++ b/res/values-es-rMX/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Deslizar para eliminar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Deslize a la derecha para borrar una conversación</string>
+    <string name="notification_channel_messages_title">Mensajes</string>
+</resources>
diff --git a/res/values-es-rUS/cm_strings.xml b/res/values-es-rUS/cm_strings.xml
new file mode 100644
index 0000000..6d8f458
--- /dev/null
+++ b/res/values-es-rUS/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Deslizar para borrar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Deslice a la derecha para borrar una conversación</string>
+    <string name="notification_channel_messages_title">Mensajes</string>
+</resources>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index f474514..02d09c2 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Eliminar"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archivo"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Eliminar del archivo"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desactivar notificaciones"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activar notificaciones"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Agregar contacto"</string>
     <string name="action_download" msgid="7786338136368564146">"Descargar"</string>
     <string name="action_send" msgid="377635240181672039">"Enviar"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avanzada"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Depurar"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificaciones"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Sonido"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificaciones"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silencio"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqueado"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Informes de entrega de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Solicitar un informe de entrega al enviar un SMS"</string>
diff --git a/res/values-es/cm_strings.xml b/res/values-es/cm_strings.xml
new file mode 100644
index 0000000..afe4d37
--- /dev/null
+++ b/res/values-es/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Deslizar para eliminar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Deslize a la derecha para borrar una conversación</string>
+</resources>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 98e0a1d..2d42bfe 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Eliminar"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archivar"</string>
     <string name="action_unarchive" msgid="139681611159869493">"No archivar"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desactivar notificaciones"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activar notificaciones"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Añadir contacto"</string>
     <string name="action_download" msgid="7786338136368564146">"Descargar"</string>
     <string name="action_send" msgid="377635240181672039">"Enviar"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Opciones avanzadas"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Depurar"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificaciones"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Sonido"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificaciones"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silencio"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqueado"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Informes de entrega de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Solicitar un informe de entrega al enviar un SMS"</string>
diff --git a/res/values-et/cm_strings.xml b/res/values-et/cm_strings.xml
new file mode 100644
index 0000000..3188d6d
--- /dev/null
+++ b/res/values-et/cm_strings.xml
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="notification_channel_messages_title">Sõnumid</string>
+</resources>
diff --git a/res/values-et/strings.xml b/res/values-et/strings.xml
index e222a3e..1744bca 100644
--- a/res/values-et/strings.xml
+++ b/res/values-et/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Kustutamine"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arhiivimine"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Arhiivimise tühistamine"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Märguannete väljalülitamine"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Märguannete sisselülitamine"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Kontakti lisamine"</string>
     <string name="action_download" msgid="7786338136368564146">"Laadi alla"</string>
     <string name="action_send" msgid="377635240181672039">"Saada"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Täpsem"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Silumine"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Märguanded"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Heli"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Märguanded"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Hääletu"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibratsioon"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokeeritud"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-i edastamisaruanded"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Edastamisaruande taotlus iga saadetud SMS-i kohta"</string>
diff --git a/res/values-eu/cm_strings.xml b/res/values-eu/cm_strings.xml
new file mode 100644
index 0000000..6bd2c81
--- /dev/null
+++ b/res/values-eu/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Pasatu hatza ezabatzeko</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Pasatu hatza eskuinera elkarrizketa bat ezabatzeko</string>
+    <string name="notification_channel_messages_title">Mezuak</string>
+</resources>
diff --git a/res/values-eu/strings.xml b/res/values-eu/strings.xml
index 1703681..aed7927 100644
--- a/res/values-eu/strings.xml
+++ b/res/values-eu/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Ezabatu"</string>
     <string name="action_archive" msgid="5437034800324083170">"Artxibatu"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Kendu artxibotik"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desaktibatu jakinarazpenak"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Aktibatu jakinarazpenak"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Gehitu kontaktua"</string>
     <string name="action_download" msgid="7786338136368564146">"Deskargatu"</string>
     <string name="action_send" msgid="377635240181672039">"Bidali"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Ezarpen aurreratuak"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Araztu"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Jakinarazpenak"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Soinua"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Jakinarazpenak"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Isilik"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Egin dar-dar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokeatuta"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMSak entregatzearen txostenak"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Eskatu bidaltzen duzun SMS bakoitzaren entrega-txostena"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index a1bf9d8..e79af23 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"حذف"</string>
     <string name="action_archive" msgid="5437034800324083170">"بایگانی"</string>
     <string name="action_unarchive" msgid="139681611159869493">"لغو بایگانی"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"خاموش کردن اعلان‌ها"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"روشن کردن اعلان‌ها"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"افزودن مخاطب"</string>
     <string name="action_download" msgid="7786338136368564146">"دانلود"</string>
     <string name="action_send" msgid="377635240181672039">"ارسال"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"پیشرفته"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"اشکال‌زدایی"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"اعلان‌ها"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"صدا"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"اعلان‌ها"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"بی‌صدا"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"لرزش"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"مسدود شده"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"گزارش‌های تحویل پیامک"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"درخواست گزارش تحویل برای هر پیامکی که ارسال می‌کنید"</string>
diff --git a/res/values-fi/cm_strings.xml b/res/values-fi/cm_strings.xml
new file mode 100644
index 0000000..b099500
--- /dev/null
+++ b/res/values-fi/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Poista liu\'uttamalla</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Pyyhkäise oikealle poistaaksesi keskustelun</string>
+    <string name="notification_channel_messages_title">Viestit</string>
+</resources>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index a07825b..23352a0 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Poista"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arkistoi"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Poista arkistosta"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Poista ilmoitukset käytöstä"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Ota ilmoitukset käyttöön"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Lisää kontakti"</string>
     <string name="action_download" msgid="7786338136368564146">"Lataa"</string>
     <string name="action_send" msgid="377635240181672039">"Lähetä"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"Multimediaviesti"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Lisäasetukset"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Vianetsintä"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Ilmoitukset"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ääni"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Ilmoitukset"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Äänetön"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Värinä"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Estetty"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Tekstiviestin lähetystiedot"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Pyydä lähetystiedot kaikista lähettämistäsi tekstiviesteistä"</string>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index a626832..e4f0bb7 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Supprimer"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archiver"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Annuler l\'archivage"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Désactiver les notifications"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activer les notifications"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Ajouter un contact"</string>
     <string name="action_download" msgid="7786338136368564146">"Télécharger"</string>
     <string name="action_send" msgid="377635240181672039">"Envoyer"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"Message multimédia"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avancés"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Déboguer"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifications"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Son"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifications"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Mode silencieux"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibreur"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqué"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Accusés de réception des messages texte"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Demander un accusé de réception pour chaque texto envoyé"</string>
diff --git a/res/values-fr/cm_strings.xml b/res/values-fr/cm_strings.xml
new file mode 100644
index 0000000..a1558df
--- /dev/null
+++ b/res/values-fr/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Balayer pour supprimer</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Balayer vers la droite pour supprimer une conversation</string>
+    <string name="notification_channel_messages_title">Messages</string>
+</resources>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index b9f22af..a04d215 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Supprimer"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archiver"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Annuler l\'archivage"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Désactiver les notifications"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activer les notifications"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Ajouter un contact"</string>
     <string name="action_download" msgid="7786338136368564146">"Télécharger"</string>
     <string name="action_send" msgid="377635240181672039">"Envoyer"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Paramètres avancés"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Déboguer"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifications"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Son"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifications"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Mode silencieux"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibreur"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqué"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Accusés de réception de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Demander un accusé de réception pour chaque SMS envoyé"</string>
diff --git a/res/values-fur-rIT/cm_strings.xml b/res/values-fur-rIT/cm_strings.xml
new file mode 100644
index 0000000..938b616
--- /dev/null
+++ b/res/values-fur-rIT/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Scor par eliminâ</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Scor viers diestre par eliminâ une conversazion</string>
+    <string name="notification_channel_messages_title">Messaçs</string>
+</resources>
diff --git a/res/values-fy-rNL/cm_strings.xml b/res/values-fy-rNL/cm_strings.xml
new file mode 100644
index 0000000..6ef4d4d
--- /dev/null
+++ b/res/values-fy-rNL/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Feie om fuort te smiten</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Nei rjochts feie om in petear fuort te smiten</string>
+    <string name="notification_channel_messages_title">Berjochten</string>
+</resources>
diff --git a/res/values-gd/cm_strings.xml b/res/values-gd/cm_strings.xml
new file mode 100644
index 0000000..1c27942
--- /dev/null
+++ b/res/values-gd/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Grad-shlaighd airson a sguabadh às</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Grad-shlaighd gun taobh deas airson còmhradh a sguabadh às</string>
+    <string name="notification_channel_messages_title">Teachdaireachdan</string>
+</resources>
diff --git a/res/values-gl/cm_strings.xml b/res/values-gl/cm_strings.xml
new file mode 100644
index 0000000..70c39e7
--- /dev/null
+++ b/res/values-gl/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Esvarar para eliminar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Esvarar cara a dereita para eliminar unha conversa</string>
+    <string name="notification_channel_messages_title">Mensaxes</string>
+</resources>
diff --git a/res/values-gl/strings.xml b/res/values-gl/strings.xml
index 8a626c2..6dccb94 100644
--- a/res/values-gl/strings.xml
+++ b/res/values-gl/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Eliminar"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arquivar"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Cancelar o arquivado"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desactivar notificacións"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activar notificacións"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Engadir contacto"</string>
     <string name="action_download" msgid="7786338136368564146">"Descargar"</string>
     <string name="action_send" msgid="377635240181672039">"Enviar"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avanzado"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Depuración"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificacións"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Son"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificacións"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silencio"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqueado"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Informes de entrega de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Solicita un informe de entrega cando envías un SMS"</string>
diff --git a/res/values-gu/cm_strings.xml b/res/values-gu/cm_strings.xml
new file mode 100644
index 0000000..e542e01
--- /dev/null
+++ b/res/values-gu/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">હટાવા માટે સ્વાઇપ કરો</string>
+    <string name="swipe_to_delete_conversation_pref_summary">વાતચીત કાઢી નાખવા જમણી બાજુ સ્વાઇપ કરો</string>
+</resources>
diff --git a/res/values-gu/strings.xml b/res/values-gu/strings.xml
index 8d2adaf..74b593b 100644
--- a/res/values-gu/strings.xml
+++ b/res/values-gu/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"કાઢી નાખો"</string>
     <string name="action_archive" msgid="5437034800324083170">"આર્કાઇવ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"આર્કાઇવ.કરેલ નથી"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"સૂચનાઓ બંધ કરો"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"સૂચનાઓ ચાલુ કરો"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"સંપર્ક ઉમેરો"</string>
     <string name="action_download" msgid="7786338136368564146">"ડાઉનલોડ કરો"</string>
     <string name="action_send" msgid="377635240181672039">"મોકલો"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"વિગતવાર"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ડીબગ"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"સૂચનાઓ"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ધ્વનિ"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"સૂચનાઓ"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"શાંત"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"વાઇબ્રેટ"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"અવરોધિત"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS વિતરણ રિપોર્ટ્સ"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"તમે મોકલેલા દરેક SMS માટે વિતરણ રિપોર્ટની વિનંતી કરો"</string>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 7e7a780..7355fbe 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"हटाएं"</string>
     <string name="action_archive" msgid="5437034800324083170">"संग्रहीत करें"</string>
     <string name="action_unarchive" msgid="139681611159869493">"संग्रह से निकालें"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"नोटिफिकेशन बंद करें"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"नोटिफिकेशन चालू करें"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"संपर्क जोड़ें"</string>
     <string name="action_download" msgid="7786338136368564146">"डाउनलोड करें"</string>
     <string name="action_send" msgid="377635240181672039">"भेजें"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"अतिरिक्त सेटिंग"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"डीबग"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"नोटिफिकेशन"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ध्वनि"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"नोटिफिकेशन"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"मौन"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"वाइब्रेट"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"अवरोधित"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS वितरण रिपोर्ट"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"आपके द्वारा भेजे गए प्रत्येक SMS की वितरण रिपोर्ट का अनुरोध करें"</string>
diff --git a/res/values-hr/cm_strings.xml b/res/values-hr/cm_strings.xml
new file mode 100644
index 0000000..ddadc2d
--- /dev/null
+++ b/res/values-hr/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Prijeđite prstom da biste izbrisali</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Prstom prijeđite udesno da biste izbrisali razgovor</string>
+</resources>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index b8bb490..a4f4077 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -156,8 +156,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Izbriši"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arhiviraj"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Poništi arhiviranje"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Isključi obavijesti"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Uključi obavijesti"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Dodaj kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Preuzmi"</string>
     <string name="action_send" msgid="377635240181672039">"Pošalji"</string>
@@ -276,10 +274,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Napredno"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Otklanjanje pogrešaka"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Obavijesti"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Zvuk"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Obavijesti"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Bešumno"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibriranje"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokirano"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Izvješća o isporuci SMS-a"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Zahtijevanje izvješća o isporuci za svaki poslani SMS"</string>
diff --git a/res/values-hu/cm_strings.xml b/res/values-hu/cm_strings.xml
new file mode 100644
index 0000000..04c7b78
--- /dev/null
+++ b/res/values-hu/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Törléshez csúsztassa az ujját</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Húzza jobbra a beszélgetés törléséhez</string>
+    <string name="notification_channel_messages_title">Üzenetek</string>
+</resources>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index 9203514..c9f7245 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Törlés"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archiválás"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Archiválás visszavonása"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Értesítések kikapcsolása"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Értesítések bekapcsolása"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Névjegy hozzáadása"</string>
     <string name="action_download" msgid="7786338136368564146">"Letöltés"</string>
     <string name="action_send" msgid="377635240181672039">"Küldés"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Speciális"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Hibakeresés"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Értesítések"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Hang"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Értesítések"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Néma"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Rezgés"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Letiltva"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-kézbesítési jelentések"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Kézbesítési jelentés kérése minden elküldött SMS-ről"</string>
diff --git a/res/values-hy/strings.xml b/res/values-hy/strings.xml
index 4dd99b0..ff8ae49 100644
--- a/res/values-hy/strings.xml
+++ b/res/values-hy/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Ջնջել"</string>
     <string name="action_archive" msgid="5437034800324083170">"Արխիվ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Ապարխիվացնել"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Անջատել ծանուցումները"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Միացնել ծանուցումները"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Ավելացնել կոնտակտ"</string>
     <string name="action_download" msgid="7786338136368564146">"Ներբեռնել"</string>
     <string name="action_send" msgid="377635240181672039">"Ուղարկել"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Հավելյալ"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Կարգաբերում"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Ծանուցումներ"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ձայն"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Ծանուցումներ"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Լուռ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Թրթռոց"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Արգելափակված է"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-ի առաքման հաշվետվություններ"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Առաքման ծանուցում հայցել յուրաքանչյուր ուղարկվող հաղորդագրության համար"</string>
diff --git a/res/values-in/cm_strings.xml b/res/values-in/cm_strings.xml
new file mode 100644
index 0000000..ceb22c2
--- /dev/null
+++ b/res/values-in/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Usap untuk menghapus</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Usap ke kanan untuk menghapus percakapan</string>
+    <string name="notification_channel_messages_title">Pesan</string>
+</resources>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 3b65bb2..3aa443d 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Hapus"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arsipkan"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Batalkan pengarsipan"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Nonaktifkan pemberitahuan"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Aktifkan pemberitahuan"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Tambahkan kontak"</string>
     <string name="action_download" msgid="7786338136368564146">"Unduh"</string>
     <string name="action_send" msgid="377635240181672039">"Kirim"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Lanjutan"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Debug"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifikasi"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Suara"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifikasi"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Senyap"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Getar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Diblokir"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Laporan pengiriman SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Minta laporan pengiriman dari setiap SMS yang Anda kirimkan"</string>
diff --git a/res/values-is/cm_strings.xml b/res/values-is/cm_strings.xml
new file mode 100644
index 0000000..5d13fee
--- /dev/null
+++ b/res/values-is/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Strjúktu til að eyða</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Strjúktu til hægri til að eyða samtali</string>
+    <string name="notification_channel_messages_title">Skilaboð</string>
+</resources>
diff --git a/res/values-is/strings.xml b/res/values-is/strings.xml
index f02a11c..da76c21 100644
--- a/res/values-is/strings.xml
+++ b/res/values-is/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Eyða"</string>
     <string name="action_archive" msgid="5437034800324083170">"Setja í geymslu"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Taka úr geymslu"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Slökkva á tilkynningum"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Kveikja á tilkynningum"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Bæta tengilið við"</string>
     <string name="action_download" msgid="7786338136368564146">"Sækja"</string>
     <string name="action_send" msgid="377635240181672039">"Senda"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Ítarlegt"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Villuleita"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Tilkynningar"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Hljóð"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Tilkynningar"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Hljóðlaust"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Titringur"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Á bannlista"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS-skilatilkynningar"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Óska eftir skilatilkynningu fyrir hver send SMS-skilaboð"</string>
diff --git a/res/values-it/cm_strings.xml b/res/values-it/cm_strings.xml
new file mode 100644
index 0000000..0b048c0
--- /dev/null
+++ b/res/values-it/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Scorri per eliminare</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Scorri verso destra per cancellare una conversazione</string>
+    <string name="notification_channel_messages_title">Messaggi</string>
+</resources>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index f041793..6f02c73 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Elimina"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archivio"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Annulla archiviazione"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Disattiva notifiche"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Attiva notifiche"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Aggiungi contatto"</string>
     <string name="action_download" msgid="7786338136368564146">"Scarica"</string>
     <string name="action_send" msgid="377635240181672039">"Invia"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avanzate"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Debug"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notifiche"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Suono"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notifiche"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silenzioso"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrazione"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloccato"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Rapporti di consegna SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Richiedi conferma di recapito per ogni SMS inviato"</string>
diff --git a/res/values-iw/cm_strings.xml b/res/values-iw/cm_strings.xml
new file mode 100644
index 0000000..5b4f7a9
--- /dev/null
+++ b/res/values-iw/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">החלק כדי למחוק</string>
+    <string name="swipe_to_delete_conversation_pref_summary">החלק ימינה כדי למחוק שיחה</string>
+</resources>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 3f80e3c..4822d37 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"מחק"</string>
     <string name="action_archive" msgid="5437034800324083170">"העבר לארכיון"</string>
     <string name="action_unarchive" msgid="139681611159869493">"הוצאה מארכיון"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"כבה התראות"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"הפעל התראות"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"הוסף איש קשר"</string>
     <string name="action_download" msgid="7786338136368564146">"הורד"</string>
     <string name="action_send" msgid="377635240181672039">"שלח"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"מתקדם"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ניפוי באגים"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"הודעות"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"צליל"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"הודעות"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"מצב שקט"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"רטט"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"חסום"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"‏דוחות מסירת SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"‏בקש דוח מסירה לכל SMS שאתה שולח"</string>
diff --git a/res/values-ja/cm_strings.xml b/res/values-ja/cm_strings.xml
new file mode 100644
index 0000000..39cb83d
--- /dev/null
+++ b/res/values-ja/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">スワイプして削除</string>
+    <string name="swipe_to_delete_conversation_pref_summary">右にスワイプしてスレッドを削除する</string>
+    <string name="notification_channel_messages_title">メッセージ</string>
+</resources>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index a3a513e..8eb36c8 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"削除"</string>
     <string name="action_archive" msgid="5437034800324083170">"アーカイブ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"アーカイブ解除"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"通知を無効化"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"通知を有効化"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"連絡先を追加"</string>
     <string name="action_download" msgid="7786338136368564146">"ダウンロード"</string>
     <string name="action_send" msgid="377635240181672039">"送信"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"詳細設定"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"デバッグ"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"通知"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"通知音"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"通知"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"マナーモード"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"バイブレーション"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ブロック済み"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS受取確認通知"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"送信するSMSの配信レポートを毎回リクエストする"</string>
diff --git a/res/values-ka/cm_strings.xml b/res/values-ka/cm_strings.xml
new file mode 100644
index 0000000..bafc417
--- /dev/null
+++ b/res/values-ka/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">გადასმით წაშლა</string>
+    <string name="swipe_to_delete_conversation_pref_summary">თითის მარჯვნივ გადასმა, საუბრის წასაშლელად</string>
+    <string name="notification_channel_messages_title">შეტყობინებები</string>
+</resources>
diff --git a/res/values-ka/strings.xml b/res/values-ka/strings.xml
index 8a2cd5e..8c1a010 100644
--- a/res/values-ka/strings.xml
+++ b/res/values-ka/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"წაშლა"</string>
     <string name="action_archive" msgid="5437034800324083170">"დაარქივება"</string>
     <string name="action_unarchive" msgid="139681611159869493">"დეარქივაცია"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"შეტყობინებების გამორთვა"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"შეტყობინებების ჩართვა"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"კონტაქტის დამატება"</string>
     <string name="action_download" msgid="7786338136368564146">"ჩამოტვირთვა"</string>
     <string name="action_send" msgid="377635240181672039">"გაგზავნა"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"გაფართოებული"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"გამართვა"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"შეტყობინებები"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ხმა"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"შეტყობინებები"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"დადუმებული"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"ვიბრაცია"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"დაბლოკილი"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS მისვლის შეტყობინებები"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ყოველ გაგზავნილ SMS-ზე მიწოდების დადასტურების მოთხოვნა"</string>
diff --git a/res/values-kab-rDZ/cm_strings.xml b/res/values-kab-rDZ/cm_strings.xml
new file mode 100644
index 0000000..e9c79e1
--- /dev/null
+++ b/res/values-kab-rDZ/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Zuɣer akken ad-tekkseḍ</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Zuɣer ar uyeffus iwakken ad-tekkseḍ adiwenni</string>
+    <string name="notification_channel_messages_title">Iznan</string>
+</resources>
diff --git a/res/values-kk/strings.xml b/res/values-kk/strings.xml
index 386e8ef..17dc0c9 100644
--- a/res/values-kk/strings.xml
+++ b/res/values-kk/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Жою"</string>
     <string name="action_archive" msgid="5437034800324083170">"Мұрағаттау"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Мұрағаттан шығару"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Хабарландыруларды өшіру"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Хабарландыруларды қосу"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Контакт қосу"</string>
     <string name="action_download" msgid="7786338136368564146">"Жүктеу"</string>
     <string name="action_send" msgid="377635240181672039">"Жіберу"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Кеңейтілген"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Күйін келтіру"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Хабарландырулар"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Дыбыс"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Хабарландырулар"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Үнсіз"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Дірілдеу"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Бөгелген"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS жеткізу туралы есептер"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Әр жіберілген SMS үшін жеткізу туралы есепті сұрау"</string>
diff --git a/res/values-km/strings.xml b/res/values-km/strings.xml
index fba58e2..bcfd77b 100644
--- a/res/values-km/strings.xml
+++ b/res/values-km/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"លុប"</string>
     <string name="action_archive" msgid="5437034800324083170">"ប័ណ្ណសារ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"មិន​ទុក​ក្នុង​ប័ណ្ណសារ"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"បិទ​ការ​ជូនដំណឹង"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"បើក​ការ​ជូនដំណឹង​"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"បន្ថែម​ទំនាក់ទំនង"</string>
     <string name="action_download" msgid="7786338136368564146">"ទាញ​យក"</string>
     <string name="action_send" msgid="377635240181672039">"ផ្ញើ"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"សារ MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"កម្រិត​ខ្ពស់"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"កែ​កំហុស"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"ការ​ជូនដំណឹង"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"សំឡេង"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"ការ​ជូនដំណឹង"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"ស្ងាត់"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"ញ័រ"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"បាន​ទប់ស្កាត់"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"របាយការណ៍​បញ្ជូន​សារ SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ស្នើ​​​របាយ​ការណ៍​​បញ្ជូន​សម្រាប់​សារ SMS ​នីមួយៗ​ដែល​អ្នក​ផ្ញើ"</string>
diff --git a/res/values-kn/cm_strings.xml b/res/values-kn/cm_strings.xml
new file mode 100644
index 0000000..3baba40
--- /dev/null
+++ b/res/values-kn/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">ಅಳಿಸಲು ಸ್ವೈಪ್ ಮಾಡಿ</string>
+    <string name="swipe_to_delete_conversation_pref_summary">ಒಂದು ಸಂವಾದವನ್ನು ಅಳಿಸಲು ಬಲಕ್ಕೆ ಸ್ವೈಪ್ ಮಾಡಿ</string>
+    <string name="notification_channel_messages_title">ಸಂದೇಶಗಳು</string>
+</resources>
diff --git a/res/values-kn/strings.xml b/res/values-kn/strings.xml
index b484009..4874690 100644
--- a/res/values-kn/strings.xml
+++ b/res/values-kn/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"ಅಳಿಸಿ"</string>
     <string name="action_archive" msgid="5437034800324083170">"ಆರ್ಕೈವ್ ಮಾಡಿ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ಅನ್‌ಆರ್ಕೈವ್ ಮಾಡು"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"ಅಧಿಸೂಚನೆಗಳನ್ನು ಆಫ್ ಮಾಡಿ"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"ಅಧಿಸೂಚನೆಗಳನ್ನು ಆನ್ ಮಾಡು"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"ಸಂಪರ್ಕ ಸೇರಿಸು"</string>
     <string name="action_download" msgid="7786338136368564146">"ಡೌನ್‌ಲೋಡ್‌"</string>
     <string name="action_send" msgid="377635240181672039">"ಕಳುಹಿಸು"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"ಸುಧಾರಿತ"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ಡೀಬಗ್ ಮಾಡು"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"ಅಧಿಸೂಚನೆಗಳು"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ಶಬ್ದ"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"ಅಧಿಸೂಚನೆಗಳು"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"ಶಾಂತ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"ವೈಬ್ರೇಟ್‌‌"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS ವಿತರಣಾ ವರದಿಗಳು"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ನೀವು ಕಳುಹಿಸುವ ಪ್ರತಿ SMS ಗೂ ವಿತರಣೆ ವರದಿಯನ್ನು ವಿನಂತಿಸಿ"</string>
diff --git a/res/values-ko/cm_strings.xml b/res/values-ko/cm_strings.xml
new file mode 100644
index 0000000..915af89
--- /dev/null
+++ b/res/values-ko/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">밀어서 삭제</string>
+    <string name="swipe_to_delete_conversation_pref_summary">오른쪽으로 밀어 대화 삭제</string>
+    <string name="notification_channel_messages_title">메시지</string>
+</resources>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index 1faec2a..07c5842 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"삭제"</string>
     <string name="action_archive" msgid="5437034800324083170">"보관처리"</string>
     <string name="action_unarchive" msgid="139681611159869493">"보관 취소"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"알림 사용 중지"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"알림 사용"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"연락처 추가"</string>
     <string name="action_download" msgid="7786338136368564146">"다운로드"</string>
     <string name="action_send" msgid="377635240181672039">"전송"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"고급"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"디버그"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"알림"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"소리"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"알림"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"무음"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"진동"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"차단됨"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS 전송 보고"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"모든 SMS에 대해 전송 확인 요청"</string>
diff --git a/res/values-ky/strings.xml b/res/values-ky/strings.xml
index 96b6d86..444169b 100644
--- a/res/values-ky/strings.xml
+++ b/res/values-ky/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Жок кылуу"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архивдөө"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Архивден чыгаруу"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Эскертмелерди өчүрүү"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Эскертмелерди күйгүзүү"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Байланыш кошуу"</string>
     <string name="action_download" msgid="7786338136368564146">"Жүктөп алуу"</string>
     <string name="action_send" msgid="377635240181672039">"Жөнөтүү"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Өркүндөтүлгөн"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Мүчүлүштүктөрдү таап оңдоо"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Эскертмелер"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Үн"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Эскертмелер"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Үнсүз"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Дирилдөө"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Бөгөттөлгөн"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS жеткирүү кабарлары"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Ар бир жөнөтүлгөн SMS билдирүүсүнүн алынгандыгын кабарлап коюну өтүнүү"</string>
diff --git a/res/values-ldrtl/styles.xml b/res/values-ldrtl/styles.xml
index de4d9e8..0c4e862 100644
--- a/res/values-ldrtl/styles.xml
+++ b/res/values-ldrtl/styles.xml
@@ -74,10 +74,6 @@
         <item name="android:textColor">@color/conversation_list_name</item>
     </style>
 
-    <style name="ConversationListNotificationBellPaddingStyle">
-        <item name="android:paddingEnd">@dimen/conversation_list_notification_bell_padding</item>
-    </style>
-
     <style name="ComposeMessageViewFrameLayoutStyle">
         <item name="android:paddingEnd">@dimen/compose_message_send_button_padding_right</item>
     </style>
diff --git a/res/values-lo/strings.xml b/res/values-lo/strings.xml
index 4911499..d673e97 100644
--- a/res/values-lo/strings.xml
+++ b/res/values-lo/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"​ລຶບ"</string>
     <string name="action_archive" msgid="5437034800324083170">"ຈັດເກັບ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ຖອດອອກຈາກແຟ້ມ"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"ປິດ​ການ​ແຈ້ງເຕືອນ"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"ເປີດ​ການ​ແຈ້ງເຕືອນ"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"ເພີ່ມ​ລາຍ​ຊື່​ຜູ່​ຕິດ​ຕໍ່"</string>
     <string name="action_download" msgid="7786338136368564146">"ດາວໂຫລດ"</string>
     <string name="action_send" msgid="377635240181672039">"ສົ່ງ"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"​ຂັ້ນ​ສູງ"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ດີບັ໊ກ"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"ການແຈ້ງເຕືອນ"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ສຽງ"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"ການແຈ້ງເຕືອນ"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"ປິດສຽງ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"ສັ່ນເຕືອນ"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ບລັອກ​ແລ້ວ"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"​ລາຍ​ງານ​ຜົນ​ການສົ່ງ SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"​ຂໍ​ລາຍ​ງານຜົນ​ການ​ສົ່ງ​ສຳ​ລັບ​ແຕ່​ລະ​ SMS ທີ່​ທ່ານ​ສົ່ງ"</string>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index 0430221..d5e9cf0 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Ištrinti"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archyvuoti"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Išarchyvuoti"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Išjungti pranešimus"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Įjungti pranešimus"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Pridėti kontaktą"</string>
     <string name="action_download" msgid="7786338136368564146">"Atsisiųsti"</string>
     <string name="action_send" msgid="377635240181672039">"Siųsti"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Išplėstiniai"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Derinti"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Pranešimai"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Garsas"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Pranešimai"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Tylus"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibravimas"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Užblokuota"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS pristatymo ataskaitos"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Pateikti kiekvieno išsiųsto SMS pristatymo ataskaitos užklausą"</string>
diff --git a/res/values-lu/cm_strings.xml b/res/values-lu/cm_strings.xml
new file mode 100644
index 0000000..f6e1e99
--- /dev/null
+++ b/res/values-lu/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Wësche fir ze läschen</string>
+    <string name="swipe_to_delete_conversation_pref_summary">No riets Wësche fir eng Konversatioun ze läschen</string>
+</resources>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index f598c77..fb8ed75 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -156,8 +156,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Dzēst"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arhivēt"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Izņemt no arhīva"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Izslēgt paziņojumus"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Ieslēgt paziņojumus"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Pievienot kontaktpersonu"</string>
     <string name="action_download" msgid="7786338136368564146">"Lejupielādēt"</string>
     <string name="action_send" msgid="377635240181672039">"Sūtīt"</string>
@@ -276,10 +274,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"Multiziņa"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Papildu"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Atkļūdot"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Paziņojumi"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Signāls"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Paziņojumi"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Klusums"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrozvans"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloķēts"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Īsziņu piegādes atskaites"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Pieprasiet piegādes atskaiti par katru sūtīto īsziņu."</string>
diff --git a/res/values-mk/strings.xml b/res/values-mk/strings.xml
index 16f60c9..92ed946 100644
--- a/res/values-mk/strings.xml
+++ b/res/values-mk/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Бришење"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архивирање"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Извади од архива"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Исклучи известувања"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Вклучи известувања"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Додај контакт"</string>
     <string name="action_download" msgid="7786338136368564146">"Преземи"</string>
     <string name="action_send" msgid="377635240181672039">"Испрати"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"ММС"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Напредни"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Отстрани грешка"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Известувања"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Звук"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Известувања"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"На тивко"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Вибрации"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Блокирано"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Извештаи за испорака на СМС"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Побарајте извештај за испорака за секоја СМС што ја испраќате"</string>
diff --git a/res/values-ml/cm_strings.xml b/res/values-ml/cm_strings.xml
new file mode 100644
index 0000000..0f78c2c
--- /dev/null
+++ b/res/values-ml/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">ഇല്ലാതാക്കാൻ സ്വൈപ്പുചെയ്യുക</string>
+    <string name="swipe_to_delete_conversation_pref_summary">ഒരു സംഭാഷണം ഇല്ലാതാക്കാന്‍ വലതുവശത്തെക്ക് സ്വൈപ്ചെയ്യുക</string>
+</resources>
diff --git a/res/values-ml/strings.xml b/res/values-ml/strings.xml
index b292525..7c36401 100644
--- a/res/values-ml/strings.xml
+++ b/res/values-ml/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"ഇല്ലാതാക്കുക"</string>
     <string name="action_archive" msgid="5437034800324083170">"ആര്‍ക്കൈവുചെയ്യുക"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ആർക്കൈവുചെയ്‌തത് മാറ്റുക"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"അറിയിപ്പുകൾ ഓഫാക്കുക"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"അറിയിപ്പുകൾ ഓണാക്കുക"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"കോൺടാക്റ്റ് ചേർക്കുക"</string>
     <string name="action_download" msgid="7786338136368564146">"ഡൗൺലോഡ്"</string>
     <string name="action_send" msgid="377635240181672039">"അയയ്‌ക്കുക"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"വിപുലം"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ഡീബഗ്"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"അറിയിപ്പുകൾ"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ശബ്‌ദം"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"അറിയിപ്പുകൾ"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"നിശബ്‌ദം"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"വൈബ്രേറ്റുചെയ്യുക"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"തടഞ്ഞിരിക്കുന്നു"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS ഡെലിവറി റിപ്പോർട്ടുകൾ"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"അയയ്‌ക്കുന്ന ഓരോ SMS-നും ഒരു ഡെലിവറി റിപ്പോർട്ട് അഭ്യർത്ഥിക്കുക"</string>
diff --git a/res/values-mn/strings.xml b/res/values-mn/strings.xml
index f3edd91..78178a2 100644
--- a/res/values-mn/strings.xml
+++ b/res/values-mn/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Устгах"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архивлах"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Архиваас гаргах"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Мэдэгдэл унтраах"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Мэдэгдлүүдийг асаах"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Харилцагч нэмэх"</string>
     <string name="action_download" msgid="7786338136368564146">"Татаж авах"</string>
     <string name="action_send" msgid="377635240181672039">"Илгээх"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Дэлгэрэнгүй"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Дебаг"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Мэдэгдэл"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Дуу"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Мэдэгдэл"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Чимээгүй"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Чичиргээ"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Хориглогдсон"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS хүргэлтийн репорт"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Өөрийн илгээх SMS бүрт хүргэлтийн репорт хүснэ үү"</string>
diff --git a/res/values-mr/cm_strings.xml b/res/values-mr/cm_strings.xml
new file mode 100644
index 0000000..4284ac0
--- /dev/null
+++ b/res/values-mr/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">हटवण्यासाठी स्वाइप करा</string>
+    <string name="swipe_to_delete_conversation_pref_summary">संभाषण हटवन्यासाठी उजविकडे स्वाइप करा</string>
+</resources>
diff --git a/res/values-mr/strings.xml b/res/values-mr/strings.xml
index ff585ba..9486919 100644
--- a/res/values-mr/strings.xml
+++ b/res/values-mr/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"हटवा"</string>
     <string name="action_archive" msgid="5437034800324083170">"संग्रहण करा"</string>
     <string name="action_unarchive" msgid="139681611159869493">"संग्रहण रद्द करा"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"सूचना बंद करा"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"सूचना चालू करा"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"संपर्क जोडा"</string>
     <string name="action_download" msgid="7786338136368564146">"डाउनलोड करा"</string>
     <string name="action_send" msgid="377635240181672039">"पाठवा"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"प्रगत"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"डीबग करणे"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"सूचना"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ध्वनी"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"सूचना"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"मूक"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"कंपन"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"अवरोधित केले"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS वितरण अहवाल"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"आपण पाठविता त्या प्रत्‍येक SMS साठी वितरण अहवालाची विनंती करा"</string>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index 3094e1d..834c133 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Padam"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arkib"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Nyaharkib"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Matikan pemberitahuan"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Hidupkan pemberitahuan"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Tambah kenalan"</string>
     <string name="action_download" msgid="7786338136368564146">"Muat turun"</string>
     <string name="action_send" msgid="377635240181672039">"Hantar"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Lanjutan"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Nyahpepijat"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Pemberitahuan"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Bunyi"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Pemberitahuan"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Senyap"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Bergetar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Disekat"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Laporan penghantaran SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Minta laporan penghantaran untuk setiap SMS yang anda hantar"</string>
diff --git a/res/values-my/strings.xml b/res/values-my/strings.xml
index 26df42e..59423ce 100644
--- a/res/values-my/strings.xml
+++ b/res/values-my/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"ဖျက်ရန်"</string>
     <string name="action_archive" msgid="5437034800324083170">"မော်ကွန်း"</string>
     <string name="action_unarchive" msgid="139681611159869493">"မော်ကွန်းမှထုတ်ယူရန်"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"အက​ြောင်းကြားချက်များ ပိတ်ရန်"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"အကြောင်းကြားချက်များ ဖွင့်ရန်"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"အဆက်အသွယ် ထည့်ရန်"</string>
     <string name="action_download" msgid="7786338136368564146">"ဒေါင်းလုဒ် လုပ်ရန်"</string>
     <string name="action_send" msgid="377635240181672039">"ပို့ရန်"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"ရုပ်သံစာ"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"အဆင့်မြင့်"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ဒီဘာဂ်"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"အကြောင်းကြားချက်များ"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"အသံ"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"အကြောင်းကြားချက်များ"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"အသံတိတ်ရန်"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"တုန်ခါရန်"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ပိတ်ဆို့ထား"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS ဖြန့်ဝေမှု အစီရင်ခံစာများ"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"သင် ပို့လိုက်သော စာတိုင်း အတွက် ပို့ပြီးကြောင်း အစီရင်ခံစာကို တောင်းဆိုမည်"</string>
diff --git a/res/values-nb/cm_strings.xml b/res/values-nb/cm_strings.xml
new file mode 100644
index 0000000..da6bddf
--- /dev/null
+++ b/res/values-nb/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Dra for å slette</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Sveip til høyre for å slette en samtale</string>
+</resources>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index ca04e94..a1fafb9 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Slett"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arkivér"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Fjern fra arkivet"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Slå av varsler"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Slå på varsler"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Legg til kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Last ned"</string>
     <string name="action_send" msgid="377635240181672039">"Send"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avansert"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Feilsøk"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Varsler"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Lyd"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Varsler"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Stille"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrer"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokkert"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Leveringsrapporter for SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Be om leveringsrapport for hver SMS du sender"</string>
diff --git a/res/values-ne/strings.xml b/res/values-ne/strings.xml
index b269345..c371c33 100644
--- a/res/values-ne/strings.xml
+++ b/res/values-ne/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"मेटाउनुहोस्"</string>
     <string name="action_archive" msgid="5437034800324083170">"अभिलेख"</string>
     <string name="action_unarchive" msgid="139681611159869493">"अभिलेखबाट निकाल्नुहोस्"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"सूचनाहरू बन्द गर्नुहोस्"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"सूचनाहरू सुचारु गर्नुहोस्"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"सम्पर्क थप्नुहोस्"</string>
     <string name="action_download" msgid="7786338136368564146">"डाउनलोड गर्नुहोस्"</string>
     <string name="action_send" msgid="377635240181672039">"पठाउनुहोस्"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"उन्नत"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"डिबग"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"सूचनाहरू"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"आवाज"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"सूचनाहरू"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"मौन"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"कम्पन गर्नुहोस्"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"अवरूद्ध गरियो"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS वितरण प्रतिवेदनहरू"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"तपाईँले पठाउनु हुने हरेक SMS को लागि पुगेको खबर अनुरोध गर्नुहोस्"</string>
diff --git a/res/values-night/lineage_colors.xml b/res/values-night/lineage_colors.xml
new file mode 100644
index 0000000..b4c0038
--- /dev/null
+++ b/res/values-night/lineage_colors.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2016 The CyanogenMod Project
+    Copyright (C) 2018, 2022-2023 The LineageOS Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources>
+    <color name="lineage_accent">@*android:color/system_accent1_100</color>
+
+    <color name="window_background">@*android:color/system_neutral1_900</color>
+
+    <color name="compose_send_text_background_color">@*android:color/system_neutral1_600</color>
+</resources>
diff --git a/res/values-nl/cm_strings.xml b/res/values-nl/cm_strings.xml
new file mode 100644
index 0000000..da7ec5a
--- /dev/null
+++ b/res/values-nl/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Vegen om te verwijderen</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Naar rechts vegen om een gesprek te verwijderen</string>
+    <string name="notification_channel_messages_title">Berichten</string>
+</resources>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 8312dcc..32d4033 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Verwijderen"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archiveren"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Terugzetten uit archief"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Meldingen uitschakelen"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Meldingen inschakelen"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Contact toevoegen"</string>
     <string name="action_download" msgid="7786338136368564146">"Downloaden"</string>
     <string name="action_send" msgid="377635240181672039">"Verzenden"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"Mms"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Geavanceerd"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Fouten opsporen"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Meldingen"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Geluid"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Meldingen"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Stil"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Trillen"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Geblokkeerd"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Bezorgingsrapporten voor sms"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Ontvangstbevestiging vragen voor elke verzonden sms"</string>
diff --git a/res/values-or/cm_strings.xml b/res/values-or/cm_strings.xml
new file mode 100644
index 0000000..45a24c5
--- /dev/null
+++ b/res/values-or/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">ବିଲୋପ କରିବାକୁ ସ୍ଵାଇପ୍ କରନ୍ତୁ</string>
+    <string name="swipe_to_delete_conversation_pref_summary">ବିଲୋପ କରିବା ପାଇଁ ଡାହାଣକୁ ସ୍ଵାଇପ୍ କରନ୍ତୁ</string>
+</resources>
diff --git a/res/values-pa/strings.xml b/res/values-pa/strings.xml
index 3ccc046..a744e28 100644
--- a/res/values-pa/strings.xml
+++ b/res/values-pa/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"ਮਿਟਾਓ"</string>
     <string name="action_archive" msgid="5437034800324083170">"ਆਰਕਾਈਵ ਕਰੋ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ਅਨਆਰਕਾਈਵ ਕਰੋ"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"ਸੂਚਨਾਵਾਂ ਬੰਦ ਕਰੋ"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"ਸੂਚਨਾਵਾਂ ਚਾਲੂ ਕਰੋ"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"ਸੰਪਰਕ ਜੋੜੋ"</string>
     <string name="action_download" msgid="7786338136368564146">"ਡਾਊਨਲੋਡ ਕਰੋ"</string>
     <string name="action_send" msgid="377635240181672039">"ਭੇਜੋ"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"ਉੱਨਤ"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ਡੀਬਗ ਕਰੋ"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"ਸੂਚਨਾਵਾਂ"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ਅਵਾਜ਼"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"ਸੂਚਨਾਵਾਂ"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"ਸਾਈਲੈਂਟ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"ਵਾਈਬ੍ਰੇਟ"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ਬਲੌਕ ਕੀਤਾ"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS ਡਿਲੀਵਰੀ ਰਿਪੋਰਟਾਂ"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ਤੁਸੀਂ ਜੋ ਵੀ SMS ਭੇਜੋ ਉਸ ਹਰੇਕ ਲਈ ਇੱਕ ਡਿਲੀਵਰੀ ਰਿਪੋਰਟ ਦੀ ਬੇਨਤੀ ਕਰੋ"</string>
diff --git a/res/values-pl/cm_strings.xml b/res/values-pl/cm_strings.xml
new file mode 100644
index 0000000..53b5429
--- /dev/null
+++ b/res/values-pl/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Przesuń, aby usunąć</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Przesuń w prawo, aby usunąć konwersację</string>
+    <string name="notification_channel_messages_title">Wiadomości</string>
+</resources>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index 1f21955..57b9055 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Usuń"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archiwizuj"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Przywróć z archiwum"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Wyłącz powiadomienia"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Włącz powiadomienia"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Dodaj kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Pobierz"</string>
     <string name="action_send" msgid="377635240181672039">"Wyślij"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Zaawansowane"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Debugowanie"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Powiadomienia"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Dźwięk"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Powiadomienia"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Cichy"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Wibracje"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Zablokowany"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Raporty doręczeń SMS-ów"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Otrzymuj raport o dostarczeniu każdego wysłanego SMS-a"</string>
diff --git a/res/values-pt-rBR/cm_strings.xml b/res/values-pt-rBR/cm_strings.xml
new file mode 100644
index 0000000..7671c4f
--- /dev/null
+++ b/res/values-pt-rBR/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Deslize para excluir</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Deslize para a direita para excluir uma mensagem</string>
+    <string name="notification_channel_messages_title">Mensagens</string>
+</resources>
diff --git a/res/values-pt-rPT/cm_strings.xml b/res/values-pt-rPT/cm_strings.xml
new file mode 100644
index 0000000..5dd39f4
--- /dev/null
+++ b/res/values-pt-rPT/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Deslize para apagar</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Deslize para a direita para apagar uma conversa</string>
+    <string name="notification_channel_messages_title">Mensagens</string>
+</resources>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index 5c64052..dccb976 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Eliminar"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arquivar"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Retirar do arquivo"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desativar as notificações"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Ativar notificações"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Adicionar contacto"</string>
     <string name="action_download" msgid="7786338136368564146">"Transferir"</string>
     <string name="action_send" msgid="377635240181672039">"Enviar"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avançadas"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Depurar"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificações"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Som"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificações"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silencioso"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrar"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqueado"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Relatórios de entrega de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Solicitar um relatório de entrega para cada SMS enviada"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index bd60502..5481105 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Excluir"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arquivar"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Desarquivar"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Desativar notificações"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Ativar notificações"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Adicionar contato"</string>
     <string name="action_download" msgid="7786338136368564146">"Fazer o download"</string>
     <string name="action_send" msgid="377635240181672039">"Enviar"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avançadas"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Depurar"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificações"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Som"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificações"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silencioso"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibração"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloqueado"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Relat. de entrega de SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Solicitar um relatório de entrega para cada SMS enviado"</string>
diff --git a/res/values-ro/cm_strings.xml b/res/values-ro/cm_strings.xml
new file mode 100644
index 0000000..46bdbfa
--- /dev/null
+++ b/res/values-ro/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Glisare pentru a șterge</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Glisați spre dreapta pentru a şterge o conversație</string>
+    <string name="notification_channel_messages_title">Mesaje</string>
+</resources>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 2f9c5a7..426dbc7 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -156,8 +156,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Ștergeți"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arhivați"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Dezarhivați"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Dezactivați notificările"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Activați notificările"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Adăugați o persoană"</string>
     <string name="action_download" msgid="7786338136368564146">"Descărcați"</string>
     <string name="action_send" msgid="377635240181672039">"Trimiteți"</string>
@@ -276,10 +274,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avansate"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Remedierea erorilor"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Notificări"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Sunet"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Notificări"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Silențios"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrații"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blocat"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Rapoarte de trimitere a SMS-urilor"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Solicitați un raport de expediere pentru fiecare mesaj SMS trimis"</string>
diff --git a/res/values-ru/cm_strings.xml b/res/values-ru/cm_strings.xml
new file mode 100644
index 0000000..4308fda
--- /dev/null
+++ b/res/values-ru/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Свайп для удаления</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Свайп вправо для удаления разговора</string>
+    <string name="notification_channel_messages_title">Сообщения</string>
+</resources>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 132f8c4..5e6f205 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Удалить"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архив"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Вернуть из архива"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Отключить оповещения"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Включить оповещения"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Добавить контакт"</string>
     <string name="action_download" msgid="7786338136368564146">"Скачать"</string>
     <string name="action_send" msgid="377635240181672039">"Отправить"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Дополнительные настройки"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Выполнить отладку"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Уведомления"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Звуковой сигнал"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Уведомления"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Без звука"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Вибросигнал"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Заблокировано"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Отчеты о доставке SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Запрашивать отчет о доставке для всех отправляемых SMS"</string>
diff --git a/res/values-si/strings.xml b/res/values-si/strings.xml
index 80c7cd7..87d9339 100644
--- a/res/values-si/strings.xml
+++ b/res/values-si/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"මකන්න"</string>
     <string name="action_archive" msgid="5437034800324083170">"සංරක්ෂිත කරන්න"</string>
     <string name="action_unarchive" msgid="139681611159869493">"සංරක්ෂණය නොකළ"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"දැනුම්දීම් අක්‍රිය කරන්න"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"දැනුම්දීම් සක්‍රිය කරන්න"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"සම්බන්ධතාවය එක් කරන්න"</string>
     <string name="action_download" msgid="7786338136368564146">"බාගන්න"</string>
     <string name="action_send" msgid="377635240181672039">"යවන්න"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"උසස්"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"නිදොස්කරණය"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"දැනුම්දීම්"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ශබ්දය"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"දැනුම්දීම්"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"නිහඬ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"කම්පනය වන්න"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"අවහිර කරන ලදි"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS යැවීමේ වාර්තාව"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ඔබ යවන ලද සෑම පණිවිඩයකටම යැවීමේ වාර්තාවක් ඉල්ලන්න"</string>
diff --git a/res/values-sk/cm_strings.xml b/res/values-sk/cm_strings.xml
new file mode 100644
index 0000000..5d1cd3c
--- /dev/null
+++ b/res/values-sk/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Potiahnutím zmazať</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Potiahnutím vpravo zmazať konverzáciu</string>
+    <string name="notification_channel_messages_title">Správy</string>
+</resources>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index 1056a95..2a4d1d9 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Odstrániť"</string>
     <string name="action_archive" msgid="5437034800324083170">"Archivovať"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Vybrať z archívu"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Vypnúť upozornenia"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Zapnúť upozornenia"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Pridať kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Stiahnuť"</string>
     <string name="action_send" msgid="377635240181672039">"Odoslať"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Rozšírené"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Ladiť"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Upozornenia"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Zvuk"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Upozornenia"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Tichý režim"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibrovanie"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokované"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Prehľady doručovania SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Vyžadovať potvrdenie o doručení každej odoslanej SMS"</string>
diff --git a/res/values-sl/cm_strings.xml b/res/values-sl/cm_strings.xml
new file mode 100644
index 0000000..b8dde7b
--- /dev/null
+++ b/res/values-sl/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Poteg za brisanje</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Povlecite desno za izbris pogovora</string>
+    <string name="notification_channel_messages_title">Sporočila</string>
+</resources>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 6c85318..4215d10 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Izbriši"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arhiviraj"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Odstrani iz arhiva"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Izklop obvestil"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Vklop obvestil"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Dodaj stik"</string>
     <string name="action_download" msgid="7786338136368564146">"Prenos"</string>
     <string name="action_send" msgid="377635240181672039">"Pošlji"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Dodatno"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Odpravljanje napak"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Obvestila"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Zvok"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Obvestila"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Tiho"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibriranje"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blokirano"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Poročila o dostavi sporočil SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Zahtevanje poročila o dostavi za vsak poslan SMS"</string>
diff --git a/res/values-sq/cm_strings.xml b/res/values-sq/cm_strings.xml
new file mode 100644
index 0000000..e6e8968
--- /dev/null
+++ b/res/values-sq/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Rrëshqit gishtin për të fshirë</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Rrëshqit gishtin djathtas për të fshirë një bisedë</string>
+    <string name="notification_channel_messages_title">Mesazhet</string>
+</resources>
diff --git a/res/values-sq/strings.xml b/res/values-sq/strings.xml
index f7b858c..db46554 100644
--- a/res/values-sq/strings.xml
+++ b/res/values-sq/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Fshi"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arkivo"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Hiq nga arkiva"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Çaktivizo njoftimet"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Aktivizo njoftimet"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Shto kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Shkarko"</string>
     <string name="action_send" msgid="377635240181672039">"Dërgo"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Të përparuara"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Korrigjo"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Njoftime"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Zëri"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Njoftime"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Hesht"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Dridh"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"I bllokuar"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Raportet e dorëzimit të SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Kërko një raport dorëzimi për çdo SMS që dërgon"</string>
diff --git a/res/values-sr/cm_strings.xml b/res/values-sr/cm_strings.xml
new file mode 100644
index 0000000..16adb08
--- /dev/null
+++ b/res/values-sr/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Брисање превлачењем</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Превуците удесно да бисте избрисали конверзацију.</string>
+</resources>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index a1262a0..041c4c9 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -156,8 +156,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Избриши"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архивирај"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Опозови архивирање"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Искључи обавештења"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Укључи обавештења"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Додај контакт"</string>
     <string name="action_download" msgid="7786338136368564146">"Преузми"</string>
     <string name="action_send" msgid="377635240181672039">"Пошаљи"</string>
@@ -276,10 +274,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Напредно"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Отклањање грешака"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Обавештења"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Звук"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Обавештења"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Нечујно"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Вибрација"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Блокирано"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Извештаји о испоруци SMS-ова"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Захтевајте извештај о испоруци за сваки послати SMS"</string>
diff --git a/res/values-sv/cm_strings.xml b/res/values-sv/cm_strings.xml
new file mode 100644
index 0000000..4f47f58
--- /dev/null
+++ b/res/values-sv/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Svep för att radera</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Svep till höger för att ta bort en konversation</string>
+    <string name="notification_channel_messages_title">Meddelanden</string>
+</resources>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 01d5820..4d81a4c 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Ta bort"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arkivera"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Ångra arkivering"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Inaktivera aviseringar"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Aktivera aviseringar"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Lägg till kontakt"</string>
     <string name="action_download" msgid="7786338136368564146">"Ladda ned"</string>
     <string name="action_send" msgid="377635240181672039">"Skicka"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"Mms"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Avancerat"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Felsökning"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Aviseringar"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ljud"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Aviseringar"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Tyst"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Vibration"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Blockerad"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Sms-leveransrapporter"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Begär en leveransrapport för varje sms du skickar"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index 87b12ae..7005d50 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Futa"</string>
     <string name="action_archive" msgid="5437034800324083170">"Kumbukumbu"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Ondoa kwenye kumbukumbu"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Zima arifa"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Washa arifa"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Ongeza anwani"</string>
     <string name="action_download" msgid="7786338136368564146">"Pakua"</string>
     <string name="action_send" msgid="377635240181672039">"Tuma"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Mahiri"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Tatua"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Arifa"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Mlio"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Arifa"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Kimya"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Tetema"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Imezuiwa"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Ripoti za kupokelewa kwa SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Omba ripoti ya kuthibitisha kuwa kila SMS unayotuma imewasilishwa"</string>
diff --git a/res/values-ta/cm_strings.xml b/res/values-ta/cm_strings.xml
new file mode 100644
index 0000000..b27a462
--- /dev/null
+++ b/res/values-ta/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">நீக்குவதற்கு தேய்க்கவும்</string>
+    <string name="swipe_to_delete_conversation_pref_summary">ஒரு உரையாடல் நீக்குவதற்கு வலது பக்கமாக தேய்க்கவும்</string>
+</resources>
diff --git a/res/values-ta/strings.xml b/res/values-ta/strings.xml
index 327e454..a11ff77 100644
--- a/res/values-ta/strings.xml
+++ b/res/values-ta/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"நீக்கு"</string>
     <string name="action_archive" msgid="5437034800324083170">"காப்பிடு"</string>
     <string name="action_unarchive" msgid="139681611159869493">"காப்பிட வேண்டாம்"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"அறிவிப்புகளை முடக்கு"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"அறிவிப்புகளை இயக்கு"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"தொடர்பைச் சேர்"</string>
     <string name="action_download" msgid="7786338136368564146">"இறக்கு"</string>
     <string name="action_send" msgid="377635240181672039">"அனுப்பு"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"மேம்பட்டவை"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"பிழைத்திருத்து"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"அறிவிப்புகள்"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ஒலி"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"அறிவிப்புகள்"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"நிசப்தம்"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"அதிர்வு"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"தடுக்கப்பட்டது"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS டெலிவரி அறிக்கைகள்"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"நீங்கள் அனுப்பும் ஒவ்வொரு SMS க்கும் வழங்கல் அறிக்கையைக் கோரவும்"</string>
diff --git a/res/values-te/cm_strings.xml b/res/values-te/cm_strings.xml
new file mode 100644
index 0000000..4ae1a91
--- /dev/null
+++ b/res/values-te/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">తొలగించడానికి స్వైప్ చెయ్యండి</string>
+    <string name="swipe_to_delete_conversation_pref_summary">ఒక సంభాషణను తొలగించడానికి కుడి ప్రక్కన స్వైప్ చెయ్యండి</string>
+</resources>
diff --git a/res/values-te/strings.xml b/res/values-te/strings.xml
index f2dabb2..62c3f46 100644
--- a/res/values-te/strings.xml
+++ b/res/values-te/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"తొలగించు"</string>
     <string name="action_archive" msgid="5437034800324083170">"ఆర్కైవ్ చేయి"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ఆర్కైవ్ నుండి తీసివేయి"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"నోటిఫికేషన్‌లను ఆఫ్ చేయి"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"నోటిఫికేషన్‌లను ఆన్ చేయి"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"పరిచయాన్ని జోడించు"</string>
     <string name="action_download" msgid="7786338136368564146">"డౌన్‌లోడ్ చేయి"</string>
     <string name="action_send" msgid="377635240181672039">"పంపు"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"అధునాతనం"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"డీబగ్"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"నోటిఫికేషన్‌లు"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"ధ్వని"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"నోటిఫికేషన్‌లు"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"నిశ్శబ్దం"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"వైబ్రేట్"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"బ్లాక్ చేయబడింది"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS బట్వాడా నివేదికలు"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"మీరు పంపే ప్రతి SMS కోసం బట్వాడా నివేదికను అభ్యర్థించండి"</string>
diff --git a/res/values-th/cm_strings.xml b/res/values-th/cm_strings.xml
new file mode 100644
index 0000000..881513f
--- /dev/null
+++ b/res/values-th/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">กวาดนิ้วเพื่อลบ</string>
+    <string name="swipe_to_delete_conversation_pref_summary">กวาดนิ้วไปทางขวาเพื่อลบการสนทนา</string>
+    <string name="notification_channel_messages_title">ข้อความ</string>
+</resources>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 3768ca8..96d17e3 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"ลบ"</string>
     <string name="action_archive" msgid="5437034800324083170">"เก็บถาวร"</string>
     <string name="action_unarchive" msgid="139681611159869493">"ยกเลิกการเก็บถาวร"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"ปิดการแจ้งเตือน"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"เปิดการแจ้งเตือน"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"เพิ่มรายชื่อติดต่อ"</string>
     <string name="action_download" msgid="7786338136368564146">"ดาวน์โหลด"</string>
     <string name="action_send" msgid="377635240181672039">"ส่ง"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"ขั้นสูง"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"แก้ไขข้อบกพร่อง"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"การแจ้งเตือน"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"เสียง"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"การแจ้งเตือน"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"เงียบ"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"สั่น"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"ถูกบล็อก"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"รายงานการส่ง SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"ขอรายงานการส่ง SMS แต่ละครั้ง"</string>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index 091949f..1cf0a38 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"I-delete"</string>
     <string name="action_archive" msgid="5437034800324083170">"I-archive"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Alisin sa archive"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"I-off ang mga notification"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"I-on ang mga notification"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Magdagdag ng contact"</string>
     <string name="action_download" msgid="7786338136368564146">"I-download"</string>
     <string name="action_send" msgid="377635240181672039">"Ipadala"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Advanced"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"I-debug"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Mga Notification"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Tunog"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Mga Notification"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Naka-silent"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Mag-vibrate"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Naka-block"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Mga ulat sa pagpapadala ng SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Humiling ng ulat sa paghahatid para sa bawat SMS na iyong ipinapadala"</string>
diff --git a/res/values-tr/cm_strings.xml b/res/values-tr/cm_strings.xml
new file mode 100644
index 0000000..af9ed6b
--- /dev/null
+++ b/res/values-tr/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Silmek için kaydırın</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Bir sohbeti silmek için sağa kaydırın</string>
+    <string name="notification_channel_messages_title">Mesajlar</string>
+</resources>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 7d7fefb..468e934 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Sil"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arşivle"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Arşivden kaldır"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Bildirimleri devre dışı bırak"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Bildirimleri aç"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Kişi ekle"</string>
     <string name="action_download" msgid="7786338136368564146">"İndir"</string>
     <string name="action_send" msgid="377635240181672039">"Gönder"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Gelişmiş"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Hata Ayıklama"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Bildirimler"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ses"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Bildirimler"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Sessiz"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Titreşim"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Engellendi"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS iletim raporları"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Gönderilen her SMS için bir iletim raporu iste"</string>
diff --git a/res/values-ug/cm_strings.xml b/res/values-ug/cm_strings.xml
new file mode 100644
index 0000000..499dea0
--- /dev/null
+++ b/res/values-ug/cm_strings.xml
@@ -0,0 +1,20 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">سۈرۈلسە ئۆچۈرىدۇ</string>
+    <string name="swipe_to_delete_conversation_pref_summary">دىئالوگنى ئۆچۈرۈش ئۈچۈن ئوڭغا سىيرىڭ</string>
+</resources>
diff --git a/res/values-uk/cm_strings.xml b/res/values-uk/cm_strings.xml
new file mode 100644
index 0000000..699d277
--- /dev/null
+++ b/res/values-uk/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Проведіть для видалення</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Проведіть вправо для видалення бесіди</string>
+    <string name="notification_channel_messages_title">Повідомлення</string>
+</resources>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 1fa8a2e..cc58175 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -165,8 +165,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Видалити"</string>
     <string name="action_archive" msgid="5437034800324083170">"Архів"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Розархівувати"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Вимкнути сповіщення"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Увімкнути сповіщення"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Додати контакт"</string>
     <string name="action_download" msgid="7786338136368564146">"Завантажити"</string>
     <string name="action_send" msgid="377635240181672039">"Надіслати"</string>
@@ -294,10 +292,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Додатково"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Налагодження"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Сповіщення"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Сигнал"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Сповіщення"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Без звуку"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Вібросигнал"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Заблоковано"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Звіти про доставку SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Запитувати звіт про доставку для кожного надісланого SMS"</string>
diff --git a/res/values-ur/strings.xml b/res/values-ur/strings.xml
index 68217ca..6c5daa7 100644
--- a/res/values-ur/strings.xml
+++ b/res/values-ur/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"حذف کریں"</string>
     <string name="action_archive" msgid="5437034800324083170">"آرکائیو کریں"</string>
     <string name="action_unarchive" msgid="139681611159869493">"آرکائیو سے نکالیں"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"اطلاعات آف کریں"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"اطلاعات آن کریں"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"رابطہ شامل کریں"</string>
     <string name="action_download" msgid="7786338136368564146">"ڈاؤن لوڈ کریں"</string>
     <string name="action_send" msgid="377635240181672039">"بھیجیں"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"جدید ترین"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"ڈیبگ کریں"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"اطلاعات"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"آواز"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"اطلاعات"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"خاموش"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"وائبریٹ"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"مسدود"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"‏SMS ڈیلیوری کی رپورٹس"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"‏اپنے ذریعہ بھیجے جانے والے ہر SMS کی ایک ڈیلیوری رپورٹ کی درخواست کریں"</string>
diff --git a/res/values-uz/strings.xml b/res/values-uz/strings.xml
index 4d84ca1..86611a2 100644
--- a/res/values-uz/strings.xml
+++ b/res/values-uz/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"O‘chirish"</string>
     <string name="action_archive" msgid="5437034800324083170">"Arxivlash"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Arxivdan chiqarish"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Bildirishnomalarni o‘chirib qo‘yish"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Bildirishnomalarni yoqish"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Kontakt qo‘shish"</string>
     <string name="action_download" msgid="7786338136368564146">"Yuklab olish"</string>
     <string name="action_send" msgid="377635240181672039">"Yuborish"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Qo‘shimcha"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Tuzatish"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Bildirishnomalar"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Ovoz"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Bildirishnomalar"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Ovozsiz"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Tebranish"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Bloklandi"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"SMS xabarlarning yetkazilganlik hisobotlari"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Yuborilgan har bir SMS uchun yetkazilganlik hisobotini talab qilish"</string>
diff --git a/res/values-v27/styles.xml b/res/values-v27/styles.xml
new file mode 100644
index 0000000..22e94ed
--- /dev/null
+++ b/res/values-v27/styles.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2018 The LineageOS Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources>
+    <style name="BugleBaseTheme" parent="Theme.AppCompat.Light.DarkActionBar">
+        <item name="android:forceDarkAllowed">true</item>
+        <item name="android:navigationBarColor">@color/navigation_bar_bg</item>
+        <item name="android:navigationBarDividerColor">@color/navigation_bar_divider</item>
+        <item name="android:windowLightNavigationBar">true</item>
+    </style>
+</resources>
diff --git a/res/values-vi/cm_strings.xml b/res/values-vi/cm_strings.xml
new file mode 100644
index 0000000..3863843
--- /dev/null
+++ b/res/values-vi/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">Vuốt để xóa</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Vuốt sang phải để xóa một cuộc trò chuyện</string>
+    <string name="notification_channel_messages_title">Tin nhắn</string>
+</resources>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 4923847..6613edf 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Xóa"</string>
     <string name="action_archive" msgid="5437034800324083170">"Lưu trữ"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Hủy lưu trữ"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Tắt thông báo"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Bật thông báo"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Thêm liên hệ"</string>
     <string name="action_download" msgid="7786338136368564146">"Tải xuống"</string>
     <string name="action_send" msgid="377635240181672039">"Gửi"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Nâng cao"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Gỡ lỗi"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Thông báo"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Âm thanh"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Thông báo"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Im lặng"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Rung"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Đã chặn"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Báo cáo gửi SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Yêu cầu báo cáo gửi cho mỗi SMS bạn gửi"</string>
diff --git a/res/values-zh-rCN/cm_strings.xml b/res/values-zh-rCN/cm_strings.xml
new file mode 100644
index 0000000..074c13f
--- /dev/null
+++ b/res/values-zh-rCN/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">滑动删除邮件</string>
+    <string name="swipe_to_delete_conversation_pref_summary">向右滑动以删除会话</string>
+    <string name="notification_channel_messages_title">短信</string>
+</resources>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 77dbfae..dd97f75 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"删除"</string>
     <string name="action_archive" msgid="5437034800324083170">"归档"</string>
     <string name="action_unarchive" msgid="139681611159869493">"取消归档"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"关闭通知"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"开启通知"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"添加到通讯录"</string>
     <string name="action_download" msgid="7786338136368564146">"下载"</string>
     <string name="action_send" msgid="377635240181672039">"发送"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"彩信"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"高级"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"调试"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"通知"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"提示音"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"通知"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"静音"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"振动"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"已屏蔽"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"短信送达情况报告"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"了解您发的每条短信的送达情况"</string>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index a5c690f..28d16e4 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"刪除"</string>
     <string name="action_archive" msgid="5437034800324083170">"封存"</string>
     <string name="action_unarchive" msgid="139681611159869493">"取消封存"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"關閉通知"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"開啟通知"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"新增聯絡人"</string>
     <string name="action_download" msgid="7786338136368564146">"下載"</string>
     <string name="action_send" msgid="377635240181672039">"傳送"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"進階"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"除錯"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"通知"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"音效"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"通知"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"靜音"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"震動"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"已封鎖"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"短訊傳送報告"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"每次發送短訊後要求發送報告"</string>
diff --git a/res/values-zh-rTW/cm_strings.xml b/res/values-zh-rTW/cm_strings.xml
new file mode 100644
index 0000000..93353a0
--- /dev/null
+++ b/res/values-zh-rTW/cm_strings.xml
@@ -0,0 +1,21 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="swipe_to_delete_conversation_pref_title">滑動刪除</string>
+    <string name="swipe_to_delete_conversation_pref_summary">向右滑動即可刪除對話</string>
+    <string name="notification_channel_messages_title">訊息</string>
+</resources>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index c911ea7..fd95762 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"刪除"</string>
     <string name="action_archive" msgid="5437034800324083170">"封存"</string>
     <string name="action_unarchive" msgid="139681611159869493">"取消封存"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"關閉通知"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"開啟通知"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"新增聯絡人"</string>
     <string name="action_download" msgid="7786338136368564146">"下載"</string>
     <string name="action_send" msgid="377635240181672039">"傳送"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"多媒體訊息"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"進階"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"偵錯"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"通知"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"音效"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"通知"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"靜音"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"震動"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"已封鎖"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"簡訊傳送報告"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"傳送簡訊後要求傳送回條"</string>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index 0221bcd..3ba95ec 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -147,8 +147,6 @@
     <string name="action_delete" msgid="4076795795307486019">"Susa"</string>
     <string name="action_archive" msgid="5437034800324083170">"Faka kungobo yomlando"</string>
     <string name="action_unarchive" msgid="139681611159869493">"Ungafaki kungobo yomlando"</string>
-    <string name="action_notification_off" msgid="4823658797441716246">"Vala izaziso"</string>
-    <string name="action_notification_on" msgid="8244389452685364211">"Vula isaziso"</string>
     <string name="action_add_contact" msgid="8248615862739848672">"Engeza oxhumana naye"</string>
     <string name="action_download" msgid="7786338136368564146">"Landa"</string>
     <string name="action_send" msgid="377635240181672039">"Thumela"</string>
@@ -258,10 +256,8 @@
     <string name="mms_messaging_category_pref_title" msgid="4816815152658525660">"I-MMS"</string>
     <string name="advanced_category_pref_title" msgid="6411454224069259687">"Okuthuthukisiwe"</string>
     <string name="debug_category_pref_title" msgid="8765138968242505061">"Lungisa iphutha"</string>
-    <string name="notifications_enabled_pref_title" msgid="4127288731844373795">"Izaziso"</string>
-    <string name="notification_sound_pref_title" msgid="3685506528957337849">"Umsindo"</string>
+    <string name="notifications_pref_title" msgid="4127288731844373795">"Izaziso"</string>
     <string name="silent_ringtone" msgid="8073534180322059814">"Thulile"</string>
-    <string name="notification_vibrate_pref_title" msgid="6668564570045187390">"Dlidlizela"</string>
     <string name="blocked_pref_title" msgid="2560554234438548817">"Ivinjelwe"</string>
     <string name="delivery_reports_pref_title" msgid="5115727259825309087">"Imibiko yokulethwa kwe-SMS"</string>
     <string name="delivery_reports_pref_summary" msgid="4272502420621500421">"Cela umbiko wokuthumela we-SMS ngayinye oyithumelayo"</string>
diff --git a/res/values/cm_strings.xml b/res/values/cm_strings.xml
new file mode 100644
index 0000000..9f2382c
--- /dev/null
+++ b/res/values/cm_strings.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2015 The Android Open Source Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <!-- Swipe to delete conversation -->
+    <string name="swipe_to_delete_conversation_pref_title">Swipe to delete</string>
+    <string name="swipe_to_delete_conversation_pref_summary">Swipe to the right to delete a conversation</string>
+
+    <!-- Notification channel -->
+    <string name="notification_channel_messages_title">Messages</string>
+</resources>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 0ecd2c2..c4e0fb4 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -15,16 +15,16 @@
     limitations under the License.
 -->
 <resources>
-    <color name="primary_color">#689F38</color>
+    <color name="primary_color">@*android:color/system_accent1_600</color>
     <color name="permission_check_activity_background">@color/primary_color</color>
 
     <!--  Action bar -->
-    <color name="action_bar_title_text_color">#ffffff</color>
-    <color name="action_bar_background_color">@color/primary_color</color>
-    <color name="action_bar_background_color_dark">#537F2D</color>
-    <color name="contextual_action_bar_background_color">#ffffff</color>
-    <color name="archived_conversation_action_bar_background_color">#9D9D9D</color>
-    <color name="archived_conversation_action_bar_background_color_dark">#838383</color>
+    <color name="action_bar_title_text_color">@*android:color/system_neutral1_0</color>
+    <color name="action_bar_background_color">@android:color/system_accent1_600</color>
+    <color name="action_bar_background_color_dark">@*android:color/system_accent1_700</color>
+    <color name="contextual_action_bar_background_color">@*android:color/system_accent1_600</color>
+    <color name="archived_conversation_action_bar_background_color">@*android:color/system_accent1_700</color>
+    <color name="archived_conversation_action_bar_background_color_dark">@*android:color/system_accent1_600</color>
 
     <!-- Conversation list -->
     <color name="conversation_list_item_read">#636363</color>
@@ -60,15 +60,15 @@
     <color name="message_text_color_incoming">#ffffffff</color>
     <color name="message_text_color_incoming_download_failed">#6a6a6a</color>
     <color name="message_text_color_outgoing">#ff323232</color>
-    <color name="conversation_background">#eeeeee</color>
+    <color name="conversation_background">@color/window_background</color>
     <color name="conversation_edge_effect">#9d9d9d</color>
-    <color name="compose_message_send_color">@color/primary_color</color>
+    <color name="compose_message_send_color">@color/lineage_accent</color>
     <color name="compose_message_send_color_pressed">#999999</color>
     <color name="message_bubble_color_outgoing">#ffffffff</color>
     <color name="message_error_bubble_color_incoming">#e2e2e2</color>
     <color name="message_audio_button_color_incoming">#ffffffff</color>
-    <color name="message_bubble_color_selected">#8BC34A</color>
-    <color name="message_image_selected_tint">#80689F38</color>
+    <color name="message_bubble_color_selected">@*android:color/system_accent3_300</color>
+    <color name="message_image_selected_tint">#7f040000</color>
     <color name="generic_video_icon">#ff808080</color>
 
     <!-- Base color used for color filtering. -->
@@ -87,7 +87,7 @@
     <color name="compose_contact_divider">#44000000</color>
     <color name="contact_picker_tab_pressed">#ddffffff</color>
     <color name="contact_picker_tab_underline">@android:color/white</color>
-    <color name="contact_list_alphabet_header">@color/primary_color</color>
+    <color name="contact_list_alphabet_header">@color/lineage_accent</color>
     <color name="contact_picker_background">#ffffff</color>
     <color name="chips_dropdown_background_activated">#4285f4</color>
     <color name="chips_dropdown_background_pressed">#ededed</color>
@@ -102,6 +102,21 @@
     <color name="gallery_image_pressed">#6733b5e5</color>
     <color name="attachment_preview_more_items_text_background">#44000000</color>
 
+    <array name="letter_tile_colors">
+        <item>@*android:color/system_accent1_300</item>
+        <item>@*android:color/system_accent2_300</item>
+        <item>@*android:color/system_accent3_300</item>
+        <item>@*android:color/system_accent1_400</item>
+        <item>@*android:color/system_accent2_400</item>
+        <item>@*android:color/system_accent3_400</item>
+        <item>@*android:color/system_accent1_500</item>
+        <item>@*android:color/system_accent2_500</item>
+        <item>@*android:color/system_accent3_500</item>
+        <item>@*android:color/system_accent1_600</item>
+        <item>@*android:color/system_accent2_600</item>
+        <item>@*android:color/system_accent3_600</item>
+    </array>
+
     <color name="letter_tile_font_color">#ffffff</color>
 
     <color name="audio_picker_level_primary_color">#29000000</color>
@@ -109,7 +124,7 @@
     <color name="audio_picker_hint_text_color">#40000000</color>
     <color name="audio_picker_timer_text_color">#323232</color>
     <color name="audio_attachment_timer_text_color">#323232</color>
-    <color name="audio_progress_bar_color">@color/primary_color</color>
+    <color name="audio_progress_bar_color">@color/lineage_accent</color>
 
     <color name="contact_picker_hint_text_color">#40000000</color>
 
@@ -122,19 +137,18 @@
     <color name="notification_subject_color">#99aaaaaa</color>
 
     <color name="participant_list_text_primary">#4d4d4d</color>
-    <color name="participant_list_text_secondary">#6d6d6d</color>
     <color name="people_and_options_header_text">#6d6d6d</color>
     <color name="people_and_options_list_divider">#cccccc</color>
 
-    <color name="fab_color">@color/primary_color</color>
-    <color name="fab_pressed_color">#3ea4dc</color>
+    <color name="fab_color">@color/lineage_accent</color>
+    <color name="fab_pressed_color">@*android:color/primary_device_default_light</color>
     <color name="fab_ripple">#40ffffff</color>
 
     <color name="message_body_size_text_color">#555555</color>
-    <color name="mms_indicator_color">#8BC34A</color>
+    <color name="mms_indicator_color">#681faf</color>
     <color name="list_empty_text">#6d6d6d</color>
     <color name="low_storage_action_item_color">#ff000000</color>
-    <color name="unblock_item_text_color">@color/primary_color</color>
+    <color name="unblock_item_text_color">@color/lineage_accent</color>
     <color name="open_conversation_animation_background_shadow">#40000000</color>
     <color name="compose_notification_bar_background">@color/primary_color</color>
 
@@ -145,7 +159,7 @@
     <color name="sim_indicator_color_light">#ffffff</color>
     <color name="sim_indicator_color_dark">#323232</color>
 
-    <color name="text_highlight_color">#80689F38</color>
+    <color name="text_highlight_color">@android:color/system_accent1_100</color>
     <color name="search_view_text_cursor">#b0dddddd</color>
 
     <color name="button_bar_action_button_text_color">#03a9f4</color>
diff --git a/res/values/config.xml b/res/values/config.xml
index 954f5ed..c3038fe 100644
--- a/res/values/config.xml
+++ b/res/values/config.xml
@@ -18,4 +18,7 @@
 <resources>
     <!-- The packaged version of APNs and MMS configurations -->
     <integer name="apnsAndMmsConfigsVersion">0</integer>
+
+    <!-- Use individual colors for contacts -->
+    <bool name="contact_colors">true</bool>
 </resources>
diff --git a/res/values/constants.xml b/res/values/constants.xml
index e494e95..7da36a1 100644
--- a/res/values/constants.xml
+++ b/res/values/constants.xml
@@ -21,8 +21,7 @@
     <string name="notifications_category_pref_key" translatable="false">notifications_category</string>
     <string name="mms_messaging_category_pref_key" translatable="false">mms_messaging_category</string>
     <string name="advanced_category_pref_key" translatable="false">advanced_category</string>
-    <string name="notifications_enabled_pref_key" translatable="false">notifications_enabled</string>
-    <bool name="notifications_enabled_pref_default" translatable="false">true</bool>
+    <string name="notifications_pref_key" translatable="false">notifications_enabled</string>
     <string name="notification_sound_pref_key" translatable="false">notification_sound</string>
     <string name="notification_vibration_pref_key" translatable="false">notification_vibration</string>
     <bool name="notification_vibration_pref_default" translatable="false">true</bool>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 0795ebc..952a0d7 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -32,9 +32,8 @@
     <dimen name="conversation_list_image_preview_corner_radius">3dp</dimen>
     <dimen name="conversation_list_image_preview_size">56dp</dimen>
     <dimen name="conversation_list_contact_icon_size">56dp</dimen>
-    <dimen name="conversation_message_contact_icon_size">42dp</dimen>
+    <dimen name="conversation_message_contact_icon_size">48dp</dimen>
     <dimen name="conversation_message_photo_min_size">96dp</dimen>
-    <dimen name="conversation_list_notification_bell_padding">4dp</dimen>
     <dimen name="conversation_list_empty_text_bottom_margin">30dp</dimen>
     <dimen name="blocked_participant_list_item_view_padding">16dp</dimen>
 
@@ -54,7 +53,7 @@
     <dimen name="compose_message_chip_padding">3dp</dimen>
     <dimen name="compose_message_fields_horizontal_margin">16dp</dimen>
     <dimen name="compose_message_font_size">16sp</dimen>
-    <dimen name="compose_message_attachment_padding_sides">20dp</dimen>
+    <dimen name="compose_message_attachment_padding_sides">0dp</dimen>
     <dimen name="compose_message_attachment_padding_topBottom">10dp</dimen>
     <dimen name="compose_message_chips_view_max_height">133dp</dimen>
     <dimen name="compose_message_subject_left_padding">52dp</dimen>
@@ -65,7 +64,7 @@
     <dimen name="compose_message_subject_cancel_left_margin">12dp</dimen>
     <dimen name="compose_message_mms_indicator_padding_top">2dp</dimen>
     <dimen name="compose_message_send_button_padding_right">12dp</dimen>
-    <dimen name="compose_message_text_box_padding_side">8dp</dimen>
+    <dimen name="compose_message_text_box_padding_side">16dp</dimen>
 
     <!-- Notification related dimensions. -->
     <dimen name="notification_wearable_image_height">240dp</dimen>
@@ -109,7 +108,6 @@
     <dimen name="progress_indicator_default_stroke_width">2dp</dimen>
     <dimen name="progress_indicator_default_radius">12dp</dimen>
     <dimen name="participant_list_text_size">18sp</dimen>
-    <dimen name="participant_list_detail_text_size">14sp</dimen>
     <dimen name="people_and_options_header_text_size">16sp</dimen>
     <dimen name="image_attachment_fallback_width">240dp</dimen>
     <dimen name="image_attachment_fallback_height">240dp</dimen>
diff --git a/res/values/lineage_colors.xml b/res/values/lineage_colors.xml
new file mode 100644
index 0000000..0203fe2
--- /dev/null
+++ b/res/values/lineage_colors.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2016 The CyanogenMod Project
+    Copyright (C) 2018, 2022-2023 The LineageOS Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources>
+    <color name="lineage_accent">@*android:color/system_accent1_600</color>
+
+    <color name="window_background">@*android:color/system_neutral1_50</color>
+
+    <color name="button_text">@*android:color/system_neutral1_900</color>
+
+    <color name="navigation_bar_bg">@*android:color/system_neutral1_10</color>
+    <color name="navigation_bar_divider">@*android:color/system_neutral1_800</color>
+
+    <color name="compose_send_text_background_color">@android:color/white</color>
+</resources>
diff --git a/res/values/lineage_constants.xml b/res/values/lineage_constants.xml
new file mode 100644
index 0000000..1975b6a
--- /dev/null
+++ b/res/values/lineage_constants.xml
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+    Copyright (C) 2016 The CyanogenMod Project
+
+    Licensed under the Apache License, Version 2.0 (the "License");
+    you may not use this file except in compliance with the License.
+    You may obtain a copy of the License at
+
+         http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing, software
+    distributed under the License is distributed on an "AS IS" BASIS,
+    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+    See the License for the specific language governing permissions and
+    limitations under the License.
+-->
+<resources>
+    <!-- Preference keys for user-visible settings -->
+    <!-- Application-wide settings -->
+    <string name="swipe_right_deletes_conversation_key" translatable="false">swipe_right_deletes_conversation</string>
+
+    <!-- This should really go into a config xml, but whoever wrote this app is an idiot, so follow their pattern -->
+    <bool name="swipe_right_deletes_conversation_default" translatable="false">false</bool>
+</resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index e5c442d..86db324 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -257,10 +257,6 @@
     <string name="action_archive">Archive</string>
     <!-- Action menu title for unarchiving selected conversations in conversation list -->
     <string name="action_unarchive">Unarchive</string>
-    <!-- Action menu title for turning off notification for the selected conversations in conversation list -->
-    <string name="action_notification_off">Turn off notifications</string>
-    <!-- Action menu title for turning on notification for the selected conversations in conversation list -->
-    <string name="action_notification_on">Turn on notifications</string>
     <!-- Action menu title for adding the contacts for the selected conversations in conversation list -->
     <string name="action_add_contact">Add contact</string>
     <!-- Action menu title for downloading failed message selected in conversation -->
@@ -440,13 +436,9 @@
     <!-- Preference category: Debug -->
     <string name="debug_category_pref_title">Debug</string>
     <!-- Title for the preference for whether or to notify the user of new messages -->
-    <string name="notifications_enabled_pref_title">Notifications</string>
+    <string name="notifications_pref_title">Notifications</string>
     <!-- Title for the notification sound preference -->
-    <string name="notification_sound_pref_title">Sound</string>
-    <!-- What to display in the settings screen for Ringtone when the user chooses "silent" [CHAR LIMIT=100]-->
     <string name="silent_ringtone">Silent</string>
-    <!-- Title for the preference for whether or not to vibrate with notifications -->
-    <string name="notification_vibrate_pref_title">Vibrate</string>
     <string name="blocked_pref_title">Blocked</string>
     <!-- Title for the preference for whether or not to request/show delivery reports for SMS -->
     <string name="delivery_reports_pref_title">SMS delivery reports</string>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 6f9be47..c690871 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -34,19 +34,25 @@
          <item name="android:dropDownListViewStyle">@style/DropDownListViewStyle</item>
          <item name="colorPrimary">@color/action_bar_background_color</item>
          <item name="colorPrimaryDark">@color/action_bar_background_color_dark</item>
-         <item name="colorAccent">@color/action_bar_background_color</item>
+         <item name="colorAccent">@color/lineage_accent</item>
          <item name="android:textColorHighlight">@color/text_highlight_color</item>
          <item name="actionBarStyle">@style/BugleActionBar</item>
          <item name="apnPreferenceStyle">@style/ApnPreference</item>
     </style>
 
+    <style name="LaunchTheme" parent="Theme.AppCompat.DayNight.DarkActionBar">
+         <item name="colorPrimary">@color/action_bar_background_color</item>
+         <item name="colorPrimaryDark">@color/action_bar_background_color_dark</item>
+    </style>
+
     <style name="BugleTheme.ConversationActivity"
         parent="@style/BugleTheme.ConversationActivityBase">
     </style>
 
     <style name="BugleTheme.ConversationActivityBase" parent="BugleTheme">
-        <item name="android:windowBackground">@color/conversation_background</item>
+        <item name="android:windowBackground">@color/window_background</item>
         <item name="windowActionBarOverlay">true</item>
+        <item name="colorAccent">@color/lineage_accent</item>
         <item name="android:fastScrollPreviewBackgroundLeft">@drawable/contacts_fastscroll_label_left</item>
         <item name="android:fastScrollPreviewBackgroundRight">@drawable/contacts_fastscroll_label_right</item>
     </style>
@@ -55,7 +61,7 @@
     </style>
 
     <style name="BugleTheme.ConversationListActivity" parent="BugleTheme">
-        <item name="android:windowBackground">@android:color/background_light</item>
+        <item name="android:windowBackground">@color/window_background</item>
     </style>
 
     <style name="BugleTheme.ArchivedConversationListActivity" parent="BugleTheme.ConversationListActivity">
@@ -64,6 +70,7 @@
     </style>
 
     <style name="BugleTheme.SettingsActivity" parent="BugleTheme">
+        <item name="android:windowBackground">@color/window_background</item>
         <item name="android:textSize">@dimen/settings_list_text_size</item>
     </style>
 
@@ -137,12 +144,14 @@
         <item name="android:fontFamily">sans-serif</item>
         <item name="android:paddingLeft">@dimen/compose_message_text_box_padding_side</item>
         <item name="android:paddingRight">@dimen/compose_message_text_box_padding_side</item>
+        <item name="android:layout_marginRight">8dp</item>
         <item name="android:minHeight">@dimen/conversation_message_contact_icon_size</item>
         <item name="android:maxLines">4</item>
         <item name="android:background">@null</item>
         <item name="android:scrollHorizontally">false</item>
         <item name="android:textCursorDrawable">@null</item>
         <item name="android:inputType">textShortMessage|textAutoCorrect|textCapSentences|textMultiLine</item>
+        <item name="android:colorAccent">@color/lineage_accent</item>
     </style>
 
     <style name="ConversationComposeSubjectText" parent="ConversationComposeSendText">
@@ -260,7 +269,7 @@
     <style name="ComposeMessageViewAttachMediaButtonStyle">
         <item name="android:paddingLeft">@dimen/compose_message_attachment_padding_sides</item>
         <item name="android:paddingRight">@dimen/compose_message_attachment_padding_sides</item>
-        <item name="android:background">?android:attr/selectableItemBackground</item>
+        <item name="android:background">?android:attr/selectableItemBackgroundBorderless</item>
     </style>
 
     <style name="ContactListItemViewStyle">
@@ -289,10 +298,6 @@
         <item name="android:textColor">@color/conversation_list_name</item>
     </style>
 
-    <style name="ConversationListNotificationBellPaddingStyle">
-        <item name="android:paddingRight">@dimen/conversation_list_notification_bell_padding</item>
-    </style>
-
     <style name="ComposeMessageViewFrameLayoutStyle">
         <item name="android:paddingRight">@dimen/compose_message_send_button_padding_right</item>
     </style>
@@ -345,12 +350,6 @@
         <item name="android:paddingRight">@dimen/copy_contact_dialog_right_padding</item>
     </style>
 
-    <style name="ParticipantListItemDetail">
-        <item name="android:textSize">@dimen/participant_list_detail_text_size</item>
-        <item name="android:textColor">@color/participant_list_text_secondary</item>
-        <item name="android:background">@null</item>
-    </style>
-
     <style name="PeopleListItemViewStyle">
         <item name="android:paddingLeft">16dp</item>
     </style>
diff --git a/res/xml-v21/preferences_application.xml b/res/xml-v21/preferences_application.xml
index 5d8ee4c..d650489 100644
--- a/res/xml-v21/preferences_application.xml
+++ b/res/xml-v21/preferences_application.xml
@@ -42,29 +42,17 @@
         android:defaultValue="@bool/send_sound_pref_default"
         android:persistent="true" />
 
-    <SwitchPreference
-        android:key="@string/notifications_enabled_pref_key"
-        android:title="@string/notifications_enabled_pref_title"
-        android:defaultValue="@bool/notifications_enabled_pref_default"
-        android:persistent="true"
-        android:disableDependentsState="false" />
-
-    <RingtonePreference
-        android:key="@string/notification_sound_pref_key"
-        android:title="@string/notification_sound_pref_title"
-        android:ringtoneType="notification"
-        android:showSilent="true"
-        android:showDefault="true"
-        android:persistent="true"
-        android:defaultValue=""
-        android:dependency="@string/notifications_enabled_pref_key" />
+    <Preference
+        android:key="@string/notifications_pref_key"
+        android:title="@string/notifications_pref_title"
+        android:persistent="true" />
 
     <SwitchPreference
-        android:key="@string/notification_vibration_pref_key"
-        android:title="@string/notification_vibrate_pref_title"
-        android:defaultValue="@bool/notification_vibration_pref_default"
-        android:persistent="true"
-        android:dependency="@string/notifications_enabled_pref_key" />
+        android:key="@string/swipe_right_deletes_conversation_key"
+        android:title="@string/swipe_to_delete_conversation_pref_title"
+        android:summary="@string/swipe_to_delete_conversation_pref_summary"
+        android:defaultValue="false"
+        android:persistent="true" />
 
     <PreferenceScreen
             android:key="@string/advanced_pref_key"
diff --git a/res/xml-v23/preferences_application.xml b/res/xml-v23/preferences_application.xml
index 8fbadc4..7370c4a 100644
--- a/res/xml-v23/preferences_application.xml
+++ b/res/xml-v23/preferences_application.xml
@@ -43,29 +43,17 @@
         android:defaultValue="@bool/send_sound_pref_default"
         android:persistent="true" />
 
-    <SwitchPreference
-        android:key="@string/notifications_enabled_pref_key"
-        android:title="@string/notifications_enabled_pref_title"
-        android:defaultValue="@bool/notifications_enabled_pref_default"
-        android:persistent="true"
-        android:disableDependentsState="false" />
-
-    <RingtonePreference
-        android:key="@string/notification_sound_pref_key"
-        android:title="@string/notification_sound_pref_title"
-        android:ringtoneType="notification"
-        android:showSilent="true"
-        android:showDefault="true"
-        android:persistent="true"
-        android:defaultValue=""
-        android:dependency="@string/notifications_enabled_pref_key" />
+    <Preference
+        android:key="@string/notifications_pref_key"
+        android:title="@string/notifications_pref_title"
+        android:persistent="true" />
 
     <SwitchPreference
-        android:key="@string/notification_vibration_pref_key"
-        android:title="@string/notification_vibrate_pref_title"
-        android:defaultValue="@bool/notification_vibration_pref_default"
-        android:persistent="true"
-        android:dependency="@string/notifications_enabled_pref_key" />
+        android:key="@string/swipe_right_deletes_conversation_key"
+        android:title="@string/swipe_to_delete_conversation_pref_title"
+        android:summary="@string/swipe_to_delete_conversation_pref_summary"
+        android:defaultValue="false"
+        android:persistent="true" />
 
     <PreferenceScreen
             android:key="@string/advanced_pref_key"
diff --git a/res/xml/preferences_application.xml b/res/xml/preferences_application.xml
index 7a18d09..7ca8dd7 100644
--- a/res/xml/preferences_application.xml
+++ b/res/xml/preferences_application.xml
@@ -42,29 +42,17 @@
         android:defaultValue="@bool/send_sound_pref_default"
         android:persistent="true" />
 
-    <CheckBoxPreference
-        android:key="@string/notifications_enabled_pref_key"
-        android:title="@string/notifications_enabled_pref_title"
-        android:defaultValue="@bool/notifications_enabled_pref_default"
-        android:persistent="true"
-        android:disableDependentsState="false" />
+    <Preference
+        android:key="@string/notifications_pref_key"
+        android:title="@string/notifications_pref_title"
+        android:persistent="true" />
 
-    <RingtonePreference
-        android:key="@string/notification_sound_pref_key"
-        android:title="@string/notification_sound_pref_title"
-        android:ringtoneType="notification"
-        android:showSilent="true"
-        android:showDefault="true"
-        android:persistent="true"
-        android:defaultValue=""
-        android:dependency="@string/notifications_enabled_pref_key" />
-
-    <CheckBoxPreference
-        android:key="@string/notification_vibration_pref_key"
-        android:title="@string/notification_vibrate_pref_title"
-        android:defaultValue="@bool/notification_vibration_pref_default"
-        android:persistent="true"
-        android:dependency="@string/notifications_enabled_pref_key" />
+    <SwitchPreference
+        android:key="@string/swipe_right_deletes_conversation_key"
+        android:title="@string/swipe_to_delete_conversation_pref_title"
+        android:summary="@string/swipe_to_delete_conversation_pref_summary"
+        android:defaultValue="false"
+        android:persistent="true" />
 
     <PreferenceScreen
             android:key="@string/advanced_pref_key"
diff --git a/src/com/android/messaging/datamodel/BugleDatabaseOperations.java b/src/com/android/messaging/datamodel/BugleDatabaseOperations.java
index c4e5fb8..4471b34 100644
--- a/src/com/android/messaging/datamodel/BugleDatabaseOperations.java
+++ b/src/com/android/messaging/datamodel/BugleDatabaseOperations.java
@@ -171,8 +171,7 @@
         final ArrayList<ParticipantData> participants =
                 getConversationParticipantsFromRecipients(recipients, refSubId);
 
-        return getOrCreateConversation(db, threadId, senderBlocked, participants, false, false,
-                null);
+        return getOrCreateConversation(db, threadId, senderBlocked, participants);
     }
 
     /**
@@ -190,7 +189,7 @@
         Assert.isNotMainThread();
         final ArrayList<ParticipantData> recipients = new ArrayList<>(1);
         recipients.add(recipient);
-        return getOrCreateConversation(db, threadId, senderBlocked, recipients, false, false, null);
+        return getOrCreateConversation(db, threadId, senderBlocked, recipients);
     }
 
     /**
@@ -200,15 +199,11 @@
      * @param threadId The message's thread
      * @param archived Flag whether the conversation should be created archived
      * @param participants list of conversation participants
-     * @param noNotification If notification should be disabled
-     * @param noVibrate If vibrate on notification should be disabled
-     * @param soundUri If there is custom sound URI
      * @return a conversation id
      */
     @DoesNotRunOnMainThread
     public static String getOrCreateConversation(final DatabaseWrapper db, final long threadId,
-            final boolean archived, final ArrayList<ParticipantData> participants,
-            boolean noNotification, boolean noVibrate, String soundUri) {
+            final boolean archived, final ArrayList<ParticipantData> participants) {
         Assert.isNotMainThread();
 
         // Check to see if this conversation is already in out local db cache
@@ -231,8 +226,7 @@
                         BugleDatabaseOperations.getOrCreateParticipantInTransaction(db, self);
                 // Create a new conversation
                 conversationId = BugleDatabaseOperations.createConversationInTransaction(
-                        db, threadId, conversationName, selfId, participants, archived,
-                        noNotification, noVibrate, soundUri);
+                        db, threadId, conversationName, selfId, participants, archived);
                 db.setTransactionSuccessful();
             } finally {
                 db.endTransaction();
@@ -357,15 +351,11 @@
      * @param threadId      The message's thread
      * @param selfId        The selfId to make default for this conversation
      * @param archived      Flag whether the conversation should be created archived
-     * @param noNotification If notification should be disabled
-     * @param noVibrate     If vibrate on notification should be disabled
-     * @param soundUri      The customized sound
      * @return The existing conversation id or new conversation id
      */
     static String createConversationInTransaction(final DatabaseWrapper dbWrapper,
             final long threadId, final String conversationName, final String selfId,
-            final List<ParticipantData> participants, final boolean archived,
-            boolean noNotification, boolean noVibrate, String soundUri) {
+            final List<ParticipantData> participants, final boolean archived) {
         // We want conversation and participant creation to be atomic
         Assert.isTrue(dbWrapper.getDatabase().inTransaction());
         boolean hasEmailAddress = false;
@@ -389,15 +379,6 @@
         if (archived) {
             values.put(ConversationColumns.ARCHIVE_STATUS, 1);
         }
-        if (noNotification) {
-            values.put(ConversationColumns.NOTIFICATION_ENABLED, 0);
-        }
-        if (noVibrate) {
-            values.put(ConversationColumns.NOTIFICATION_VIBRATION, 0);
-        }
-        if (!TextUtils.isEmpty(soundUri)) {
-            values.put(ConversationColumns.NOTIFICATION_SOUND_URI, soundUri);
-        }
 
         fillParticipantData(values, participants);
 
diff --git a/src/com/android/messaging/datamodel/BugleNotifications.java b/src/com/android/messaging/datamodel/BugleNotifications.java
index 3faee85..6df9e88 100644
--- a/src/com/android/messaging/datamodel/BugleNotifications.java
+++ b/src/com/android/messaging/datamodel/BugleNotifications.java
@@ -17,6 +17,8 @@
 package com.android.messaging.datamodel;
 
 import android.app.Notification;
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.Context;
 import android.content.Intent;
@@ -74,10 +76,10 @@
 import com.android.messaging.util.ImageUtils;
 import com.android.messaging.util.LogUtil;
 import com.android.messaging.util.NotificationPlayer;
+import com.android.messaging.util.NotificationsUtil;
 import com.android.messaging.util.OsUtil;
 import com.android.messaging.util.PendingIntentConstants;
 import com.android.messaging.util.PhoneUtils;
-import com.android.messaging.util.RingtoneUtil;
 import com.android.messaging.util.ThreadUtil;
 import com.android.messaging.util.UriUtil;
 
@@ -173,24 +175,24 @@
         }
     Assert.isNotMainThread();
         checkInitialized();
-
-        if (!shouldNotify()) {
-            if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) {
-                LogUtil.v(TAG, "Notifications disabled");
-            }
-            cancel(PendingIntentConstants.SMS_NOTIFICATION_ID);
-            return;
-        } else {
-            if ((coverage & UPDATE_MESSAGES) != 0) {
-                createMessageNotification(silent, conversationId);
-            }
+        if ((coverage & UPDATE_MESSAGES) != 0) {
+            createMessageNotification(silent, conversationId);
         }
+
         if ((coverage & UPDATE_ERRORS) != 0) {
             MessageNotificationState.checkFailedMessages();
         }
     }
 
     /**
+     * Play a sound to notify arrival of a class 0 message
+     *
+     */
+    public static void playClassZeroNotification() {
+        playObservableConversationNotificationSound(null);
+    }
+
+    /**
      * Cancel all notifications of a certain type.
      *
      * @param type Message or error notifications from Constants.
@@ -289,56 +291,6 @@
     }
 
     /**
-     * Returns {@code true} if incoming notifications should display a
-     * notification, {@code false} otherwise.
-     *
-     * @return true if the notification should occur
-     */
-    private static boolean shouldNotify() {
-        // If we're not the default sms app, don't put up any notifications.
-        if (!PhoneUtils.getDefault().isDefaultSmsApp()) {
-            return false;
-        }
-
-        // Now check prefs (i.e. settings) to see if the user turned off notifications.
-        final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
-        final Context context = Factory.get().getApplicationContext();
-        final String prefKey = context.getString(R.string.notifications_enabled_pref_key);
-        final boolean defaultValue = context.getResources().getBoolean(
-                R.bool.notifications_enabled_pref_default);
-        return prefs.getBoolean(prefKey, defaultValue);
-    }
-
-    /**
-     * Returns {@code true} if incoming notifications for the given {@link NotificationState}
-     * should vibrate the device, {@code false} otherwise.
-     *
-     * @return true if vibration should be used
-     */
-    public static boolean shouldVibrate(final NotificationState state) {
-        // The notification should vibrate if the global setting is turned on AND
-        // the per-conversation setting is turned on (default).
-        if (!state.getNotificationVibrate()) {
-            return false;
-        } else {
-            final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
-            final Context context = Factory.get().getApplicationContext();
-            final String prefKey = context.getString(R.string.notification_vibration_pref_key);
-            final boolean defaultValue = context.getResources().getBoolean(
-                    R.bool.notification_vibration_pref_default);
-            return prefs.getBoolean(prefKey, defaultValue);
-        }
-    }
-
-    private static Uri getNotificationRingtoneUriForConversationId(final String conversationId) {
-        final DatabaseWrapper db = DataModel.get().getDatabase();
-        final ConversationListItemData convData =
-                ConversationListItemData.getExistingConversation(db, conversationId);
-        return RingtoneUtil.getNotificationRingtoneUri(
-                convData != null ? convData.getNotificationSoundUri() : null);
-    }
-
-    /**
      * Returns a unique tag to identify a notification.
      *
      * @param name The tag name (in practice, the type)
@@ -411,13 +363,15 @@
     private static void processAndSend(final NotificationState state, final boolean silent,
             final boolean softSound) {
         final Context context = Factory.get().getApplicationContext();
-        final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context);
-        notifBuilder.setCategory(Notification.CATEGORY_MESSAGE);
         // TODO: Need to fix this for multi conversation notifications to rate limit dings.
         final String conversationId = state.mConversationIds.first();
+        String id = NotificationsUtil.DEFAULT_CHANNEL_ID;
+        if (NotificationsUtil.getNotificationChannel(context, conversationId) != null) {
+            id = conversationId;
+        }
+        final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context, id);
+        notifBuilder.setCategory(Notification.CATEGORY_MESSAGE);
 
-
-        final Uri ringtoneUri = RingtoneUtil.getNotificationRingtoneUri(state.getRingtoneUri());
         // If the notification's conversation is currently observable (focused or in the
         // conversation list),  then play a notification beep at a low volume and don't display an
         // actual notification.
@@ -427,7 +381,7 @@
                         "sCurrentlyDisplayedConversationId so NOT showing notification," +
                         " but playing soft sound. conversationId: " + conversationId);
             }
-            playObservableConversationNotificationSound(ringtoneUri);
+            playObservableConversationNotificationSound(conversationId);
             return;
         }
         state.mBaseRequestCode = state.mType;
@@ -440,7 +394,7 @@
             notifBuilder.setDeleteIntent(clearIntent);
         }
 
-        updateBuilderAudioVibrate(state, notifBuilder, silent, ringtoneUri, conversationId);
+        updateBuilderAudioVibrate(state, notifBuilder, silent, conversationId);
 
         // Set the content intent
         PendingIntent destinationIntent;
@@ -598,8 +552,7 @@
         if (state == null) {
             cancel(PendingIntentConstants.SMS_NOTIFICATION_ID);
             if (softSound && !TextUtils.isEmpty(conversationId)) {
-                final Uri ringtoneUri = getNotificationRingtoneUriForConversationId(conversationId);
-                playObservableConversationNotificationSound(ringtoneUri);
+                playObservableConversationNotificationSound(conversationId);
             }
             return;
         }
@@ -637,8 +590,8 @@
 
     private static void updateBuilderAudioVibrate(final NotificationState state,
             final NotificationCompat.Builder notifBuilder, final boolean silent,
-            final Uri ringtoneUri, final String conversationId) {
-        int defaults = Notification.DEFAULT_LIGHTS;
+            final String conversationId) {
+        int defaults = Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE;
         if (!silent) {
             final BuglePrefs prefs = Factory.get().getApplicationPrefs();
             final long latestNotificationTimestamp = prefs.getLong(
@@ -660,10 +613,6 @@
                     if (lastTime == null
                             || SystemClock.elapsedRealtime() - lastTime > sTimeBetweenDingsMs) {
                         sLastMessageDingTime.put(conversationId, SystemClock.elapsedRealtime());
-                        notifBuilder.setSound(ringtoneUri);
-                        if (shouldVibrate(state)) {
-                            defaults |= Notification.DEFAULT_VIBRATE;
-                        }
                     }
                 }
             }
@@ -817,8 +766,14 @@
                 notificationState.mNotificationBuilder.setLargeIcon(smallBitmap);
 
                 // Add a wearable page with no visible card so you can more easily see the photo.
+                String conversationId = notificationState.mConversationIds.first();
+                String id = NotificationsUtil.DEFAULT_CHANNEL_ID;
+                if (NotificationsUtil.getNotificationChannel(context, conversationId) != null) {
+                    id = conversationId;
+                }
                 final NotificationCompat.Builder photoPageNotifBuilder =
-                        new NotificationCompat.Builder(Factory.get().getApplicationContext());
+                        new NotificationCompat.Builder(Factory.get().getApplicationContext(),
+                        NotificationsUtil.DEFAULT_CHANNEL_ID);
                 final WearableExtender photoPageWearableExtender = new WearableExtender();
                 photoPageWearableExtender.setHintShowBackgroundOnly(true);
                 if (attachmentBitmap != null) {
@@ -833,7 +788,7 @@
             maybeAddWearableConversationLog(wearableExtender,
                     (MultiMessageNotificationState) notificationState);
             addDownloadMmsAction(notifBuilder, wearableExtender, notificationState);
-            addWearableVoiceReplyAction(wearableExtender, notificationState);
+            addWearableVoiceReplyAction(notifBuilder, wearableExtender, notificationState);
         }
 
         // Apply the wearable options and build & post the notification
@@ -875,7 +830,7 @@
         }
     }
 
-    private static void addWearableVoiceReplyAction(
+    private static void addWearableVoiceReplyAction(final NotificationCompat.Builder notifBuilder,
             final WearableExtender wearableExtender, final NotificationState notificationState) {
         if (!(notificationState instanceof MultiMessageNotificationState)) {
             return;
@@ -905,14 +860,20 @@
         final NotificationCompat.Action.Builder actionBuilder =
                 new NotificationCompat.Action.Builder(R.drawable.ic_wear_reply,
                         context.getString(replyLabelRes), replyPendingIntent);
+        final RemoteInput.Builder remoteInputBuilder = new RemoteInput.Builder(Intent.EXTRA_TEXT);
+        remoteInputBuilder.setLabel(context.getString(R.string.notification_reply_prompt));
+        actionBuilder.addRemoteInput(remoteInputBuilder.build());
+        notifBuilder.addAction(actionBuilder.build());
+
+        // Support the action on a wearable device
+        final NotificationCompat.Action.Builder wearActionBuilder =
+                new NotificationCompat.Action.Builder(R.drawable.ic_wear_reply,
+                        context.getString(replyLabelRes), replyPendingIntent);
         final String[] choices = context.getResources().getStringArray(
                 R.array.notification_reply_choices);
-        final RemoteInput remoteInput = new RemoteInput.Builder(Intent.EXTRA_TEXT).setLabel(
-                context.getString(R.string.notification_reply_prompt)).
-                setChoices(choices)
-                .build();
-        actionBuilder.addRemoteInput(remoteInput);
-        wearableExtender.addAction(actionBuilder.build());
+        remoteInputBuilder.setChoices(choices);
+        wearActionBuilder.addRemoteInput(remoteInputBuilder.build());
+        wearableExtender.addAction(wearActionBuilder.build());
     }
 
     private static void addDownloadMmsAction(final NotificationCompat.Builder notifBuilder,
@@ -973,6 +934,16 @@
         notification.flags |= Notification.FLAG_AUTO_CANCEL;
         notification.defaults |= Notification.DEFAULT_LIGHTS;
 
+        Context context = Factory.get().getApplicationContext();
+
+        NotificationsUtil.createNotificationChannelGroup(context,
+                NotificationsUtil.CONVERSATION_GROUP_NAME,
+                R.string.notification_channel_messages_title);
+        NotificationsUtil.createNotificationChannel(context,
+                NotificationsUtil.DEFAULT_CHANNEL_ID,
+                R.string.notification_channel_messages_title,
+                NotificationManager.IMPORTANCE_DEFAULT,
+                NotificationsUtil.CONVERSATION_GROUP_NAME);
         notificationManager.notify(notificationTag, type, notification);
 
         LogUtil.i(TAG, "Notifying for conversation " + conversationId + "; "
@@ -1096,7 +1067,7 @@
      * Play the observable conversation notification sound (it's the regular notification sound, but
      * played at half-volume)
      */
-    private static void playObservableConversationNotificationSound(final Uri ringtoneUri) {
+    private static void playObservableConversationNotificationSound(final String conversationId) {
         final Context context = Factory.get().getApplicationContext();
         final AudioManager audioManager = (AudioManager) context
                 .getSystemService(Context.AUDIO_SERVICE);
@@ -1107,7 +1078,11 @@
         }
 
         final NotificationPlayer player = new NotificationPlayer(LogUtil.BUGLE_TAG);
-        player.play(ringtoneUri, false,
+        NotificationChannel channel = NotificationsUtil.getNotificationChannel(context, conversationId);
+        if (channel == null) {
+            channel = NotificationsUtil.getNotificationChannel(context, NotificationsUtil.DEFAULT_CHANNEL_ID);
+        }
+        player.play(channel != null ? channel.getSound() : null, false,
                 AudioManager.STREAM_NOTIFICATION,
                 OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME);
 
@@ -1202,7 +1177,8 @@
         final PendingIntent destinationIntent = UIIntents.get()
                 .getPendingIntentForConversationActivity(context, conversationId, null /* draft */);
 
-        final NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
+        final NotificationCompat.Builder builder =
+                new NotificationCompat.Builder(context, NotificationsUtil.DEFAULT_CHANNEL_ID);
         builder.setTicker(line1)
                 .setContentTitle(line1)
                 .setContentText(line2)
@@ -1212,6 +1188,15 @@
                 .setSound(UriUtil.getUriForResourceId(context, R.raw.message_failure));
 
         final String tag = context.getPackageName() + ":emergency_sms_error";
+
+        NotificationsUtil.createNotificationChannelGroup(context,
+                NotificationsUtil.CONVERSATION_GROUP_NAME,
+                R.string.notification_channel_messages_title);
+        NotificationsUtil.createNotificationChannel(context,
+                NotificationsUtil.DEFAULT_CHANNEL_ID,
+                R.string.notification_channel_messages_title,
+                NotificationManager.IMPORTANCE_HIGH,
+                null);
         NotificationManagerCompat.from(context).notify(
                 tag,
                 PendingIntentConstants.MSG_SEND_ERROR,
diff --git a/src/com/android/messaging/datamodel/DatabaseHelper.java b/src/com/android/messaging/datamodel/DatabaseHelper.java
index 486973e..87bf08d 100644
--- a/src/com/android/messaging/datamodel/DatabaseHelper.java
+++ b/src/com/android/messaging/datamodel/DatabaseHelper.java
@@ -136,15 +136,6 @@
         /* Participant count not including self (so will be 1 for 1:1 or bigger for group) */
         public static final String PARTICIPANT_COUNT = "participant_count";
 
-        /* Should notifications be enabled for this conversation? */
-        public static final String NOTIFICATION_ENABLED = "notification_enabled";
-
-        /* Notification sound used for the conversation */
-        public static final String NOTIFICATION_SOUND_URI = "notification_sound_uri";
-
-        /* Should vibrations be enabled for the conversation's notification? */
-        public static final String NOTIFICATION_VIBRATION = "notification_vibration";
-
         /* Conversation recipients include email address */
         public static final String INCLUDE_EMAIL_ADDRESS = "include_email_addr";
 
@@ -184,9 +175,6 @@
                     + ConversationColumns.OTHER_PARTICIPANT_NORMALIZED_DESTINATION + " TEXT, "
                     + ConversationColumns.CURRENT_SELF_ID + " TEXT, "
                     + ConversationColumns.PARTICIPANT_COUNT + " INT DEFAULT(0), "
-                    + ConversationColumns.NOTIFICATION_ENABLED + " INT DEFAULT(1), "
-                    + ConversationColumns.NOTIFICATION_SOUND_URI + " TEXT, "
-                    + ConversationColumns.NOTIFICATION_VIBRATION + " INT DEFAULT(1), "
                     + ConversationColumns.INCLUDE_EMAIL_ADDRESS + " INT DEFAULT(0), "
                     + ConversationColumns.SMS_SERVICE_CENTER + " TEXT ,"
                     + ConversationColumns.IS_ENTERPRISE + " INT DEFAULT(0)"
diff --git a/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java b/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java
index 8f65156..fad4040 100644
--- a/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java
+++ b/src/com/android/messaging/datamodel/FrequentContactsCursorBuilder.java
@@ -74,7 +74,7 @@
      * are both ready to be consumed.
      * @return the frequent contact cursor if built successfully, or null if it can't be built yet.
      */
-    public Cursor build() {
+    public Cursor build(boolean getAllContacts) {
         if (mFrequentContactsCursor != null && mAllContactsCursor != null) {
             Assert.isTrue(!mFrequentContactsCursor.isClosed());
             Assert.isTrue(!mAllContactsCursor.isClosed());
@@ -108,7 +108,7 @@
             mAllContactsCursor.moveToPosition(-1);
             while (mAllContactsCursor.moveToNext()) {
                 final String lookupKey = mAllContactsCursor.getString(ContactUtil.INDEX_LOOKUP_KEY);
-                if (lookupKeyToRankMap.containsKey(lookupKey)) {
+                if (lookupKeyToRankMap.containsKey(lookupKey) || getAllContacts) {
                     final Object[] row = new Object[ContactUtil.PhoneQuery.PROJECTION.length];
                     row[ContactUtil.INDEX_DATA_ID] =
                             mAllContactsCursor.getLong(ContactUtil.INDEX_DATA_ID);
@@ -121,16 +121,38 @@
                     row[ContactUtil.INDEX_PHOTO_URI] =
                             mAllContactsCursor.getString(ContactUtil.INDEX_PHOTO_URI);
                     row[ContactUtil.INDEX_PHONE_EMAIL] =
-                            mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL);
+                            mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL)
+                                    .replaceAll("[^\\d+]", "");
                     row[ContactUtil.INDEX_PHONE_EMAIL_TYPE] =
                             mAllContactsCursor.getInt(ContactUtil.INDEX_PHONE_EMAIL_TYPE);
                     row[ContactUtil.INDEX_PHONE_EMAIL_LABEL] =
                             mAllContactsCursor.getString(ContactUtil.INDEX_PHONE_EMAIL_LABEL);
-                    rows.add(row);
+
+                    boolean numberAlreadyAdded = false;
+                    for (Object[] oldRow : rows) {
+                        final int idxType = ContactUtil.INDEX_PHONE_EMAIL_TYPE;
+                        final int idxPhone = ContactUtil.INDEX_PHONE_EMAIL;
+                        if (oldRow[idxType] == row[idxType] &&
+                                oldRow[idxPhone].toString().equals(row[idxPhone].toString())) {
+                            numberAlreadyAdded = true;
+                            break;
+                        }
+                    }
+                    if (!numberAlreadyAdded) {
+                        rows.add(row);
+                    }
                 }
             }
             mAllContactsCursor.moveToPosition(oldPosition);
 
+            // We can return all rows at this point, no sorting or further filtering needed
+            if (getAllContacts) {
+                for (final Object[] row : rows) {
+                    retCursor.addRow(row);
+                }
+                return retCursor;
+            }
+
             // Now we have a list of rows containing frequent contacts in alphabetical order.
             // Therefore, sort all the rows according to their actual ranks in the frequents list.
             Collections.sort(rows, new Comparator<Object[]>() {
diff --git a/src/com/android/messaging/datamodel/MessageNotificationState.java b/src/com/android/messaging/datamodel/MessageNotificationState.java
index 6b858fa..fd82f74 100644
--- a/src/com/android/messaging/datamodel/MessageNotificationState.java
+++ b/src/com/android/messaging/datamodel/MessageNotificationState.java
@@ -55,6 +55,7 @@
 import com.android.messaging.util.ContentType;
 import com.android.messaging.util.ConversationIdSet;
 import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.NotificationsUtil;
 import com.android.messaging.util.PendingIntentConstants;
 import com.android.messaging.util.UriUtil;
 import com.google.common.collect.Lists;
@@ -197,15 +198,6 @@
         // line infos is capped.
         int mTotalMessageCount;
 
-        // Custom ringtone if set
-        final String mRingtoneUri;
-
-        // Should notification be enabled for this conversation?
-        final boolean mNotificationEnabled;
-
-        // Should notifications vibrate for this conversation?
-        final boolean mNotificationVibrate;
-
         // Avatar uri of sender
         final Uri mAvatarUri;
 
@@ -224,9 +216,6 @@
                 final boolean includeEmailAddress,
                 final long receivedTimestamp,
                 final String selfParticipantId,
-                final String ringtoneUri,
-                final boolean notificationEnabled,
-                final boolean notificationVibrate,
                 final Uri avatarUri,
                 final Uri contactUri,
                 final int subId,
@@ -239,11 +228,8 @@
             mSelfParticipantId = selfParticipantId;
             mLineInfos = new ArrayList<NotificationLineInfo>();
             mTotalMessageCount = 0;
-            mRingtoneUri = ringtoneUri;
             mAvatarUri = avatarUri;
             mContactUri = contactUri;
-            mNotificationEnabled = notificationEnabled;
-            mNotificationVibrate = notificationVibrate;
             mSubId = subId;
             mParticipantCount = participantCount;
         }
@@ -789,7 +775,8 @@
             bigText.append("\n\n").append(statusText);
         }
 
-        final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context);
+        final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context,
+                NotificationsUtil.DEFAULT_CHANNEL_ID);
         final NotificationCompat.Style notifStyle =
                 new NotificationCompat.BigTextStyle(notifBuilder).bigText(bigText);
         notifBuilder.setStyle(notifStyle);
@@ -870,10 +857,6 @@
                     if (currConvInfo == null) {
                         final ConversationListItemData convData =
                                 ConversationListItemData.getExistingConversation(db, convId);
-                        if (!convData.getNotificationEnabled()) {
-                            // Skip conversations that have notifications disabled.
-                            continue;
-                        }
                         final int subId = BugleDatabaseOperations.getSelfSubscriptionId(db,
                                 convData.getSelfId());
                         groupConversationName = convData.getName();
@@ -888,9 +871,6 @@
                                 convData.getIncludeEmailAddress(),
                                 convMessageData.getReceivedTimeStamp(),
                                 convData.getSelfId(),
-                                convData.getNotificationSoundUri(),
-                                convData.getNotificationEnabled(),
-                                convData.getNotifiationVibrate(),
                                 avatarUri,
                                 convMessageData.getSenderContactLookupUri(),
                                 subId,
@@ -1103,22 +1083,6 @@
         return BugleNotifications.LOCAL_SMS_NOTIFICATION;
     }
 
-    @Override
-    public String getRingtoneUri() {
-        if (mConvList.mConvInfos.size() > 0) {
-            return mConvList.mConvInfos.get(0).mRingtoneUri;
-        }
-        return null;
-    }
-
-    @Override
-    public boolean getNotificationVibrate() {
-        if (mConvList.mConvInfos.size() > 0) {
-            return mConvList.mConvInfos.get(0).mNotificationVibrate;
-        }
-        return false;
-    }
-
     protected CharSequence getTicker() {
         return BugleNotifications.buildColonSeparatedMessage(
                 mTickerSender != null ? mTickerSender : mTitle,
@@ -1234,7 +1198,8 @@
                 }
                 if (failedMessages.size() > 0) {
                     final NotificationCompat.Builder builder =
-                            new NotificationCompat.Builder(context);
+                            new NotificationCompat.Builder(context,
+                                    NotificationsUtil.DEFAULT_CHANNEL_ID);
 
                     CharSequence line1;
                     CharSequence line2;
diff --git a/src/com/android/messaging/datamodel/NotificationState.java b/src/com/android/messaging/datamodel/NotificationState.java
index e19f70c..144f0fe 100644
--- a/src/com/android/messaging/datamodel/NotificationState.java
+++ b/src/com/android/messaging/datamodel/NotificationState.java
@@ -134,15 +134,6 @@
      */
     public abstract int getPriority();
 
-    /** @return custom ringtone URI or null if not set */
-    public String getRingtoneUri() {
-        return null;
-    }
-
-    public boolean getNotificationVibrate() {
-        return false;
-    }
-
     public long getLatestReceivedTimestamp() {
         return Long.MIN_VALUE;
     }
diff --git a/src/com/android/messaging/datamodel/SyncManager.java b/src/com/android/messaging/datamodel/SyncManager.java
index 28fc696..e5d4935 100644
--- a/src/com/android/messaging/datamodel/SyncManager.java
+++ b/src/com/android/messaging/datamodel/SyncManager.java
@@ -51,33 +51,14 @@
      */
     public static class ConversationCustomization {
         private final boolean mArchived;
-        private final boolean mMuted;
-        private final boolean mNoVibrate;
-        private final String mNotificationSoundUri;
 
-        public ConversationCustomization(final boolean archived, final boolean muted,
-                final boolean noVibrate, final String notificationSoundUri) {
+        public ConversationCustomization(final boolean archived) {
             mArchived = archived;
-            mMuted = muted;
-            mNoVibrate = noVibrate;
-            mNotificationSoundUri = notificationSoundUri;
         }
 
         public boolean isArchived() {
             return mArchived;
         }
-
-        public boolean isMuted() {
-            return mMuted;
-        }
-
-        public boolean noVibrate() {
-            return mNoVibrate;
-        }
-
-        public String getNotificationSoundUri() {
-            return mNotificationSoundUri;
-        }
     }
 
     SyncManager() {
@@ -436,15 +417,13 @@
             if (customization != null) {
                 // There is user customization we need to recover
                 conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
-                        customization.isArchived(), participants, customization.isMuted(),
-                        customization.noVibrate(), customization.getNotificationSoundUri());
+                        customization.isArchived(), participants);
                 if (customization.isArchived()) {
                     mArchivedConversations.add(conversationId);
                 }
             } else {
                 conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
-                        false/*archived*/, participants, false/*noNotification*/,
-                        false/*noVibrate*/, null/*soundUri*/);
+                        false/*archived*/, participants);
             }
 
             if (conversationId != null) {
diff --git a/src/com/android/messaging/datamodel/action/BugleActionToasts.java b/src/com/android/messaging/datamodel/action/BugleActionToasts.java
index f60facd..17d15f2 100644
--- a/src/com/android/messaging/datamodel/action/BugleActionToasts.java
+++ b/src/com/android/messaging/datamodel/action/BugleActionToasts.java
@@ -114,7 +114,6 @@
     }
 
     public static void onConversationDeleted() {
-        showToast(R.string.conversation_deleted);
     }
 
     private static void showToast(final int messageResId) {
diff --git a/src/com/android/messaging/datamodel/action/DeleteConversationAction.java b/src/com/android/messaging/datamodel/action/DeleteConversationAction.java
index a00f6d6..6b81aa6 100644
--- a/src/com/android/messaging/datamodel/action/DeleteConversationAction.java
+++ b/src/com/android/messaging/datamodel/action/DeleteConversationAction.java
@@ -35,6 +35,7 @@
 import com.android.messaging.sms.MmsUtils;
 import com.android.messaging.util.Assert;
 import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.NotificationsUtil;
 import com.android.messaging.widget.WidgetConversationProvider;
 
 import java.util.ArrayList;
@@ -118,6 +119,10 @@
                         + " has an invalid telephony thread id; will delete messages individually");
                 deleteConversationMessagesFromTelephony();
             }
+
+            // Finally, remove the conversation specific notification channel
+            NotificationsUtil.deleteNotificationChannel(Factory.get().getApplicationContext(),
+                    conversationId);
         } else {
             LogUtil.e(TAG, "DeleteConversationAction: conversationId is empty");
         }
diff --git a/src/com/android/messaging/datamodel/action/GetOrCreateConversationAction.java b/src/com/android/messaging/datamodel/action/GetOrCreateConversationAction.java
index b262141..7dd09c1 100644
--- a/src/com/android/messaging/datamodel/action/GetOrCreateConversationAction.java
+++ b/src/com/android/messaging/datamodel/action/GetOrCreateConversationAction.java
@@ -110,7 +110,7 @@
         }
 
         final String conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
-                false, participants, false, false, null);
+                false, participants);
 
         return conversationId;
     }
diff --git a/src/com/android/messaging/datamodel/action/InsertNewMessageAction.java b/src/com/android/messaging/datamodel/action/InsertNewMessageAction.java
index 8bf6d5e..20f90dc 100644
--- a/src/com/android/messaging/datamodel/action/InsertNewMessageAction.java
+++ b/src/com/android/messaging/datamodel/action/InsertNewMessageAction.java
@@ -274,7 +274,7 @@
         }
 
         final String conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
-                false, participants, false, false, null);
+                false, participants);
 
         final ParticipantData self = BugleDatabaseOperations.getOrCreateSelf(db, subId);
 
diff --git a/src/com/android/messaging/datamodel/action/UpdateConversationOptionsAction.java b/src/com/android/messaging/datamodel/action/UpdateConversationOptionsAction.java
deleted file mode 100644
index 6c9e739..0000000
--- a/src/com/android/messaging/datamodel/action/UpdateConversationOptionsAction.java
+++ /dev/null
@@ -1,156 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.messaging.datamodel.action;
-
-import android.content.ContentValues;
-import android.os.Parcel;
-import android.os.Parcelable;
-
-import com.android.messaging.datamodel.BugleDatabaseOperations;
-import com.android.messaging.datamodel.DataModel;
-import com.android.messaging.datamodel.DatabaseHelper.ConversationColumns;
-import com.android.messaging.datamodel.DatabaseWrapper;
-import com.android.messaging.datamodel.MessagingContentProvider;
-import com.android.messaging.util.Assert;
-
-/**
- * Action used to update conversation options such as notification settings.
- */
-public class UpdateConversationOptionsAction extends Action
-        implements Parcelable {
-    /**
-     * Enable/disable conversation notifications.
-     */
-    public static void enableConversationNotifications(final String conversationId,
-            final boolean enableNotification) {
-        Assert.notNull(conversationId);
-
-        final UpdateConversationOptionsAction action = new UpdateConversationOptionsAction(
-                conversationId, enableNotification, null, null);
-        action.start();
-    }
-
-    /**
-     * Sets conversation notification sound.
-     */
-    public static void setConversationNotificationSound(final String conversationId,
-            final String ringtoneUri) {
-        Assert.notNull(conversationId);
-
-        final UpdateConversationOptionsAction action = new UpdateConversationOptionsAction(
-                conversationId, null, ringtoneUri, null);
-        action.start();
-    }
-
-    /**
-     * Enable/disable vibrations for conversation notification.
-     */
-    public static void enableVibrationForConversationNotification(final String conversationId,
-            final boolean enableVibration) {
-        Assert.notNull(conversationId);
-
-        final UpdateConversationOptionsAction action = new UpdateConversationOptionsAction(
-                conversationId, null, null, enableVibration);
-        action.start();
-    }
-
-    private static final String KEY_CONVERSATION_ID = "conversation_id";
-
-    // Keys for all settable settings.
-    private static final String KEY_ENABLE_NOTIFICATION = "enable_notification";
-    private static final String KEY_RINGTONE_URI = "ringtone_uri";
-    private static final String KEY_ENABLE_VIBRATION = "enable_vibration";
-
-    protected UpdateConversationOptionsAction(final String conversationId,
-            final Boolean enableNotification, final String ringtoneUri,
-            final Boolean enableVibration) {
-        Assert.notNull(conversationId);
-        actionParameters.putString(KEY_CONVERSATION_ID, conversationId);
-        if (enableNotification != null) {
-            actionParameters.putBoolean(KEY_ENABLE_NOTIFICATION, enableNotification);
-        }
-
-        if (ringtoneUri != null) {
-            actionParameters.putString(KEY_RINGTONE_URI, ringtoneUri);
-        }
-
-        if (enableVibration != null) {
-            actionParameters.putBoolean(KEY_ENABLE_VIBRATION, enableVibration);
-        }
-    }
-
-    protected void putOptionValuesInTransaction(final ContentValues values,
-            final DatabaseWrapper dbWrapper) {
-        Assert.isTrue(dbWrapper.getDatabase().inTransaction());
-        if (actionParameters.containsKey(KEY_ENABLE_NOTIFICATION)) {
-            values.put(ConversationColumns.NOTIFICATION_ENABLED,
-                    actionParameters.getBoolean(KEY_ENABLE_NOTIFICATION));
-        }
-
-        if (actionParameters.containsKey(KEY_RINGTONE_URI)) {
-            values.put(ConversationColumns.NOTIFICATION_SOUND_URI,
-                    actionParameters.getString(KEY_RINGTONE_URI));
-        }
-
-        if (actionParameters.containsKey(KEY_ENABLE_VIBRATION)) {
-            values.put(ConversationColumns.NOTIFICATION_VIBRATION,
-                    actionParameters.getBoolean(KEY_ENABLE_VIBRATION));
-        }
-    }
-
-    @Override
-    protected Object executeAction() {
-        final String conversationId = actionParameters.getString(KEY_CONVERSATION_ID);
-
-        final DatabaseWrapper db = DataModel.get().getDatabase();
-        db.beginTransaction();
-        try {
-            final ContentValues values = new ContentValues();
-            putOptionValuesInTransaction(values, db);
-
-            BugleDatabaseOperations.updateConversationRowIfExists(db, conversationId, values);
-
-            db.setTransactionSuccessful();
-        } finally {
-            db.endTransaction();
-        }
-        MessagingContentProvider.notifyConversationMetadataChanged(conversationId);
-        return null;
-    }
-
-    protected UpdateConversationOptionsAction(final Parcel in) {
-        super(in);
-    }
-
-    public static final Parcelable.Creator<UpdateConversationOptionsAction> CREATOR
-            = new Parcelable.Creator<UpdateConversationOptionsAction>() {
-        @Override
-        public UpdateConversationOptionsAction createFromParcel(final Parcel in) {
-            return new UpdateConversationOptionsAction(in);
-        }
-
-        @Override
-        public UpdateConversationOptionsAction[] newArray(final int size) {
-            return new UpdateConversationOptionsAction[size];
-        }
-    };
-
-    @Override
-    public void writeToParcel(final Parcel parcel, final int flags) {
-        writeActionToParcel(parcel, flags);
-    }
-}
diff --git a/src/com/android/messaging/datamodel/data/ContactPickerData.java b/src/com/android/messaging/datamodel/data/ContactPickerData.java
index fd6fca0..bf057db 100644
--- a/src/com/android/messaging/datamodel/data/ContactPickerData.java
+++ b/src/com/android/messaging/datamodel/data/ContactPickerData.java
@@ -96,7 +96,6 @@
         if (isBound(cursorLoader.getBindingId())) {
             switch (loader.getId()) {
                 case ALL_CONTACTS_LOADER:
-                    mListener.onAllContactsCursorUpdated(data);
                     mFrequentContactsCursorBuilder.setAllContacts(data);
                     break;
                 case FREQUENT_CONTACTS_LOADER:
@@ -115,10 +114,14 @@
                 // all contacts and frequent contacts loader, and we don't know which will finish
                 // first. Therefore, try to build the cursor and notify the listener if it's
                 // successfully built.
-                final Cursor frequentContactsCursor = mFrequentContactsCursorBuilder.build();
+                final Cursor frequentContactsCursor = mFrequentContactsCursorBuilder.build(false);
                 if (frequentContactsCursor != null) {
                     mListener.onFrequentContactsCursorUpdated(frequentContactsCursor);
+
+                    final Cursor allContactsCursor = mFrequentContactsCursorBuilder.build(true);
+                    mListener.onAllContactsCursorUpdated(allContactsCursor);
                 }
+
             }
         } else {
             LogUtil.w(LogUtil.BUGLE_TAG, "Loader finished after unbinding the contacts list");
diff --git a/src/com/android/messaging/datamodel/data/ConversationListItemData.java b/src/com/android/messaging/datamodel/data/ConversationListItemData.java
index f627a09..46d4b64 100644
--- a/src/com/android/messaging/datamodel/data/ConversationListItemData.java
+++ b/src/com/android/messaging/datamodel/data/ConversationListItemData.java
@@ -52,9 +52,6 @@
     private String mOtherParticipantNormalizedDestination;
     private String mSelfId;
     private int mParticipantCount;
-    private boolean mNotificationEnabled;
-    private String mNotificationSoundUri;
-    private boolean mNotificationVibrate;
     private boolean mIncludeEmailAddress;
     private int mMessageStatus;
     private int mMessageRawTelephonyStatus;
@@ -92,9 +89,6 @@
                 INDEX_OTHER_PARTICIPANT_NORMALIZED_DESTINATION);
         mSelfId = cursor.getString(INDEX_SELF_ID);
         mParticipantCount = cursor.getInt(INDEX_PARTICIPANT_COUNT);
-        mNotificationEnabled = cursor.getInt(INDEX_NOTIFICATION_ENABLED) == 1;
-        mNotificationSoundUri = cursor.getString(INDEX_NOTIFICATION_SOUND_URI);
-        mNotificationVibrate = cursor.getInt(INDEX_NOTIFICATION_VIBRATION) == 1;
         mIncludeEmailAddress = cursor.getInt(INDEX_INCLUDE_EMAIL_ADDRESS) == 1;
         mMessageStatus = cursor.getInt(INDEX_MESSAGE_STATUS);
         mMessageRawTelephonyStatus = cursor.getInt(INDEX_MESSAGE_RAW_TELEPHONY_STATUS);
@@ -199,18 +193,6 @@
         return mIncludeEmailAddress;
     }
 
-    public boolean getNotificationEnabled() {
-        return mNotificationEnabled;
-    }
-
-    public String getNotificationSoundUri() {
-        return mNotificationSoundUri;
-    }
-
-    public boolean getNotifiationVibrate() {
-        return mNotificationVibrate;
-    }
-
     public final boolean getIsFailedStatus() {
         return (mMessageStatus == MessageData.BUGLE_STATUS_OUTGOING_FAILED ||
                 mMessageStatus == MessageData.BUGLE_STATUS_OUTGOING_FAILED_EMERGENCY_NUMBER ||
@@ -328,12 +310,6 @@
             + " as " + ConversationListViewColumns.PREVIEW_CONTENT_TYPE + ", "
             + DatabaseHelper.CONVERSATIONS_TABLE + '.' + ConversationColumns.PARTICIPANT_COUNT
             + " as " + ConversationListViewColumns.PARTICIPANT_COUNT + ", "
-            + DatabaseHelper.CONVERSATIONS_TABLE + '.' + ConversationColumns.NOTIFICATION_ENABLED
-            + " as " + ConversationListViewColumns.NOTIFICATION_ENABLED + ", "
-            + DatabaseHelper.CONVERSATIONS_TABLE + '.' + ConversationColumns.NOTIFICATION_SOUND_URI
-            + " as " + ConversationListViewColumns.NOTIFICATION_SOUND_URI + ", "
-            + DatabaseHelper.CONVERSATIONS_TABLE + '.' + ConversationColumns.NOTIFICATION_VIBRATION
-            + " as " + ConversationListViewColumns.NOTIFICATION_VIBRATION + ", "
             + DatabaseHelper.CONVERSATIONS_TABLE + '.' +
                     ConversationColumns.INCLUDE_EMAIL_ADDRESS
             + " as " + ConversationListViewColumns.INCLUDE_EMAIL_ADDRESS + ", "
@@ -396,9 +372,6 @@
                 ConversationColumns.OTHER_PARTICIPANT_NORMALIZED_DESTINATION;
         static final String CURRENT_SELF_ID = ConversationColumns.CURRENT_SELF_ID;
         static final String PARTICIPANT_COUNT = ConversationColumns.PARTICIPANT_COUNT;
-        static final String NOTIFICATION_ENABLED = ConversationColumns.NOTIFICATION_ENABLED;
-        static final String NOTIFICATION_SOUND_URI = ConversationColumns.NOTIFICATION_SOUND_URI;
-        static final String NOTIFICATION_VIBRATION = ConversationColumns.NOTIFICATION_VIBRATION;
         static final String INCLUDE_EMAIL_ADDRESS =
                 ConversationColumns.INCLUDE_EMAIL_ADDRESS;
         static final String MESSAGE_STATUS = MessageColumns.STATUS;
@@ -424,9 +397,6 @@
         ConversationListViewColumns.OTHER_PARTICIPANT_NORMALIZED_DESTINATION,
         ConversationListViewColumns.PARTICIPANT_COUNT,
         ConversationListViewColumns.CURRENT_SELF_ID,
-        ConversationListViewColumns.NOTIFICATION_ENABLED,
-        ConversationListViewColumns.NOTIFICATION_SOUND_URI,
-        ConversationListViewColumns.NOTIFICATION_VIBRATION,
         ConversationListViewColumns.INCLUDE_EMAIL_ADDRESS,
         ConversationListViewColumns.MESSAGE_STATUS,
         ConversationListViewColumns.SHOW_DRAFT,
@@ -456,23 +426,20 @@
     private static final int INDEX_OTHER_PARTICIPANT_NORMALIZED_DESTINATION = 10;
     private static final int INDEX_PARTICIPANT_COUNT = 11;
     private static final int INDEX_SELF_ID = 12;
-    private static final int INDEX_NOTIFICATION_ENABLED = 13;
-    private static final int INDEX_NOTIFICATION_SOUND_URI = 14;
-    private static final int INDEX_NOTIFICATION_VIBRATION = 15;
-    private static final int INDEX_INCLUDE_EMAIL_ADDRESS = 16;
-    private static final int INDEX_MESSAGE_STATUS = 17;
-    private static final int INDEX_SHOW_DRAFT = 18;
-    private static final int INDEX_DRAFT_PREVIEW_URI = 19;
-    private static final int INDEX_DRAFT_PREVIEW_CONTENT_TYPE = 20;
-    private static final int INDEX_DRAFT_SNIPPET_TEXT = 21;
-    private static final int INDEX_ARCHIVE_STATUS = 22;
-    private static final int INDEX_MESSAGE_ID = 23;
-    private static final int INDEX_SUBJECT_TEXT = 24;
-    private static final int INDEX_DRAFT_SUBJECT_TEXT = 25;
-    private static final int INDEX_MESSAGE_RAW_TELEPHONY_STATUS = 26;
-    private static final int INDEX_SNIPPET_SENDER_FIRST_NAME = 27;
-    private static final int INDEX_SNIPPET_SENDER_DISPLAY_DESTINATION = 28;
-    private static final int INDEX_IS_ENTERPRISE = 29;
+    private static final int INDEX_INCLUDE_EMAIL_ADDRESS = 13;
+    private static final int INDEX_MESSAGE_STATUS = 14;
+    private static final int INDEX_SHOW_DRAFT = 15;
+    private static final int INDEX_DRAFT_PREVIEW_URI = 16;
+    private static final int INDEX_DRAFT_PREVIEW_CONTENT_TYPE = 17;
+    private static final int INDEX_DRAFT_SNIPPET_TEXT = 18;
+    private static final int INDEX_ARCHIVE_STATUS = 19;
+    private static final int INDEX_MESSAGE_ID = 20;
+    private static final int INDEX_SUBJECT_TEXT = 21;
+    private static final int INDEX_DRAFT_SUBJECT_TEXT = 22;
+    private static final int INDEX_MESSAGE_RAW_TELEPHONY_STATUS = 23;
+    private static final int INDEX_SNIPPET_SENDER_FIRST_NAME = 24;
+    private static final int INDEX_SNIPPET_SENDER_DISPLAY_DESTINATION = 25;
+    private static final int INDEX_IS_ENTERPRISE = 26;
 
     private static final String DIVIDER_TEXT = ", ";
 
diff --git a/src/com/android/messaging/datamodel/data/PeopleAndOptionsData.java b/src/com/android/messaging/datamodel/data/PeopleAndOptionsData.java
index 650a037..b8b4a41 100644
--- a/src/com/android/messaging/datamodel/data/PeopleAndOptionsData.java
+++ b/src/com/android/messaging/datamodel/data/PeopleAndOptionsData.java
@@ -26,7 +26,6 @@
 import com.android.messaging.datamodel.BoundCursorLoader;
 import com.android.messaging.datamodel.MessagingContentProvider;
 import com.android.messaging.datamodel.action.BugleActionToasts;
-import com.android.messaging.datamodel.action.UpdateConversationOptionsAction;
 import com.android.messaging.datamodel.action.UpdateDestinationBlockedAction;
 import com.android.messaging.datamodel.binding.BindableData;
 import com.android.messaging.datamodel.binding.BindingBase;
@@ -74,7 +73,7 @@
                     final Uri uri =
                             MessagingContentProvider.buildConversationMetadataUri(mConversationId);
                     return new BoundCursorLoader(bindingId, mContext, uri,
-                            PeopleOptionsItemData.PROJECTION, null, null, null);
+                            new String[]{}, null, null, null);
                 }
 
                 case PARTICIPANT_LOADER: {
@@ -169,33 +168,6 @@
         }
     }
 
-    public void enableConversationNotifications(final BindingBase<PeopleAndOptionsData> binding,
-            final boolean enable) {
-        final String bindingId = binding.getBindingId();
-        if (isBound(bindingId)) {
-            UpdateConversationOptionsAction.enableConversationNotifications(
-                    mConversationId, enable);
-        }
-    }
-
-    public void setConversationNotificationSound(final BindingBase<PeopleAndOptionsData> binding,
-            final String ringtoneUri) {
-        final String bindingId = binding.getBindingId();
-        if (isBound(bindingId)) {
-            UpdateConversationOptionsAction.setConversationNotificationSound(mConversationId,
-                    ringtoneUri);
-        }
-    }
-
-    public void enableConversationNotificationVibration(
-            final BindingBase<PeopleAndOptionsData> binding, final boolean enable) {
-        final String bindingId = binding.getBindingId();
-        if (isBound(bindingId)) {
-            UpdateConversationOptionsAction.enableVibrationForConversationNotification(
-                    mConversationId, enable);
-        }
-    }
-
     public void setDestinationBlocked(final BindingBase<PeopleAndOptionsData> binding,
             final boolean blocked) {
         final String bindingId = binding.getBindingId();
@@ -207,4 +179,8 @@
                     BugleActionToasts.makeUpdateDestinationBlockedActionListener(mContext));
         }
     }
+
+    public String getConversationId() {
+        return mConversationId;
+    }
 }
diff --git a/src/com/android/messaging/datamodel/data/PeopleOptionsItemData.java b/src/com/android/messaging/datamodel/data/PeopleOptionsItemData.java
index 5af6a30..7441afc 100644
--- a/src/com/android/messaging/datamodel/data/PeopleOptionsItemData.java
+++ b/src/com/android/messaging/datamodel/data/PeopleOptionsItemData.java
@@ -17,44 +17,19 @@
 
 import android.content.Context;
 import android.database.Cursor;
-import android.media.Ringtone;
-import android.media.RingtoneManager;
 import android.net.Uri;
 
 import com.android.messaging.R;
 import com.android.messaging.datamodel.data.ConversationListItemData.ConversationListViewColumns;
 import com.android.messaging.util.Assert;
-import com.android.messaging.util.RingtoneUtil;
 
 public class PeopleOptionsItemData {
-    public static final String[] PROJECTION = {
-        ConversationListViewColumns.NOTIFICATION_ENABLED,
-        ConversationListViewColumns.NOTIFICATION_SOUND_URI,
-        ConversationListViewColumns.NOTIFICATION_VIBRATION,
-    };
-
-    // Column index for query projection.
-    private static final int INDEX_NOTIFICATION_ENABLED = 0;
-    private static final int INDEX_NOTIFICATION_SOUND_URI = 1;
-    private static final int INDEX_NOTIFICATION_VIBRATION = 2;
-
     // Identification for each setting that's surfaced to the UI layer.
-    public static final int SETTING_NOTIFICATION_ENABLED = 0;
-    public static final int SETTING_NOTIFICATION_SOUND_URI = 1;
-    public static final int SETTING_NOTIFICATION_VIBRATION = 2;
-    public static final int SETTING_BLOCKED = 3;
-    public static final int SETTINGS_COUNT = 4;
-
-    // Type of UI switch to show for the toggle button.
-    public static final int TOGGLE_TYPE_CHECKBOX = 0;
-    public static final int TOGGLE_TYPE_SWITCH = 1;
+    public static final int SETTING_NOTIFICATION = 0;
+    public static final int SETTING_BLOCKED = 1;
+    public static final int SETTINGS_COUNT = 2;
 
     private String mTitle;
-    private String mSubtitle;
-    private Uri mRingtoneUri;
-    private boolean mCheckable;
-    private boolean mChecked;
-    private boolean mEnabled;
     private int mItemId;
     private ParticipantData mOtherParticipant;
 
@@ -71,41 +46,12 @@
      */
     public void bind(
             final Cursor cursor, final ParticipantData otherParticipant, final int settingType) {
-        mSubtitle = null;
-        mRingtoneUri = null;
-        mCheckable = true;
-        mEnabled = true;
         mItemId = settingType;
         mOtherParticipant = otherParticipant;
 
-        final boolean notificationEnabled = cursor.getInt(INDEX_NOTIFICATION_ENABLED) == 1;
         switch (settingType) {
-            case SETTING_NOTIFICATION_ENABLED:
+            case SETTING_NOTIFICATION:
                 mTitle = mContext.getString(R.string.notifications_enabled_conversation_pref_title);
-                mChecked = notificationEnabled;
-                break;
-
-            case SETTING_NOTIFICATION_SOUND_URI:
-                mTitle = mContext.getString(R.string.notification_sound_pref_title);
-                final String ringtoneString = cursor.getString(INDEX_NOTIFICATION_SOUND_URI);
-                Uri ringtoneUri = RingtoneUtil.getNotificationRingtoneUri(ringtoneString);
-
-                mSubtitle = mContext.getString(R.string.silent_ringtone);
-                if (ringtoneUri != null) {
-                    final Ringtone ringtone = RingtoneManager.getRingtone(mContext, ringtoneUri);
-                    if (ringtone != null) {
-                        mSubtitle = ringtone.getTitle(mContext);
-                    }
-                }
-                mCheckable = false;
-                mRingtoneUri = ringtoneUri;
-                mEnabled = notificationEnabled;
-                break;
-
-            case SETTING_NOTIFICATION_VIBRATION:
-                mTitle = mContext.getString(R.string.notification_vibrate_pref_title);
-                mChecked = cursor.getInt(INDEX_NOTIFICATION_VIBRATION) == 1;
-                mEnabled = notificationEnabled;
                 break;
 
             case SETTING_BLOCKED:
@@ -113,7 +59,6 @@
                 final int resourceId = otherParticipant.isBlocked() ?
                         R.string.unblock_contact_title : R.string.block_contact_title;
                 mTitle = mContext.getString(resourceId, otherParticipant.getDisplayDestination());
-                mCheckable = false;
                 break;
 
              default:
@@ -125,30 +70,10 @@
         return mTitle;
     }
 
-    public String getSubtitle() {
-        return mSubtitle;
-    }
-
-    public boolean getCheckable() {
-        return mCheckable;
-    }
-
-    public boolean getChecked() {
-        return mChecked;
-    }
-
-    public boolean getEnabled() {
-        return mEnabled;
-    }
-
     public int getItemId() {
         return mItemId;
     }
 
-    public Uri getRingtoneUri() {
-        return mRingtoneUri;
-    }
-
     public ParticipantData getOtherParticipant() {
         return mOtherParticipant;
     }
diff --git a/src/com/android/messaging/datamodel/media/AvatarRequest.java b/src/com/android/messaging/datamodel/media/AvatarRequest.java
index 6a738c7..c6b06b1 100644
--- a/src/com/android/messaging/datamodel/media/AvatarRequest.java
+++ b/src/com/android/messaging/datamodel/media/AvatarRequest.java
@@ -17,6 +17,7 @@
 
 import android.content.Context;
 import android.content.res.Resources;
+import android.content.res.TypedArray;
 import android.graphics.Bitmap;
 import android.graphics.Canvas;
 import android.graphics.Matrix;
@@ -27,6 +28,7 @@
 import android.graphics.drawable.BitmapDrawable;
 import android.media.ExifInterface;
 import android.net.Uri;
+import android.text.TextUtils;
 
 import com.android.messaging.R;
 import com.android.messaging.util.Assert;
@@ -42,10 +44,12 @@
 public class AvatarRequest extends UriImageRequest<AvatarRequestDescriptor> {
     private static Bitmap sDefaultPersonBitmap;
     private static Bitmap sDefaultPersonBitmapLarge;
+    private TypedArray mColors;
 
     public AvatarRequest(final Context context,
             final AvatarRequestDescriptor descriptor) {
         super(context, descriptor);
+        mColors = mContext.getResources().obtainTypedArray(R.array.letter_tile_colors);
     }
 
     @Override
@@ -116,7 +120,7 @@
 
     private Bitmap renderDefaultAvatar(final int width, final int height) {
         final Bitmap bitmap = getBitmapPool().createOrReuseBitmap(width, height,
-                getBackgroundColor());
+                getBackgroundColor(AvatarUriUtil.getIdentifier(mDescriptor.uri)));
         final Canvas canvas = new Canvas(bitmap);
 
         if (sDefaultPersonBitmap == null) {
@@ -158,7 +162,7 @@
         final float halfHeight = height / 2;
         final int minOfWidthAndHeight = Math.min(width, height);
         final Bitmap bitmap = getBitmapPool().createOrReuseBitmap(width, height,
-                getBackgroundColor());
+                getBackgroundColor(AvatarUriUtil.getIdentifier(mDescriptor.uri)));
         final Resources resources = mContext.getResources();
         final Paint paint = new Paint(Paint.ANTI_ALIAS_FLAG);
         paint.setTypeface(Typeface.create("sans-serif-medium", Typeface.NORMAL));
@@ -178,8 +182,15 @@
         return bitmap;
     }
 
-    private int getBackgroundColor() {
-        return mContext.getResources().getColor(R.color.primary_color);
+    private int getBackgroundColor(final String identifier) {
+        if (!TextUtils.isEmpty(identifier) &&
+                mContext.getResources().getBoolean(R.bool.contact_colors)) {
+            int idcolor = Math.abs(identifier.hashCode()) % mColors.length();
+            return mColors.getColor(idcolor,
+                     mContext.getResources().getColor(R.color.primary_color));
+        } else {
+            return mContext.getResources().getColor(R.color.primary_color);
+        }
     }
 
     @Override
diff --git a/src/com/android/messaging/receiver/SmsReceiver.java b/src/com/android/messaging/receiver/SmsReceiver.java
index f1f9bcd..89a3710 100644
--- a/src/com/android/messaging/receiver/SmsReceiver.java
+++ b/src/com/android/messaging/receiver/SmsReceiver.java
@@ -48,6 +48,7 @@
 import com.android.messaging.util.BugleGservicesKeys;
 import com.android.messaging.util.DebugUtils;
 import com.android.messaging.util.LogUtil;
+import com.android.messaging.util.NotificationsUtil;
 import com.android.messaging.util.OsUtil;
 import com.android.messaging.util.PendingIntentConstants;
 import com.android.messaging.util.PhoneUtils;
@@ -252,11 +253,6 @@
         protected Style build(Builder builder) {
             return null;
         }
-
-        @Override
-        public boolean getNotificationVibrate() {
-            return true;
-        }
     }
 
     public static void postNewMessageSecondaryUserNotification() {
@@ -265,7 +261,8 @@
         final PendingIntent pendingIntent = UIIntents.get()
                 .getPendingIntentForSecondaryUserNewMessageNotification(context);
 
-        final NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
+        final NotificationCompat.Builder builder = new NotificationCompat.Builder(context,
+                NotificationsUtil.DEFAULT_CHANNEL_ID);
         builder.setContentTitle(resources.getString(R.string.secondary_user_new_message_title))
                 .setTicker(resources.getString(R.string.secondary_user_new_message_ticker))
                 .setSmallIcon(R.drawable.ic_sms_light)
@@ -282,10 +279,7 @@
         final NotificationManagerCompat notificationManager =
                 NotificationManagerCompat.from(Factory.get().getApplicationContext());
 
-        int defaults = Notification.DEFAULT_LIGHTS;
-        if (BugleNotifications.shouldVibrate(new SecondaryUserNotificationState())) {
-            defaults |= Notification.DEFAULT_VIBRATE;
-        }
+        int defaults = Notification.DEFAULT_LIGHTS | Notification.DEFAULT_VIBRATE;
         notification.defaults = defaults;
 
         notificationManager.notify(getNotificationTag(),
diff --git a/src/com/android/messaging/sms/SmsStorageStatusManager.java b/src/com/android/messaging/sms/SmsStorageStatusManager.java
index 4f03195..6bd68cb 100644
--- a/src/com/android/messaging/sms/SmsStorageStatusManager.java
+++ b/src/com/android/messaging/sms/SmsStorageStatusManager.java
@@ -25,6 +25,7 @@
 import com.android.messaging.Factory;
 import com.android.messaging.R;
 import com.android.messaging.ui.UIIntents;
+import com.android.messaging.util.NotificationsUtil;
 import com.android.messaging.util.PendingIntentConstants;
 import com.android.messaging.util.PhoneUtils;
 
@@ -65,7 +66,8 @@
         final PendingIntent pendingIntent = UIIntents.get()
                 .getPendingIntentForLowStorageNotifications(context);
 
-        final NotificationCompat.Builder builder = new NotificationCompat.Builder(context);
+        final NotificationCompat.Builder builder = new NotificationCompat.Builder(context,
+                NotificationsUtil.DEFAULT_CHANNEL_ID);
         builder.setContentTitle(resources.getString(R.string.sms_storage_low_title))
                 .setTicker(resources.getString(R.string.sms_storage_low_notification_ticker))
                 .setSmallIcon(R.drawable.ic_failed_light)
diff --git a/src/com/android/messaging/ui/ClassZeroActivity.java b/src/com/android/messaging/ui/ClassZeroActivity.java
index 129ec19..ccb15a0 100644
--- a/src/com/android/messaging/ui/ClassZeroActivity.java
+++ b/src/com/android/messaging/ui/ClassZeroActivity.java
@@ -33,6 +33,7 @@
 
 import com.android.messaging.R;
 import com.android.messaging.datamodel.action.ReceiveSmsMessageAction;
+import com.android.messaging.datamodel.BugleNotifications;
 import com.android.messaging.util.Assert;
 
 import java.util.ArrayList;
@@ -88,6 +89,8 @@
             return false;
         }
         mMessageQueue.add(messageValues);
+        // Show a notification to let the user know a new message has arrived
+        BugleNotifications.playClassZeroNotification();
         return true;
     }
 
diff --git a/src/com/android/messaging/ui/ConversationDrawables.java b/src/com/android/messaging/ui/ConversationDrawables.java
index cf858e2..46f483f 100644
--- a/src/com/android/messaging/ui/ConversationDrawables.java
+++ b/src/com/android/messaging/ui/ConversationDrawables.java
@@ -17,6 +17,7 @@
 
 import android.content.Context;
 import android.content.res.Resources;
+import android.content.res.TypedArray;
 import android.graphics.drawable.Drawable;
 
 import com.android.messaging.Factory;
@@ -52,6 +53,7 @@
     private int mIncomingAudioButtonColor;
     private int mSelectedBubbleColor;
     private int mThemeColor;
+    private TypedArray mColors;
 
     public static ConversationDrawables get() {
         if (sInstance == null) {
@@ -102,10 +104,11 @@
                 resources.getColor(R.color.message_audio_button_color_incoming);
         mSelectedBubbleColor = resources.getColor(R.color.message_bubble_color_selected);
         mThemeColor = resources.getColor(R.color.primary_color);
+        mColors = resources.obtainTypedArray(R.array.letter_tile_colors);
     }
 
     public Drawable getBubbleDrawable(final boolean selected, final boolean incoming,
-            final boolean needArrow, final boolean isError) {
+            final boolean needArrow, final boolean isError, final String identifier) {
         final Drawable protoDrawable;
         if (needArrow) {
             if (incoming) {
@@ -127,7 +130,13 @@
             if (isError) {
                 color = mIncomingErrorBubbleColor;
             } else {
-                color = mThemeColor;
+                if (identifier != null &&
+                        mContext.getResources().getBoolean(R.bool.contact_colors)) {
+                    int idcolor = Math.abs(identifier.hashCode()) % mColors.length();
+                    color = mColors.getColor(idcolor, mThemeColor);
+                } else {
+                    color = mThemeColor;
+                }
             }
         } else {
             color = mOutgoingBubbleColor;
diff --git a/src/com/android/messaging/ui/SmsStorageLowWarningFragment.java b/src/com/android/messaging/ui/SmsStorageLowWarningFragment.java
index 3ebfdcf..43908a6 100644
--- a/src/com/android/messaging/ui/SmsStorageLowWarningFragment.java
+++ b/src/com/android/messaging/ui/SmsStorageLowWarningFragment.java
@@ -85,7 +85,7 @@
     /**
      * The dialog to show for user to choose what delete actions to take when storage is low
      */
-    private static class ChooseActionDialogFragment extends DialogFragment {
+    public static class ChooseActionDialogFragment extends DialogFragment {
         public static ChooseActionDialogFragment newInstance() {
             return new ChooseActionDialogFragment();
         }
@@ -157,7 +157,7 @@
     /**
      * The dialog to confirm user's delete action
      */
-    private static class ConfirmationDialog extends DialogFragment {
+    public static class ConfirmationDialog extends DialogFragment {
         private Duration mDuration;
         private String mDurationString;
 
diff --git a/src/com/android/messaging/ui/UIIntents.java b/src/com/android/messaging/ui/UIIntents.java
index bf5edd7..2d10527 100644
--- a/src/com/android/messaging/ui/UIIntents.java
+++ b/src/com/android/messaging/ui/UIIntents.java
@@ -72,7 +72,7 @@
     // Sending VCard uri to VCard detail activity
     public static final String UI_INTENT_EXTRA_VCARD_URI = "vcard_uri";
 
-    public static final String CMAS_COMPONENT = "com.android.cellbroadcastreceiver";
+    public static final String CMAS_COMPONENT = "com.android.cellbroadcastreceiver.module";
 
     // Intent action for local broadcast receiver for conversation self id change.
     public static final String CONVERSATION_SELF_ID_CHANGE_BROADCAST_ACTION =
@@ -265,16 +265,6 @@
     public abstract Intent getViewUrlIntent(final String url);
 
     /**
-     * Get an intent to launch the ringtone picker
-     * @param title the title to show in the ringtone picker
-     * @param existingUri the currently set uri
-     * @param defaultUri the default uri if none is currently set
-     * @param toneType type of ringtone to pick, maybe any of RingtoneManager.TYPE_*
-     */
-    public abstract Intent getRingtonePickerIntent(final String title, final Uri existingUri,
-            final Uri defaultUri, final int toneType);
-
-    /**
      * Get an intent to launch the wireless alert viewer.
      */
     public abstract Intent getWirelessAlertsIntent();
diff --git a/src/com/android/messaging/ui/UIIntentsImpl.java b/src/com/android/messaging/ui/UIIntentsImpl.java
index 8a1224a..d64082d 100644
--- a/src/com/android/messaging/ui/UIIntentsImpl.java
+++ b/src/com/android/messaging/ui/UIIntentsImpl.java
@@ -27,7 +27,6 @@
 import android.content.Intent;
 import android.graphics.Point;
 import android.graphics.Rect;
-import android.media.RingtoneManager;
 import android.net.Uri;
 import android.os.Bundle;
 import android.provider.ContactsContract.Contacts;
@@ -451,16 +450,6 @@
     }
 
     @Override
-    public Intent getRingtonePickerIntent(final String title, final Uri existingUri,
-            final Uri defaultUri, final int toneType) {
-        return new Intent(RingtoneManager.ACTION_RINGTONE_PICKER)
-                .putExtra(RingtoneManager.EXTRA_RINGTONE_TYPE, toneType)
-                .putExtra(RingtoneManager.EXTRA_RINGTONE_TITLE, title)
-                .putExtra(RingtoneManager.EXTRA_RINGTONE_EXISTING_URI, existingUri)
-                .putExtra(RingtoneManager.EXTRA_RINGTONE_DEFAULT_URI, defaultUri);
-    }
-
-    @Override
     public PendingIntent getPendingIntentForLowStorageNotifications(final Context context) {
         final TaskStackBuilder taskStackBuilder = TaskStackBuilder.create(context);
         final Intent conversationListIntent = getConversationListActivityIntent(context);
diff --git a/src/com/android/messaging/ui/appsettings/ApplicationSettingsActivity.java b/src/com/android/messaging/ui/appsettings/ApplicationSettingsActivity.java
index d7abe85..19979a9 100644
--- a/src/com/android/messaging/ui/appsettings/ApplicationSettingsActivity.java
+++ b/src/com/android/messaging/ui/appsettings/ApplicationSettingsActivity.java
@@ -18,17 +18,12 @@
 
 import android.app.FragmentTransaction;
 import android.content.Intent;
-import android.content.SharedPreferences;
-import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
-import android.media.Ringtone;
-import android.media.RingtoneManager;
 import android.net.Uri;
 import android.os.Bundle;
 import android.preference.Preference;
 import android.preference.PreferenceFragment;
 import android.preference.PreferenceScreen;
-import android.preference.RingtonePreference;
-import android.preference.TwoStatePreference;
+import android.preference.SwitchPreference;
 import android.provider.Settings;
 import androidx.core.app.NavUtils;
 import android.text.TextUtils;
@@ -84,19 +79,17 @@
         return super.onOptionsItemSelected(item);
     }
 
-    public static class ApplicationSettingsFragment extends PreferenceFragment implements
-            OnSharedPreferenceChangeListener {
+    public static class ApplicationSettingsFragment extends PreferenceFragment {
 
-        private String mNotificationsEnabledPreferenceKey;
-        private TwoStatePreference mNotificationsEnabledPreference;
-        private String mRingtonePreferenceKey;
-        private RingtonePreference mRingtonePreference;
-        private Preference mVibratePreference;
+        private String mNotificationsPreferenceKey;
+        private Preference mNotificationsPreference;
         private String mSmsDisabledPrefKey;
         private Preference mSmsDisabledPreference;
         private String mSmsEnabledPrefKey;
         private Preference mSmsEnabledPreference;
         private boolean mIsSmsPreferenceClicked;
+        private String mSwipeRightToDeleteConversationkey;
+        private SwitchPreference mSwipeRightToDeleteConversationPreference;
 
         public ApplicationSettingsFragment() {
             // Required empty constructor
@@ -109,23 +102,19 @@
             getPreferenceManager().setSharedPreferencesName(BuglePrefs.SHARED_PREFERENCES_NAME);
             addPreferencesFromResource(R.xml.preferences_application);
 
-            mNotificationsEnabledPreferenceKey =
-                    getString(R.string.notifications_enabled_pref_key);
-            mNotificationsEnabledPreference = (TwoStatePreference) findPreference(
-                    mNotificationsEnabledPreferenceKey);
-            mRingtonePreferenceKey = getString(R.string.notification_sound_pref_key);
-            mRingtonePreference = (RingtonePreference) findPreference(mRingtonePreferenceKey);
-            mVibratePreference = findPreference(
-                    getString(R.string.notification_vibration_pref_key));
+            mNotificationsPreferenceKey =
+                    getString(R.string.notifications_pref_key);
+            mNotificationsPreference = findPreference(mNotificationsPreferenceKey);
             mSmsDisabledPrefKey = getString(R.string.sms_disabled_pref_key);
             mSmsDisabledPreference = findPreference(mSmsDisabledPrefKey);
             mSmsEnabledPrefKey = getString(R.string.sms_enabled_pref_key);
             mSmsEnabledPreference = findPreference(mSmsEnabledPrefKey);
+            mSwipeRightToDeleteConversationkey = getString(
+                    R.string.swipe_right_deletes_conversation_key);
+            mSwipeRightToDeleteConversationPreference =
+                    (SwitchPreference) findPreference(mSwipeRightToDeleteConversationkey);
             mIsSmsPreferenceClicked = false;
 
-            final SharedPreferences prefs = getPreferenceScreen().getSharedPreferences();
-            updateSoundSummary(prefs);
-
             if (!DebugUtils.isDebugEnabled()) {
                 final Preference debugCategory = findPreference(getString(
                         R.string.debug_pref_key));
@@ -147,8 +136,13 @@
         }
 
         @Override
-        public boolean onPreferenceTreeClick (PreferenceScreen preferenceScreen,
+        public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
                 Preference preference) {
+            if (preference.getKey() == mNotificationsPreferenceKey) {
+                Intent intent = new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS);
+                intent.putExtra(Settings.EXTRA_APP_PACKAGE, getContext().getPackageName());
+                startActivity(intent);
+            }
             if (preference.getKey() ==  mSmsDisabledPrefKey ||
                     preference.getKey() == mSmsEnabledPrefKey) {
                 mIsSmsPreferenceClicked = true;
@@ -156,35 +150,6 @@
             return super.onPreferenceTreeClick(preferenceScreen, preference);
         }
 
-        private void updateSoundSummary(final SharedPreferences sharedPreferences) {
-            // The silent ringtone just returns an empty string
-            String ringtoneName = mRingtonePreference.getContext().getString(
-                    R.string.silent_ringtone);
-
-            String ringtoneString = sharedPreferences.getString(mRingtonePreferenceKey, null);
-
-            // Bootstrap the default setting in the preferences so that we have a valid selection
-            // in the dialog the first time that the user opens it.
-            if (ringtoneString == null) {
-                ringtoneString = Settings.System.DEFAULT_NOTIFICATION_URI.toString();
-                final SharedPreferences.Editor editor = sharedPreferences.edit();
-                editor.putString(mRingtonePreferenceKey, ringtoneString);
-                editor.apply();
-            }
-
-            if (!TextUtils.isEmpty(ringtoneString)) {
-                final Uri ringtoneUri = Uri.parse(ringtoneString);
-                final Ringtone tone = RingtoneManager.getRingtone(mRingtonePreference.getContext(),
-                        ringtoneUri);
-
-                if (tone != null) {
-                    ringtoneName = tone.getTitle(mRingtonePreference.getContext());
-                }
-            }
-
-            mRingtonePreference.setSummary(ringtoneName);
-        }
-
         private void updateSmsEnabledPreferences() {
             if (!OsUtil.isAtLeastKLP()) {
                 getPreferenceScreen().removePreference(mSmsDisabledPreference);
@@ -215,48 +180,14 @@
                     getPreferenceScreen().removePreference(mSmsEnabledPreference);
                     mSmsDisabledPreference.setSummary(defaultSmsAppLabel);
                 }
-                updateNotificationsPreferences();
             }
             mIsSmsPreferenceClicked = false;
         }
 
-        private void updateNotificationsPreferences() {
-            final boolean canNotify = !OsUtil.isAtLeastKLP()
-                    || PhoneUtils.getDefault().isDefaultSmsApp();
-            mNotificationsEnabledPreference.setEnabled(canNotify);
-        }
-
-        @Override
-        public void onStart() {
-            super.onStart();
-            // We do this on start rather than on resume because the sound picker is in a
-            // separate activity.
-            getPreferenceScreen().getSharedPreferences()
-                    .registerOnSharedPreferenceChangeListener(this);
-        }
-
         @Override
         public void onResume() {
             super.onResume();
             updateSmsEnabledPreferences();
-            updateNotificationsPreferences();
-        }
-
-        @Override
-        public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences,
-                final String key) {
-            if (key.equals(mNotificationsEnabledPreferenceKey)) {
-                updateNotificationsPreferences();
-            } else if (key.equals(mRingtonePreferenceKey)) {
-                updateSoundSummary(sharedPreferences);
-            }
-        }
-
-        @Override
-        public void onStop() {
-            super.onStop();
-            getPreferenceScreen().getSharedPreferences()
-                    .unregisterOnSharedPreferenceChangeListener(this);
         }
     }
 }
diff --git a/src/com/android/messaging/ui/contact/AllContactsListViewHolder.java b/src/com/android/messaging/ui/contact/AllContactsListViewHolder.java
index 7263c54..960f04c 100644
--- a/src/com/android/messaging/ui/contact/AllContactsListViewHolder.java
+++ b/src/com/android/messaging/ui/contact/AllContactsListViewHolder.java
@@ -27,7 +27,7 @@
 public class AllContactsListViewHolder extends CustomHeaderPagerListViewHolder {
     public AllContactsListViewHolder(final Context context, final HostInterface clivHostInterface) {
         super(context, new ContactListAdapter(context, null, clivHostInterface,
-                true /* needAlphabetHeader */));
+                false /* needAlphabetHeader */));
     }
 
     @Override
diff --git a/src/com/android/messaging/ui/conversation/ConversationMessageView.java b/src/com/android/messaging/ui/conversation/ConversationMessageView.java
index 282e172..e2af75b 100644
--- a/src/com/android/messaging/ui/conversation/ConversationMessageView.java
+++ b/src/com/android/messaging/ui/conversation/ConversationMessageView.java
@@ -287,8 +287,7 @@
      * contains media attachments or if shouldShowSimplifiedVisualStyle() is true.
      */
     private boolean shouldShowMessageBubbleArrow() {
-        return !shouldShowSimplifiedVisualStyle()
-                && !(mData.hasAttachments() || mMessageHasYouTubeLink);
+        return false;
     }
 
     /**
@@ -701,7 +700,8 @@
                         isSelected(),
                         incoming,
                         false /* needArrow */,
-                        mData.hasIncomingErrorStatus());
+                        mData.hasIncomingErrorStatus(),
+                        mData.getSenderContactLookupKey());
                 textMinHeight = messageTextMinHeightDefault;
                 textTopMargin = messageTopPaddingClustered;
                 textTopPadding = textTopPaddingDefault;
@@ -729,7 +729,8 @@
                     isSelected(),
                     incoming,
                     shouldShowMessageBubbleArrow(),
-                    mData.hasIncomingErrorStatus());
+                    mData.hasIncomingErrorStatus(),
+                    mData.getSenderContactLookupKey());
             textMinHeight = messageTextMinHeightDefault;
             textTopMargin = 0;
             textTopPadding = textTopPaddingDefault;
@@ -1121,7 +1122,7 @@
             audioView.bindMessagePartData(attachment, mData.getIsIncoming(), isSelected());
             audioView.setBackground(ConversationDrawables.get().getBubbleDrawable(
                     isSelected(), mData.getIsIncoming(), false /* needArrow */,
-                    mData.hasIncomingErrorStatus()));
+                    mData.hasIncomingErrorStatus(), mData.getSenderContactLookupKey()));
         }
 
         @Override
@@ -1138,7 +1139,7 @@
                     attachment));
             personView.setBackground(ConversationDrawables.get().getBubbleDrawable(
                     isSelected(), mData.getIsIncoming(), false /* needArrow */,
-                    mData.hasIncomingErrorStatus()));
+                    mData.hasIncomingErrorStatus(), mData.getSenderContactLookupKey()));
             final int nameTextColorRes;
             final int detailsTextColorRes;
             if (isSelected()) {
diff --git a/src/com/android/messaging/ui/conversationlist/AbstractConversationListActivity.java b/src/com/android/messaging/ui/conversationlist/AbstractConversationListActivity.java
index a2b0bdf..e7bfd66 100644
--- a/src/com/android/messaging/ui/conversationlist/AbstractConversationListActivity.java
+++ b/src/com/android/messaging/ui/conversationlist/AbstractConversationListActivity.java
@@ -30,7 +30,6 @@
 import com.android.messaging.R;
 import com.android.messaging.datamodel.action.DeleteConversationAction;
 import com.android.messaging.datamodel.action.UpdateConversationArchiveStatusAction;
-import com.android.messaging.datamodel.action.UpdateConversationOptionsAction;
 import com.android.messaging.datamodel.action.UpdateDestinationBlockedAction;
 import com.android.messaging.datamodel.data.ConversationListData;
 import com.android.messaging.datamodel.data.ConversationListItemData;
@@ -191,23 +190,6 @@
     }
 
     @Override
-    public void onActionBarNotification(final Iterable<SelectedConversation> conversations,
-            final boolean isNotificationOn) {
-        for (final SelectedConversation conversation : conversations) {
-            UpdateConversationOptionsAction.enableConversationNotifications(
-                    conversation.conversationId, isNotificationOn);
-        }
-
-        final int textId = isNotificationOn ?
-                R.string.notification_on_toast_message : R.string.notification_off_toast_message;
-        final String message = getResources().getString(textId, 1);
-        UiUtils.showSnackBar(this, findViewById(android.R.id.list), message,
-            null /* undoRunnable */,
-            SnackBar.Action.SNACK_BAR_UNDO, mConversationListFragment.getSnackBarInteractions());
-        exitMultiSelectState();
-    }
-
-    @Override
     public void onActionBarAddContact(final SelectedConversation conversation) {
         final Uri avatarUri;
         if (conversation.icon != null) {
diff --git a/src/com/android/messaging/ui/conversationlist/ConversationListActivity.java b/src/com/android/messaging/ui/conversationlist/ConversationListActivity.java
index 636b0f5..4d83f12 100644
--- a/src/com/android/messaging/ui/conversationlist/ConversationListActivity.java
+++ b/src/com/android/messaging/ui/conversationlist/ConversationListActivity.java
@@ -31,6 +31,7 @@
     @Override
     protected void onCreate(final Bundle savedInstanceState) {
         Trace.beginSection("ConversationListActivity.onCreate");
+        setTheme(R.style.BugleTheme_ConversationListActivity);
         super.onCreate(savedInstanceState);
         setContentView(R.layout.conversation_list_activity);
         Trace.endSection();
diff --git a/src/com/android/messaging/ui/conversationlist/ConversationListItemView.java b/src/com/android/messaging/ui/conversationlist/ConversationListItemView.java
index b22ccfc..9331d10 100644
--- a/src/com/android/messaging/ui/conversationlist/ConversationListItemView.java
+++ b/src/com/android/messaging/ui/conversationlist/ConversationListItemView.java
@@ -58,6 +58,7 @@
 import com.android.messaging.util.Typefaces;
 import com.android.messaging.util.UiUtils;
 import com.android.messaging.util.UriUtil;
+import org.lineageos.messaging.util.PrefsUtils;
 
 import java.util.List;
 
@@ -75,6 +76,8 @@
     private static String sPlusOneString;
     private static String sPlusNString;
 
+    private static final int SWIPE_DIRECTION_RIGHT = 2;
+
     public interface HostInterface {
         boolean isConversationSelected(final String conversationId);
         void onConversationClicked(final ConversationListItemData conversationListItemData,
@@ -124,7 +127,6 @@
     private TextView mTimestampTextView;
     private ContactIconView mContactIconView;
     private ImageView mContactCheckmarkView;
-    private ImageView mNotificationBellView;
     private ImageView mFailedStatusIconView;
     private ImageView mCrossSwipeArchiveLeftImageView;
     private ImageView mCrossSwipeArchiveRightImageView;
@@ -150,7 +152,6 @@
         mTimestampTextView = (TextView) findViewById(R.id.conversation_timestamp);
         mContactIconView = (ContactIconView) findViewById(R.id.conversation_icon);
         mContactCheckmarkView = (ImageView) findViewById(R.id.conversation_checkmark);
-        mNotificationBellView = (ImageView) findViewById(R.id.conversation_notification_bell);
         mFailedStatusIconView = (ImageView) findViewById(R.id.conversation_failed_status_icon);
         mCrossSwipeArchiveLeftImageView = (ImageView) findViewById(R.id.crossSwipeArchiveIconLeft);
         mCrossSwipeArchiveRightImageView =
@@ -500,8 +501,17 @@
         mAudioAttachmentView.setOnLongClickListener(this);
         mAudioAttachmentView.setVisibility(audioPreviewVisiblity);
 
-        final int notificationBellVisiblity = mData.getNotificationEnabled() ? GONE : VISIBLE;
-        mNotificationBellView.setVisibility(notificationBellVisiblity);
+        if (PrefsUtils.isSwipeRightToDeleteEnabled()) {
+            mCrossSwipeArchiveLeftImageView.setImageDrawable(getResources()
+                    .getDrawable(R.drawable.ic_delete_small_dark));
+            mCrossSwipeArchiveRightImageView.setImageDrawable(getResources()
+                    .getDrawable(R.drawable.ic_archive_small_dark));
+        } else {
+            mCrossSwipeArchiveLeftImageView.setImageDrawable(getResources()
+                    .getDrawable(R.drawable.ic_archive_small_dark));
+            mCrossSwipeArchiveRightImageView.setImageDrawable(getResources()
+                    .getDrawable(R.drawable.ic_archive_small_dark));
+        }
     }
 
     public boolean isSwipeAnimatable() {
@@ -535,10 +545,16 @@
         }
     }
 
-    public void onSwipeComplete() {
+    public void onSwipeComplete(int swipeDirection) {
         final String conversationId = mData.getConversationId();
+        if (PrefsUtils.isSwipeRightToDeleteEnabled()
+                && swipeDirection == ConversationListSwipeHelper.SWIPE_DIRECTION_RIGHT) {
+            mData.deleteConversation();
+            UiUtils.showSnackBar(getContext(), getRootView(),
+                    getResources().getString(R.string.conversation_deleted));
+            return;
+        }
         UpdateConversationArchiveStatusAction.archiveConversation(conversationId);
-
         final Runnable undoRunnable = new Runnable() {
             @Override
             public void run() {
diff --git a/src/com/android/messaging/ui/conversationlist/ConversationListSwipeHelper.java b/src/com/android/messaging/ui/conversationlist/ConversationListSwipeHelper.java
index e5859a6..8b8ed0c 100644
--- a/src/com/android/messaging/ui/conversationlist/ConversationListSwipeHelper.java
+++ b/src/com/android/messaging/ui/conversationlist/ConversationListSwipeHelper.java
@@ -44,9 +44,9 @@
     private static final float PERCENTAGE_OF_WIDTH_TO_DISMISS = 0.4f;
     private static final float FLING_PERCENTAGE_OF_WIDTH_TO_DISMISS = 0.05f;
 
-    private static final int SWIPE_DIRECTION_NONE = 0;
-    private static final int SWIPE_DIRECTION_LEFT = 1;
-    private static final int SWIPE_DIRECTION_RIGHT = 2;
+    public static final int SWIPE_DIRECTION_NONE = 0;
+    public static final int SWIPE_DIRECTION_LEFT = 1;
+    public static final int SWIPE_DIRECTION_RIGHT = 2;
 
     private final RecyclerView mRecyclerView;
     private final long mDefaultRestoreAnimationDuration;
@@ -269,7 +269,7 @@
     private void onSwipeGestureEnd(final ConversationListItemView itemView,
             final int swipeDirection) {
         if (swipeDirection == SWIPE_DIRECTION_RIGHT || swipeDirection == SWIPE_DIRECTION_LEFT) {
-            itemView.onSwipeComplete();
+            itemView.onSwipeComplete(swipeDirection);
         }
 
         // Balances out onSwipeGestureStart.
diff --git a/src/com/android/messaging/ui/conversationlist/ForwardMessageActivity.java b/src/com/android/messaging/ui/conversationlist/ForwardMessageActivity.java
index 61e3640..96ca085 100644
--- a/src/com/android/messaging/ui/conversationlist/ForwardMessageActivity.java
+++ b/src/com/android/messaging/ui/conversationlist/ForwardMessageActivity.java
@@ -46,9 +46,10 @@
 
     @Override
     public void onAttachFragment(final Fragment fragment) {
-        Assert.isTrue(fragment instanceof ConversationListFragment);
-        final ConversationListFragment clf = (ConversationListFragment) fragment;
-        clf.setHost(this);
+        if (fragment instanceof ConversationListFragment) {
+            final ConversationListFragment clf = (ConversationListFragment) fragment;
+            clf.setHost(this);
+        }
     }
 
     @Override
diff --git a/src/com/android/messaging/ui/conversationlist/MultiSelectActionModeCallback.java b/src/com/android/messaging/ui/conversationlist/MultiSelectActionModeCallback.java
index 64d1436..96c962e 100644
--- a/src/com/android/messaging/ui/conversationlist/MultiSelectActionModeCallback.java
+++ b/src/com/android/messaging/ui/conversationlist/MultiSelectActionModeCallback.java
@@ -37,8 +37,6 @@
         void onActionBarDelete(Collection<SelectedConversation> conversations);
         void onActionBarArchive(Iterable<SelectedConversation> conversations,
                 boolean isToArchive);
-        void onActionBarNotification(Iterable<SelectedConversation> conversations,
-                boolean isNotificationOn);
         void onActionBarAddContact(final SelectedConversation conversation);
         void onActionBarBlock(final SelectedConversation conversation);
         void onActionBarHome();
@@ -52,7 +50,6 @@
         public final CharSequence participantLookupKey;
         public final boolean isGroup;
         public final boolean isArchived;
-        public final boolean notificationEnabled;
         public SelectedConversation(ConversationListItemData data) {
             conversationId = data.getConversationId();
             timestamp = data.getTimestamp();
@@ -61,7 +58,6 @@
             participantLookupKey = data.getParticipantLookupKey();
             isGroup = data.getIsGroup();
             isArchived = data.getIsArchived();
-            notificationEnabled = data.getNotificationEnabled();
         }
     }
 
@@ -72,8 +68,6 @@
     private MenuItem mUnarchiveMenuItem;
     private MenuItem mAddContactMenuItem;
     private MenuItem mBlockMenuItem;
-    private MenuItem mNotificationOnMenuItem;
-    private MenuItem mNotificationOffMenuItem;
     private boolean mHasInflated;
 
     public MultiSelectActionModeCallback(final Listener listener) {
@@ -89,8 +83,6 @@
         mUnarchiveMenuItem = menu.findItem(R.id.action_unarchive);
         mAddContactMenuItem = menu.findItem(R.id.action_add_contact);
         mBlockMenuItem = menu.findItem(R.id.action_block);
-        mNotificationOffMenuItem = menu.findItem(R.id.action_notification_off);
-        mNotificationOnMenuItem = menu.findItem(R.id.action_notification_on);
         mHasInflated = true;
         updateActionIconsVisiblity();
         return true;
@@ -113,12 +105,6 @@
             case R.id.action_unarchive:
                 mListener.onActionBarArchive(mSelectedConversations.values(), false);
                 return true;
-            case R.id.action_notification_off:
-                mListener.onActionBarNotification(mSelectedConversations.values(), false);
-                return true;
-            case R.id.action_notification_on:
-                mListener.onActionBarNotification(mSelectedConversations.values(), true);
-                return true;
             case R.id.action_add_contact:
                 Assert.isTrue(mSelectedConversations.size() == 1);
                 mListener.onActionBarAddContact(mSelectedConversations.valueAt(0));
@@ -186,16 +172,8 @@
 
         boolean hasCurrentlyArchived = false;
         boolean hasCurrentlyUnarchived = false;
-        boolean hasCurrentlyOnNotification = false;
-        boolean hasCurrentlyOffNotification = false;
         final Iterable<SelectedConversation> conversations = mSelectedConversations.values();
         for (final SelectedConversation conversation : conversations) {
-            if (conversation.notificationEnabled) {
-                hasCurrentlyOnNotification = true;
-            } else {
-                hasCurrentlyOffNotification = true;
-            }
-
             if (conversation.isArchived) {
                 hasCurrentlyArchived = true;
             } else {
@@ -203,15 +181,10 @@
             }
 
             // If we found at least one of each example we don't need to keep looping.
-            if (hasCurrentlyOffNotification && hasCurrentlyOnNotification &&
-                    hasCurrentlyArchived && hasCurrentlyUnarchived) {
+            if (hasCurrentlyArchived && hasCurrentlyUnarchived) {
                 break;
             }
         }
-        // If we have notification off conversations we show on button, if we have notification on
-        // conversation we show off button. We can show both if we have a mixture.
-        mNotificationOffMenuItem.setVisible(hasCurrentlyOnNotification);
-        mNotificationOnMenuItem.setVisible(hasCurrentlyOffNotification);
 
         mArchiveMenuItem.setVisible(hasCurrentlyUnarchived);
         mUnarchiveMenuItem.setVisible(hasCurrentlyArchived);
diff --git a/src/com/android/messaging/ui/conversationsettings/PeopleAndOptionsFragment.java b/src/com/android/messaging/ui/conversationsettings/PeopleAndOptionsFragment.java
index b86d952..00af751 100644
--- a/src/com/android/messaging/ui/conversationsettings/PeopleAndOptionsFragment.java
+++ b/src/com/android/messaging/ui/conversationsettings/PeopleAndOptionsFragment.java
@@ -18,12 +18,12 @@
 import android.app.Activity;
 import android.app.AlertDialog;
 import android.app.Fragment;
+import android.app.NotificationManager;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.database.Cursor;
-import android.media.RingtoneManager;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.provider.Settings;
@@ -49,6 +49,7 @@
 import com.android.messaging.ui.PersonItemView;
 import com.android.messaging.ui.UIIntents;
 import com.android.messaging.ui.conversation.ConversationActivity;
+import com.android.messaging.util.NotificationsUtil;
 import com.android.messaging.util.Assert;
 
 import java.util.ArrayList;
@@ -62,11 +63,10 @@
     private ListView mListView;
     private OptionsListAdapter mOptionsListAdapter;
     private PeopleListAdapter mPeopleListAdapter;
+    private List<ParticipantData> mOtherParticipants;
     private final Binding<PeopleAndOptionsData> mBinding =
             BindingBase.createBinding(this);
 
-    private static final int REQUEST_CODE_RINGTONE_PICKER = 1000;
-
     @Override
     public void onCreate(final Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
@@ -90,17 +90,6 @@
     }
 
     @Override
-    public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
-        super.onActivityResult(requestCode, resultCode, data);
-        if (resultCode == Activity.RESULT_OK && requestCode == REQUEST_CODE_RINGTONE_PICKER) {
-            final Parcelable pick = data.getParcelableExtra(
-                    RingtoneManager.EXTRA_RINGTONE_PICKED_URI);
-            final String pickedUri = pick == null ? "" : pick.toString();
-            mBinding.getData().setConversationNotificationSound(mBinding, pickedUri);
-        }
-    }
-
-    @Override
     public void onDestroy() {
         super.onDestroy();
         mBinding.unbind();
@@ -125,30 +114,31 @@
             final List<ParticipantData> participants) {
         mBinding.ensureBound(data);
         mPeopleListAdapter.updateParticipants(participants);
+        mOtherParticipants = participants;
         final ParticipantData otherParticipant = participants.size() == 1 ?
                 participants.get(0) : null;
         mOptionsListAdapter.setOtherParticipant(otherParticipant);
     }
 
     @Override
-    public void onOptionsItemViewClicked(final PeopleOptionsItemData item,
-            final boolean isChecked) {
+    public void onOptionsItemViewClicked(final PeopleOptionsItemData item) {
         switch (item.getItemId()) {
-            case PeopleOptionsItemData.SETTING_NOTIFICATION_ENABLED:
-                mBinding.getData().enableConversationNotifications(mBinding, isChecked);
-                break;
-
-            case PeopleOptionsItemData.SETTING_NOTIFICATION_SOUND_URI:
-                final Intent ringtonePickerIntent = UIIntents.get().getRingtonePickerIntent(
-                        getString(R.string.notification_sound_pref_title),
-                        item.getRingtoneUri(), Settings.System.DEFAULT_NOTIFICATION_URI,
-                        RingtoneManager.TYPE_NOTIFICATION);
-                startActivityForResult(ringtonePickerIntent, REQUEST_CODE_RINGTONE_PICKER);
-                break;
-
-            case PeopleOptionsItemData.SETTING_NOTIFICATION_VIBRATION:
-                mBinding.getData().enableConversationNotificationVibration(mBinding,
-                        isChecked);
+            case PeopleOptionsItemData.SETTING_NOTIFICATION:
+                ArrayList<String> participantsNames = new ArrayList<String>();
+                for (ParticipantData participant : mOtherParticipants) {
+                    participantsNames.add(participant.getDisplayName(true));
+                }
+                NotificationsUtil.createNotificationChannelGroup(getActivity(),
+                        NotificationsUtil.CONVERSATION_GROUP_NAME,
+                        R.string.notification_channel_messages_title);
+                NotificationsUtil.createNotificationChannel(getActivity(),
+                        mBinding.getData().getConversationId(),
+                        String.join(", ", participantsNames),
+                        NotificationManager.IMPORTANCE_DEFAULT,
+                        NotificationsUtil.CONVERSATION_GROUP_NAME);
+                Intent intent = new Intent(Settings.ACTION_APP_NOTIFICATION_SETTINGS);
+                intent.putExtra(Settings.EXTRA_APP_PACKAGE, getContext().getPackageName());
+                startActivity(intent);
                 break;
 
             case PeopleOptionsItemData.SETTING_BLOCKED:
diff --git a/src/com/android/messaging/ui/conversationsettings/PeopleOptionsItemView.java b/src/com/android/messaging/ui/conversationsettings/PeopleOptionsItemView.java
index 5b6f3b0..91fd10c 100644
--- a/src/com/android/messaging/ui/conversationsettings/PeopleOptionsItemView.java
+++ b/src/com/android/messaging/ui/conversationsettings/PeopleOptionsItemView.java
@@ -38,7 +38,7 @@
      * Implemented by the host of this view that handles options click event.
      */
     public interface HostInterface {
-        void onOptionsItemViewClicked(PeopleOptionsItemData item, boolean isChecked);
+        void onOptionsItemViewClicked(PeopleOptionsItemData item);
     }
 
     private TextView mTitle;
@@ -55,12 +55,10 @@
     @Override
     protected void onFinishInflate () {
         mTitle = (TextView) findViewById(R.id.title);
-        mSubtitle = (TextView) findViewById(R.id.subtitle);
-        mSwitch = (SwitchCompat) findViewById(R.id.switch_button);
         setOnClickListener(new OnClickListener() {
             @Override
             public void onClick(final View v) {
-                mHostInterface.onOptionsItemViewClicked(mData, !mData.getChecked());
+                mHostInterface.onOptionsItemViewClicked(mData);
             }
         });
     }
@@ -72,28 +70,5 @@
         mHostInterface = hostInterface;
 
         mTitle.setText(mData.getTitle());
-        final String subtitle = mData.getSubtitle();
-        if (TextUtils.isEmpty(subtitle)) {
-            mSubtitle.setVisibility(GONE);
-        } else {
-            mSubtitle.setVisibility(VISIBLE);
-            mSubtitle.setText(subtitle);
-        }
-
-        if (mData.getCheckable()) {
-            mSwitch.setVisibility(VISIBLE);
-            mSwitch.setChecked(mData.getChecked());
-        } else {
-            mSwitch.setVisibility(GONE);
-        }
-
-        final boolean enabled = mData.getEnabled();
-        if (enabled != isEnabled()) {
-            mTitle.setEnabled(enabled);
-            mSubtitle.setEnabled(enabled);
-            mSwitch.setEnabled(enabled);
-            setAlpha(enabled ? 1.0f : 0.5f);
-            setEnabled(enabled);
-        }
     }
 }
diff --git a/src/com/android/messaging/ui/mediapicker/AudioMediaChooser.java b/src/com/android/messaging/ui/mediapicker/AudioMediaChooser.java
index 5d79293..3553f10 100644
--- a/src/com/android/messaging/ui/mediapicker/AudioMediaChooser.java
+++ b/src/com/android/messaging/ui/mediapicker/AudioMediaChooser.java
@@ -123,6 +123,10 @@
             final int requestCode, final String permissions[], final int[] grantResults) {
         if (requestCode == MediaPicker.RECORD_AUDIO_PERMISSION_REQUEST_CODE) {
             final boolean permissionGranted = grantResults[0] == PackageManager.PERMISSION_GRANTED;
+            // onRequestPermissionsResult can sometimes get called before createView().
+            if (mEnabledView == null) {
+                return;
+            }
             mEnabledView.setVisibility(permissionGranted ? View.VISIBLE : View.GONE);
             mMissingPermissionView.setVisibility(permissionGranted ? View.GONE : View.VISIBLE);
         }
diff --git a/src/com/android/messaging/util/NotificationsUtil.java b/src/com/android/messaging/util/NotificationsUtil.java
new file mode 100644
index 0000000..591f15a
--- /dev/null
+++ b/src/com/android/messaging/util/NotificationsUtil.java
@@ -0,0 +1,101 @@
+/*
+ * Copyright (C) 2019 The LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.messaging.util;
+
+import android.app.NotificationChannel;
+import android.app.NotificationChannelGroup;
+import android.app.NotificationManager;
+import android.content.Context;
+import android.os.Build;
+
+public final class NotificationsUtil {
+    public static final String DEFAULT_CHANNEL_ID = "messaging_channel";
+    public static final String CONVERSATION_GROUP_NAME = "conversation_group";
+
+    private NotificationsUtil() {
+    }
+
+    public static void createNotificationChannel(Context context, String id,
+            int titleResId, int priority, String groupId) {
+        String title = context.getString(titleResId);
+        createNotificationChannel(context, id, title, priority, groupId);
+    }
+
+    public static void createNotificationChannel(Context context, String id,
+            String title, int priority, String groupId) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        NotificationChannel existing = manager.getNotificationChannel(id);
+        if (existing != null) {
+            return;
+        }
+
+        NotificationChannel newChannel = new NotificationChannel(id, title, priority);
+        newChannel.enableLights(true);
+        if (groupId != null) {
+            newChannel.setGroup(groupId);
+        }
+        manager.createNotificationChannel(newChannel);
+    }
+
+    public static void deleteNotificationChannel(Context context, String id) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        manager.deleteNotificationChannel(id);
+    }
+
+    public static void createNotificationChannelGroup(Context context, String id,
+            int titleResId) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return;
+        }
+
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        NotificationChannelGroup existing = manager.getNotificationChannelGroup(id);
+        if (existing != null) {
+            return;
+        }
+
+        String title = context.getString(titleResId);
+        NotificationChannelGroup newChannelGroup = new NotificationChannelGroup(id, title);
+        manager.createNotificationChannelGroup(newChannelGroup);
+    }
+
+    public static NotificationChannel getNotificationChannel(Context context, String id) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return null;
+        }
+
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        return manager.getNotificationChannel(id);
+    }
+
+    public static NotificationChannelGroup getNotificationChannelGroup(Context context, String id) {
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+            return null;
+        }
+
+        NotificationManager manager = context.getSystemService(NotificationManager.class);
+        return manager.getNotificationChannelGroup(id);
+    }
+}
diff --git a/src/com/android/messaging/util/RingtoneUtil.java b/src/com/android/messaging/util/RingtoneUtil.java
deleted file mode 100644
index a7facfb..0000000
--- a/src/com/android/messaging/util/RingtoneUtil.java
+++ /dev/null
@@ -1,53 +0,0 @@
-/*
- * Copyright (C) 2015 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-package com.android.messaging.util;
-
-import android.content.Context;
-import android.net.Uri;
-import android.provider.Settings;
-import android.text.TextUtils;
-
-import com.android.messaging.Factory;
-import com.android.messaging.R;
-
-public class RingtoneUtil {
-    /**
-     * Return a ringtone Uri for the string representation passed in. Use the app
-     * and system defaults as fallbacks
-     * @param ringtoneString is the ringtone to resolve
-     * @return the Uri of the ringtone or the fallback ringtone
-     */
-    public static Uri getNotificationRingtoneUri(String ringtoneString) {
-        if (ringtoneString == null) {
-            // No override specified, fall back to system-wide setting.
-            final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
-            final Context context = Factory.get().getApplicationContext();
-            final String prefKey = context.getString(R.string.notification_sound_pref_key);
-            ringtoneString = prefs.getString(prefKey, null);
-        }
-
-        if (!TextUtils.isEmpty(ringtoneString)) {
-            // We have set a value, even if it is the default Uri at some point
-            return Uri.parse(ringtoneString);
-        } else if (ringtoneString == null) {
-            // We have no setting specified (== null), so we default to the system default
-            return Settings.System.DEFAULT_NOTIFICATION_URI;
-        } else {
-            // An empty string (== "") here is the result of selecting "None" as the ringtone
-            return null;
-        }
-    }
-}
diff --git a/src/com/android/messaging/util/UiUtils.java b/src/com/android/messaging/util/UiUtils.java
index 6e0c16e..17c877f 100644
--- a/src/com/android/messaging/util/UiUtils.java
+++ b/src/com/android/messaging/util/UiUtils.java
@@ -132,6 +132,16 @@
                                         null /* placement */);
     }
 
+    public static void showSnackBar(final Context context, @NonNull final View parentView,
+            final String message) {
+        Assert.notNull(context);
+        Assert.isTrue(!TextUtils.isEmpty(message));
+        SnackBarManager.get()
+            .newBuilder(parentView)
+            .setText(message)
+            .show();
+    }
+
     public static void showSnackBarWithCustomAction(final Context context,
             @NonNull final View parentView,
             @NonNull final String message,
diff --git a/src/com/android/messaging/widget/WidgetConversationListService.java b/src/com/android/messaging/widget/WidgetConversationListService.java
index b67bd79..023c56d 100644
--- a/src/com/android/messaging/widget/WidgetConversationListService.java
+++ b/src/com/android/messaging/widget/WidgetConversationListService.java
@@ -120,10 +120,6 @@
                 remoteViews.setTextViewText(R.id.from,
                         boldifyIfUnread(conv.getName(), hasUnreadMessages));
 
-                // Notifications turned off mini-bell icon
-                remoteViews.setViewVisibility(R.id.conversation_notification_bell,
-                        conv.getNotificationEnabled() ? View.GONE : View.VISIBLE);
-
                 // On click intent.
                 final Intent intent = UIIntents.get().getIntentForConversationActivity(mContext,
                         conv.getConversationId(), null /* draft */);
diff --git a/src/org/lineageos/messaging/util/PrefsUtils.java b/src/org/lineageos/messaging/util/PrefsUtils.java
new file mode 100644
index 0000000..fa08af4
--- /dev/null
+++ b/src/org/lineageos/messaging/util/PrefsUtils.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 The CyanogenMod Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.lineageos.messaging.util;
+
+import android.content.Context;
+import com.android.messaging.Factory;
+import com.android.messaging.R;
+import com.android.messaging.util.BuglePrefs;
+
+public class PrefsUtils {
+    private PrefsUtils() {
+        //Don't instantiate
+    }
+
+    /**
+     * Returns whether or not swipe to dismiss in the ConversationListFragment deletes
+     * the conversation rather than archiving it.
+     * @return hopefully true
+     */
+    public static boolean isSwipeRightToDeleteEnabled() {
+        final BuglePrefs prefs = BuglePrefs.getApplicationPrefs();
+        final Context context = Factory.get().getApplicationContext();
+        final String prefKey = context.getString(R.string.swipe_right_deletes_conversation_key);
+        final boolean defaultValue = context.getResources().getBoolean(
+                R.bool.swipe_right_deletes_conversation_default);
+        return prefs.getBoolean(prefKey, defaultValue);
+    }
+}
diff --git a/tests/AndroidManifest.xml b/tests/AndroidManifest.xml
index 07f0d17..0879287 100644
--- a/tests/AndroidManifest.xml
+++ b/tests/AndroidManifest.xml
@@ -17,7 +17,7 @@
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.android.messaging.test" >
 
-    <uses-sdk android:minSdkVersion="16" android:targetSdkVersion="24"/>
+    <uses-sdk android:minSdkVersion="16" android:targetSdkVersion="29"/>
 
     <application android:label="Messaging Tests" >
         <uses-library android:name="android.test.runner" />
diff --git a/tests/src/com/android/messaging/datamodel/action/ReadWriteDraftMessageActionTest.java b/tests/src/com/android/messaging/datamodel/action/ReadWriteDraftMessageActionTest.java
index e977aa7..1064aa3 100644
--- a/tests/src/com/android/messaging/datamodel/action/ReadWriteDraftMessageActionTest.java
+++ b/tests/src/com/android/messaging/datamodel/action/ReadWriteDraftMessageActionTest.java
@@ -112,7 +112,7 @@
         participants.add(ParticipantData.getFromRawPhoneBySystemLocale(participantNumber));
 
         final String conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
-                senderBlocked, participants, false, false, null);
+                senderBlocked, participants);
         assertNotNull("No conversation", conversationId);
         return conversationId;
     }
@@ -188,7 +188,7 @@
         participants.add(ParticipantData.getFromRawPhoneBySystemLocale(Long.toString(phoneNumber)));
 
         conversationId = BugleDatabaseOperations.getOrCreateConversation(db, threadId,
-                senderBlocked, participants, false, false, null);
+                senderBlocked, participants);
         assertNotNull("No conversation", conversationId);
 
         final MessageData actual = BugleDatabaseOperations.readDraftMessageData(db, conversationId,
