diff --git a/Android.mk b/Android.mk
index 0679ac1..e4d7382 100644
--- a/Android.mk
+++ b/Android.mk
@@ -16,15 +16,21 @@
 res_dirs := res $(contacts_common_dir)/res $(phone_common_dir)/res
 asset_dirs := $(contacts_common_dir)/assets
 
+src_dirs += src-N $(contacts_common_dir)/src-N $(phone_common_dir)/src-N
+
 LOCAL_SRC_FILES := $(call all-java-files-under, $(src_dirs))
 LOCAL_RESOURCE_DIR := $(addprefix $(LOCAL_PATH)/, $(res_dirs)) \
-    $(support_library_root_dir)/v7/cardview/res
+    $(support_library_root_dir)/v7/appcompat/res \
+    $(support_library_root_dir)/v7/cardview/res \
+    $(support_library_root_dir)/design/res
 LOCAL_ASSET_DIR := $(addprefix $(LOCAL_PATH)/, $(asset_dirs))
 
 LOCAL_AAPT_FLAGS := \
     --auto-add-overlay \
     --extra-packages com.android.contacts.common \
     --extra-packages com.android.phone.common \
+    --extra-packages android.support.v7.appcompat \
+    --extra-packages android.support.design \
     --extra-packages android.support.v7.cardview
 
 LOCAL_STATIC_JAVA_LIBRARIES := \
@@ -32,9 +38,11 @@
     android-common \
     guava \
     android-support-v13 \
+    android-support-v7-appcompat \
     android-support-v7-cardview \
     android-support-v7-palette \
     android-support-v4 \
+    android-support-design \
     libphonenumber
 
 LOCAL_PACKAGE_NAME := Contacts
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 12d4b0c..74a8a91 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -16,10 +16,10 @@
 
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="com.android.contacts"
-    android:versionCode="10302"
-    android:versionName="1.3.02">
+    android:versionCode="10401"
+    android:versionName="1.4.1">
 
-    <uses-sdk android:minSdkVersion="23" android:targetSdkVersion="23" />
+    <uses-sdk android:minSdkVersion="21" android:targetSdkVersion="23" />
     <original-package android:name="com.android.contacts" />
 
     <uses-permission android:name="android.permission.CALL_PHONE" />
@@ -29,6 +29,7 @@
     <uses-permission android:name="android.permission.GET_ACCOUNTS" />
     <uses-permission android:name="android.permission.ACCESS_FINE_LOCATION" />
     <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION" />
+    <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
     <uses-permission android:name="android.permission.READ_PROFILE" />
     <uses-permission android:name="android.permission.WRITE_PROFILE" />
     <uses-permission android:name="android.permission.INTERNET" />
@@ -46,11 +47,13 @@
     <uses-permission android:name="android.permission.READ_SMS" />
     <uses-permission android:name="android.permission.READ_CALENDAR" />
     <uses-permission android:name="com.android.voicemail.permission.READ_VOICEMAIL" />
+    <!-- Following used for Contact metadata syncing -->
+    <uses-permission android:name="android.permission.WRITE_SYNC_SETTINGS" />
 
     <application
         android:name="com.android.contacts.ContactsApplication"
         android:label="@string/applicationLabel"
-        android:icon="@mipmap/ic_contacts_clr_48cv_44dp"
+        android:icon="@mipmap/ic_contacts_launcher"
         android:taskAffinity="android.task.contacts"
         android:hardwareAccelerated="true"
         android:supportsRtl="true"
@@ -60,9 +63,10 @@
         <!-- The main Contacts activity with the contact list, favorites, and groups. -->
         <activity android:name=".activities.PeopleActivity"
             android:label="@string/launcherActivityLabel"
-            android:theme="@style/PeopleTheme"
+            android:theme="@style/PeopleActivityTheme"
             android:clearTaskOnLaunch="true"
             android:launchMode="singleTop"
+            android:resizeableActivity="true"
         >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
@@ -199,7 +203,7 @@
 
         <!-- Used to set options -->
         <activity
-            android:name=".preference.ContactsPreferenceActivity"
+            android:name=".common.preference.ContactsPreferenceActivity"
             android:label="@string/activity_title_settings"
             android:theme="@style/ContactsPreferencesTheme"
             android:exported="false"/>
@@ -259,7 +263,7 @@
 
         <activity
             android:name=".quickcontact.QuickContactActivity"
-            android:label="@string/launcherActivityLabel"
+            android:label="@string/quickContactActivityLabel"
             android:theme="@style/Theme.QuickContact"
             android:launchMode="singleTop"
             android:excludeFromRecents="true"
@@ -302,8 +306,7 @@
         <activity-alias android:name="alias.DialShortcut"
             android:targetActivity=".activities.ContactSelectionActivity"
             android:label="@string/shortcutDialContact"
-            android:icon="@drawable/logo_quick_contacts_dialer_color_44in48dp"
-            android:enabled="@*android:bool/config_voice_capable">
+            android:icon="@drawable/logo_quick_contacts_dialer_color_44in48dp">
 
             <intent-filter>
                 <action android:name="android.intent.action.CREATE_SHORTCUT" />
@@ -316,8 +319,7 @@
         <activity-alias android:name="alias.MessageShortcut"
             android:targetActivity=".activities.ContactSelectionActivity"
             android:label="@string/shortcutMessageContact"
-            android:icon="@drawable/logo_quick_contacts_mail_color_44in48dp"
-            android:enabled="@*android:bool/config_voice_capable">
+            android:icon="@drawable/logo_quick_contacts_mail_color_44in48dp">
 
             <intent-filter>
                 <action android:name="android.intent.action.CREATE_SHORTCUT" />
@@ -344,7 +346,7 @@
         <!-- Edit or create a contact with only the most important fields displayed initially. -->
         <activity
             android:name=".activities.CompactContactEditorActivity"
-            android:label="@string/launcherActivityLabel"
+            android:label="@string/editContactActivityLabel"
             android:theme="@style/EditorActivityTheme"
             android:windowSoftInputMode="stateHidden|adjustResize">
 
@@ -367,7 +369,7 @@
         <!-- Edit or create a contact with all fields displayed. -->
         <activity
             android:name=".activities.ContactEditorActivity"
-            android:label="@string/launcherActivityLabel"
+            android:label="@string/editContactActivityLabel"
             android:theme="@style/EditorActivityTheme"
             android:windowSoftInputMode="stateHidden|adjustResize"
             android:exported="false">
@@ -416,6 +418,17 @@
             </intent-filter>
         </activity>
 
+        <!-- Blocked numbers activity -->
+        <activity android:name=".activities.BlockedNumbersActivity"
+                  android:label="@string/blocked_numbers_title"
+                  android:theme="@style/BlockedNumbersStyle">
+            <intent-filter>
+                <action android:name="android.intent.action.EDIT" />
+                <data android:mimeType="blocked_numbers/*" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
         <!-- vCard related -->
         <activity android:name=".common.vcard.ImportVCardActivity"
             android:label="@string/launcherActivityLabel"
diff --git a/proguard.flags b/proguard.flags
index 05071df..feaa360 100644
--- a/proguard.flags
+++ b/proguard.flags
@@ -9,6 +9,8 @@
   public void *(android.view.MenuItem);
 }
 
+-keep class com.android.contacts.common.** { *;}
+
 # Any class or method annotated with NeededForTesting or NeededForReflection.
 -keep @com.android.contacts.common.testing.NeededForTesting class *
 -keep @com.android.contacts.test.NeededForReflection class *
diff --git a/res/drawable-hdpi/empty_contacts.png b/res/drawable-hdpi/empty_contacts.png
new file mode 100644
index 0000000..d3c0378
--- /dev/null
+++ b/res/drawable-hdpi/empty_contacts.png
Binary files differ
diff --git a/res/drawable-hdpi/ic_not_interested_googblue_24dp.png b/res/drawable-hdpi/ic_not_interested_googblue_24dp.png
new file mode 100644
index 0000000..26a26f9
--- /dev/null
+++ b/res/drawable-hdpi/ic_not_interested_googblue_24dp.png
Binary files differ
diff --git a/res/drawable-hdpi/ic_remove.png b/res/drawable-hdpi/ic_remove.png
new file mode 100644
index 0000000..1ee6adf
--- /dev/null
+++ b/res/drawable-hdpi/ic_remove.png
Binary files differ
diff --git a/res/drawable-hdpi/search_shadow.9.png b/res/drawable-hdpi/search_shadow.9.png
new file mode 100644
index 0000000..92b4f5b
--- /dev/null
+++ b/res/drawable-hdpi/search_shadow.9.png
Binary files differ
diff --git a/res/drawable-mdpi/empty_contacts.png b/res/drawable-mdpi/empty_contacts.png
new file mode 100644
index 0000000..2ce7eae
--- /dev/null
+++ b/res/drawable-mdpi/empty_contacts.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_not_interested_googblue_24dp.png b/res/drawable-mdpi/ic_not_interested_googblue_24dp.png
new file mode 100644
index 0000000..d7d5c58
--- /dev/null
+++ b/res/drawable-mdpi/ic_not_interested_googblue_24dp.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_remove.png b/res/drawable-mdpi/ic_remove.png
new file mode 100644
index 0000000..2c134ea
--- /dev/null
+++ b/res/drawable-mdpi/ic_remove.png
Binary files differ
diff --git a/res/drawable-mdpi/search_shadow.9.png b/res/drawable-mdpi/search_shadow.9.png
new file mode 100644
index 0000000..0c33905
--- /dev/null
+++ b/res/drawable-mdpi/search_shadow.9.png
Binary files differ
diff --git a/res/xml/preference_headers.xml b/res/drawable-v21/floating_action_button.xml
similarity index 62%
copy from res/xml/preference_headers.xml
copy to res/drawable-v21/floating_action_button.xml
index 98019fd..9a90112 100644
--- a/res/xml/preference_headers.xml
+++ b/res/drawable-v21/floating_action_button.xml
@@ -1,5 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2010 The Android Open Source Project
+<!--
+     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.
@@ -14,11 +15,11 @@
      limitations under the License.
 -->
 
-<preference-headers
-    xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <header
-        android:fragment="com.android.contacts.common.preference.DisplayOptionsPreferenceFragment"
-        android:title="@string/preference_displayOptions" />
-
-</preference-headers>
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+     android:color="@color/contacts_accent_color">
+     <item android:id="@android:id/mask">
+          <shape android:shape="oval">
+               <solid android:color="@android:color/white" />
+          </shape>
+     </item>
+</ripple>
\ No newline at end of file
diff --git a/res/drawable-v21/view_pager_tab_background.xml b/res/drawable-v21/view_pager_tab_background.xml
new file mode 100644
index 0000000..00c6db7
--- /dev/null
+++ b/res/drawable-v21/view_pager_tab_background.xml
@@ -0,0 +1,22 @@
+<?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
+  -->
+<ripple xmlns:android="http://schemas.android.com/apk/res/android"
+    android:color="@color/tab_ripple_color">
+    <item android:id="@android:id/mask">
+        <color android:color="@android:color/white" />
+    </item>
+</ripple>
\ No newline at end of file
diff --git a/res/drawable-xhdpi/empty_contacts.png b/res/drawable-xhdpi/empty_contacts.png
new file mode 100644
index 0000000..65b1de3
--- /dev/null
+++ b/res/drawable-xhdpi/empty_contacts.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png b/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png
new file mode 100644
index 0000000..3e6ec07
--- /dev/null
+++ b/res/drawable-xhdpi/ic_not_interested_googblue_24dp.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_remove.png b/res/drawable-xhdpi/ic_remove.png
new file mode 100644
index 0000000..be81592
--- /dev/null
+++ b/res/drawable-xhdpi/ic_remove.png
Binary files differ
diff --git a/res/drawable-xhdpi/search_shadow.9.png b/res/drawable-xhdpi/search_shadow.9.png
new file mode 100644
index 0000000..5667ab3
--- /dev/null
+++ b/res/drawable-xhdpi/search_shadow.9.png
Binary files differ
diff --git a/res/drawable-xxhdpi/empty_contacts.png b/res/drawable-xxhdpi/empty_contacts.png
new file mode 100644
index 0000000..407d78c
--- /dev/null
+++ b/res/drawable-xxhdpi/empty_contacts.png
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png b/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png
new file mode 100644
index 0000000..7c256b5
--- /dev/null
+++ b/res/drawable-xxhdpi/ic_not_interested_googblue_24dp.png
Binary files differ
diff --git a/res/drawable-xxhdpi/ic_remove.png b/res/drawable-xxhdpi/ic_remove.png
new file mode 100644
index 0000000..2722f23
--- /dev/null
+++ b/res/drawable-xxhdpi/ic_remove.png
Binary files differ
diff --git a/res/drawable-xxhdpi/search_shadow.9.png b/res/drawable-xxhdpi/search_shadow.9.png
new file mode 100644
index 0000000..ff55620
--- /dev/null
+++ b/res/drawable-xxhdpi/search_shadow.9.png
Binary files differ
diff --git a/res/drawable-xxxhdpi/empty_contacts.png b/res/drawable-xxxhdpi/empty_contacts.png
new file mode 100644
index 0000000..5893965
--- /dev/null
+++ b/res/drawable-xxxhdpi/empty_contacts.png
Binary files differ
diff --git a/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png b/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png
new file mode 100644
index 0000000..6591ed4
--- /dev/null
+++ b/res/drawable-xxxhdpi/ic_not_interested_googblue_24dp.png
Binary files differ
diff --git a/res/drawable/floating_action_button.xml b/res/drawable/floating_action_button.xml
index 7753c89..2ba237f 100644
--- a/res/drawable/floating_action_button.xml
+++ b/res/drawable/floating_action_button.xml
@@ -15,11 +15,10 @@
      limitations under the License.
 -->
 
-<ripple xmlns:android="http://schemas.android.com/apk/res/android"
-     android:color="@color/contacts_accent_color">
-     <item android:id="@android:id/mask">
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+     <item android:state_pressed="true">
           <shape android:shape="oval">
-               <solid android:color="@android:color/white" />
+               <solid android:color="@color/primary_color_dark" />
           </shape>
      </item>
-</ripple>
\ No newline at end of file
+</selector>
\ No newline at end of file
diff --git a/res/drawable/rounded_corner.xml b/res/drawable/rounded_corner.xml
new file mode 100644
index 0000000..276fb30
--- /dev/null
+++ b/res/drawable/rounded_corner.xml
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  ~ Copyright (C) 2016 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
+  -->
+<shape xmlns:android="http://schemas.android.com/apk/res/android"
+       android:shape="rectangle" >
+    <solid android:color="@color/blocked_number_background" />
+    <corners android:radius="2dp" />
+</shape>
\ No newline at end of file
diff --git a/res/drawable/view_pager_tab_background.xml b/res/drawable/view_pager_tab_background.xml
index 1ba6c57..f1ddbe2 100644
--- a/res/drawable/view_pager_tab_background.xml
+++ b/res/drawable/view_pager_tab_background.xml
@@ -14,9 +14,8 @@
   ~ See the License for the specific language governing permissions and
   ~ limitations under the License
   -->
-<ripple xmlns:android="http://schemas.android.com/apk/res/android"
-    android:color="@color/tab_ripple_color">
-    <item android:id="@android:id/mask">
-        <color android:color="@android:color/white" />
-    </item>
-</ripple>
\ No newline at end of file
+<selector xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:state_pressed="true"
+        android:drawable="@color/primary_color_dark"/>
+</selector>
\ No newline at end of file
diff --git a/res/layout-land/contacts_unavailable_fragment_content.xml b/res/layout-land/contacts_unavailable_fragment_content.xml
index 05e4919..3d5a0b0 100644
--- a/res/layout-land/contacts_unavailable_fragment_content.xml
+++ b/res/layout-land/contacts_unavailable_fragment_content.xml
@@ -23,22 +23,15 @@
 
     <LinearLayout
         android:orientation="vertical"
-        android:layout_marginLeft="44dip"
-        android:layout_marginRight="44dip"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"/>
-
-    <LinearLayout
-        android:orientation="vertical"
-        android:layout_marginLeft="48dip"
-        android:layout_marginRight="48dip"
+        android:layout_marginLeft="40dp"
+        android:layout_marginRight="40dp"
         android:layout_width="wrap_content"
         android:layout_height="match_parent">
         <ImageView
             android:id="@+id/empty_image"
             android:layout_height="128dp"
             android:layout_width="128dp"
-            android:layout_marginTop="56dip"
+            android:layout_marginTop="60dp"
             android:alpha="0.38"
             android:gravity="center_horizontal"/>
 
@@ -46,48 +39,53 @@
             android:id="@+id/message"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
-            android:layout_marginTop="6dip"
-            android:textAppearance="?android:attr/textAppearanceLarge"
+            android:layout_marginTop="4dp"
+            android:textAppearance="?android:attr/textAppearanceMedium"
             android:textColor="?android:attr/textColorSecondary"
+            android:layout_gravity="center_horizontal"
             android:textIsSelectable="false"/>
 
-    </LinearLayout>
-
-    <LinearLayout
-        android:orientation="vertical"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent">
-
-        <Button
-            android:id="@+id/add_account_button"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginTop="72dip"
-            android:layout_marginBottom="20dip"
-            android:textColor="@android:color/white"
-            android:text="@string/contacts_unavailable_add_account" />
-
-        <Button
-            android:id="@+id/import_contacts_button"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:layout_marginBottom="15dip"
-            android:textColor="@android:color/white"
-            android:text="@string/contacts_unavailable_import_contacts" />
-
         <ProgressBar
             android:id="@+id/progress"
-            android:layout_width="wrap_content"
+            android:layout_width="match_parent"
             android:layout_height="wrap_content"
+            style="?android:attr/progressBarStyleHorizontal"
+            android:indeterminate="true"
             android:layout_gravity="center_horizontal"
-            android:layout_marginBottom="15dip" />
+            android:layout_marginTop="12dp" />
     </LinearLayout>
 
+    <!-- This buttons_container is landscape exclusive because we want the two buttons to be of
+         the same width (wrapping the longer content) and the layout width to be 208dp. -->
     <LinearLayout
+        android:id="@+id/buttons_container"
         android:orientation="vertical"
-        android:layout_marginLeft="44dip"
-        android:layout_marginRight="44dip"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"/>
+        android:layout_width="208dp"
+        android:layout_height="match_parent">
+        <LinearLayout
+            android:orientation="vertical"
+            android:layout_width="wrap_content"
+            android:layout_height="match_parent"
+            android:layout_gravity="center_horizontal">
+
+            <Button
+                style="@style/ContactsUnavailableButtonStyle"
+                android:id="@+id/add_account_button"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:layout_marginTop="85dp"
+                android:layout_marginBottom="10dp"
+                android:textColor="@android:color/white"
+                android:text="@string/contacts_unavailable_add_account" />
+
+            <Button
+                style="@style/ContactsUnavailableButtonStyle"
+                android:id="@+id/import_contacts_button"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:textColor="@android:color/white"
+                android:text="@string/contacts_unavailable_import_contacts" />
+        </LinearLayout>
+    </LinearLayout>
 
 </LinearLayout>
diff --git a/res/layout-land/people_activity_toolbar.xml b/res/layout-land/people_activity_toolbar.xml
index d33a96c..c110133 100644
--- a/res/layout-land/people_activity_toolbar.xml
+++ b/res/layout-land/people_activity_toolbar.xml
@@ -28,13 +28,15 @@
     <FrameLayout
         android:id="@+id/toolbar_frame"
         android:layout_width="match_parent"
-        android:layout_height="?android:attr/actionBarSize"
+        android:layout_height="?attr/actionBarSize"
         android:background="@color/actionbar_background_color">
 
-        <Toolbar
+        <!-- the attribute padding removes the gap between this Toolbar and its parent FrameLayout on tablet -->
+        <android.support.v7.widget.Toolbar
             android:layout_width="match_parent"
-            android:layout_height="?android:attr/actionBarSize"
+            android:layout_height="?attr/actionBarSize"
             android:id="@+id/toolbar"
+            android:padding="0dp"
             style="@style/ContactsToolbarStyle" />
 
     </FrameLayout>
diff --git a/res/layout/blocked_number_fragment.xml b/res/layout/blocked_number_fragment.xml
new file mode 100644
index 0000000..e2b9403
--- /dev/null
+++ b/res/layout/blocked_number_fragment.xml
@@ -0,0 +1,29 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 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.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+              android:id="@+id/blocked_number_fragment"
+              android:layout_width="match_parent"
+              android:layout_height="match_parent"
+              android:orientation="vertical"
+              android:background="@color/blocked_number_background">
+
+    <ListView android:id="@id/android:list"
+              android:layout_width="match_parent"
+              android:layout_height="wrap_content"
+              android:divider="@null"
+              android:headerDividersEnabled="false" />
+
+</LinearLayout>
\ No newline at end of file
diff --git a/res/layout/blocked_number_header.xml b/res/layout/blocked_number_header.xml
new file mode 100644
index 0000000..13ee7ba
--- /dev/null
+++ b/res/layout/blocked_number_header.xml
@@ -0,0 +1,179 @@
+<?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.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:card_view="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:focusable="false"
+    android:orientation="vertical">
+
+    <LinearLayout
+        android:id="@+id/blocked_numbers_disabled_for_emergency"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:paddingTop="27dp"
+        android:paddingBottom="29dp"
+        android:paddingStart="@dimen/blocked_number_container_padding"
+        android:paddingEnd="44dp"
+        android:background="@color/blocked_number_disabled_emergency_background_color"
+        android:focusable="true"
+        android:orientation="vertical"
+        android:visibility="gone">
+
+        <TextView
+            style="@style/BlockedNumbersDescriptionTextStyle"
+            android:textStyle="bold"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/blocked_numbers_disabled_emergency_header_label"/>
+
+        <TextView
+            style="@style/BlockedNumbersDescriptionTextStyle"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:text="@string/blocked_numbers_disabled_emergency_desc"/>
+
+    </LinearLayout>
+
+    <android.support.v7.widget.CardView
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        card_view:cardCornerRadius="0dp">
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:background="@android:color/white"
+            android:focusable="true"
+            android:orientation="vertical">
+
+            <LinearLayout
+                android:id="@+id/header_textview"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:orientation="vertical"
+                android:padding="@dimen/blocked_number_container_padding"
+                android:background="@android:color/white"
+                android:focusable="true">
+
+                <TextView
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:textColor="@color/blocked_number_secondary_text_color"
+                    android:textSize="@dimen/blocked_number_settings_description_text_size"
+                    android:text="@string/blocked_number_header_message"/>
+            </LinearLayout>
+
+            <RelativeLayout
+                android:id="@+id/import_settings"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:visibility="gone">
+
+                <TextView
+                    android:id="@+id/import_description"
+                    style="@style/BlockedNumbersDescriptionTextStyle"
+                    android:layout_width="match_parent"
+                    android:layout_height="wrap_content"
+                    android:paddingTop="11dp"
+                    android:paddingBottom="27dp"
+                    android:paddingStart="@dimen/blocked_number_container_padding"
+                    android:paddingEnd="@dimen/blocked_number_container_padding"
+                    android:text="@string/blocked_call_settings_import_description"
+                    android:textColor="@color/blocked_number_secondary_text_color"
+                    android:textSize="@dimen/blocked_number_settings_description_text_size"/>
+
+                <Button
+                    android:id="@+id/import_button"
+                    style="@style/ContactsFlatButtonStyle"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginEnd="@dimen/blocked_number_container_padding"
+                    android:layout_alignParentEnd="true"
+                    android:layout_below="@id/import_description"
+                    android:text="@string/blocked_call_settings_import_button"/>
+
+                <Button
+                    android:id="@+id/view_numbers_button"
+                    style="@style/ContactsFlatButtonStyle"
+                    android:layout_width="wrap_content"
+                    android:layout_height="wrap_content"
+                    android:layout_marginEnd="8dp"
+                    android:layout_below="@id/import_description"
+                    android:layout_toStartOf="@id/import_button"
+                    android:text="@string/blocked_call_settings_view_numbers_button"/>
+
+                <View
+                    android:layout_width="match_parent"
+                    android:layout_height="1dp"
+                    android:layout_marginTop="8dp"
+                    android:layout_below="@id/import_button"
+                    android:background="@color/blocked_number_divider_line_color"/>
+
+            </RelativeLayout>
+
+            <LinearLayout
+                android:id="@+id/add_number_linear_layout"
+                android:layout_width="match_parent"
+                android:layout_height="wrap_content"
+                android:paddingTop="@dimen/blocked_number_add_top_margin"
+                android:paddingBottom="@dimen/blocked_number_add_bottom_margin"
+                android:paddingStart="@dimen/blocked_number_horizontal_margin"
+                android:background="?android:attr/selectableItemBackground"
+                android:baselineAligned="false"
+                android:clickable="true"
+                android:contentDescription="@string/addBlockedNumber"
+                android:focusable="true"
+                android:gravity="center_vertical"
+                android:orientation="horizontal">
+
+                <ImageView
+                    android:id="@+id/add_number_icon"
+                    android:layout_width="@dimen/blocked_number_add_number_icon_size"
+                    android:layout_height="@dimen/blocked_number_add_number_icon_size"
+                    android:importantForAccessibility="no"/>
+                <LinearLayout
+                    android:layout_width="0dp"
+                    android:layout_height="wrap_content"
+                    android:layout_weight="1"
+                    android:layout_marginStart="@dimen/blocked_number_horizontal_margin"
+                    android:gravity="center_vertical"
+                    android:orientation="vertical">
+
+                    <TextView
+                        android:id="@+id/add_number_textview"
+                        android:layout_width="wrap_content"
+                        android:layout_height="wrap_content"
+                        android:includeFontPadding="false"
+                        android:text="@string/addBlockedNumber"
+                        android:textColor="@color/blocked_number_primary_text_color"
+                        android:textSize="@dimen/blocked_number_primary_text_size"/>
+                </LinearLayout>
+
+            </LinearLayout>
+
+            <View
+                android:id="@+id/blocked_number_list_divider"
+                android:layout_width="match_parent"
+                android:layout_height="1dp"
+                android:layout_marginStart="72dp"
+                android:background="@color/blocked_number_divider_line_color"/>
+
+        </LinearLayout>
+
+    </android.support.v7.widget.CardView>
+
+</LinearLayout>
diff --git a/res/layout/blocked_number_item.xml b/res/layout/blocked_number_item.xml
new file mode 100644
index 0000000..0d8b26f
--- /dev/null
+++ b/res/layout/blocked_number_item.xml
@@ -0,0 +1,72 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 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.
+-->
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/caller_information"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:paddingStart="@dimen/blocked_number_horizontal_margin"
+    android:baselineAligned="false"
+    android:orientation="horizontal"
+    android:focusable="true"
+    android:gravity="center_vertical"
+    android:background="@android:color/white">
+
+    <QuickContactBadge
+        android:id="@+id/quick_contact_photo"
+        android:layout_width="@dimen/blocked_number_add_number_icon_size"
+        android:layout_height="@dimen/blocked_number_add_number_icon_size"
+        android:focusable="true"
+        android:layout_marginTop="@dimen/blocked_number_top_margin"
+        android:layout_marginBottom="@dimen/blocked_number_bottom_margin"/>
+    <LinearLayout
+        android:layout_width="0dp"
+        android:layout_height="match_parent"
+        android:gravity="center_vertical"
+        android:layout_weight="1"
+        android:orientation="vertical"
+        android:layout_marginStart="@dimen/blocked_number_horizontal_margin">
+
+        <TextView
+            android:id="@+id/caller_name"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textColor="@color/blocked_number_primary_text_color"
+            android:textSize="@dimen/blocked_number_primary_text_size"
+            android:includeFontPadding="false"
+            android:singleLine="true"/>
+
+        <TextView
+            android:id="@+id/caller_number"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:textColor="@color/blocked_number_secondary_text_color"
+            android:textSize="@dimen/blocked_number_settings_description_text_size"
+            android:singleLine="true" />
+    </LinearLayout>
+
+    <ImageView
+        android:id="@+id/delete_button"
+        android:layout_width="@dimen/blocked_number_delete_icon_size"
+        android:layout_height="@dimen/blocked_number_delete_icon_size"
+        android:layout_marginEnd="24dp"
+        android:background="?android:attr/selectableItemBackgroundBorderless"
+        android:src="@drawable/ic_remove"
+        android:scaleType="center"
+        android:tint="@color/blocked_number_icon_tint"
+        android:contentDescription="@string/description_blocked_number_list_delete" />
+
+</LinearLayout>
\ No newline at end of file
diff --git a/res/xml/preference_headers.xml b/res/layout/blocked_numbers_activity.xml
similarity index 64%
rename from res/xml/preference_headers.xml
rename to res/layout/blocked_numbers_activity.xml
index 98019fd..6451496 100644
--- a/res/xml/preference_headers.xml
+++ b/res/layout/blocked_numbers_activity.xml
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2010 The Android Open Source Project
+<!-- Copyright (C) 2016 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.
@@ -14,11 +14,8 @@
      limitations under the License.
 -->
 
-<preference-headers
-    xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <header
-        android:fragment="com.android.contacts.common.preference.DisplayOptionsPreferenceFragment"
-        android:title="@string/preference_displayOptions" />
-
-</preference-headers>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+             android:id="@+id/blocked_numbers_activity_container"
+             android:layout_width="match_parent"
+             android:layout_height="match_parent">
+</FrameLayout>
\ No newline at end of file
diff --git a/res/layout/contacts_unavailable_fragment_content.xml b/res/layout/contacts_unavailable_fragment_content.xml
index 32636b4..765e453 100644
--- a/res/layout/contacts_unavailable_fragment_content.xml
+++ b/res/layout/contacts_unavailable_fragment_content.xml
@@ -25,48 +25,54 @@
         android:id="@+id/empty_image"
         android:layout_height="128dp"
         android:layout_width="128dp"
-        android:layout_marginTop="56dip"
+        android:layout_marginTop="56dp"
         android:alpha="0.38"
         android:gravity="center_horizontal" />
 
-    <TextView
-        android:id="@+id/message"
+    <LinearLayout
+        android:orientation="vertical"
         android:layout_width="wrap_content"
-        android:layout_height="wrap_content"
-        android:layout_marginTop="6dip"
-        android:textAppearance="?android:attr/textAppearanceLarge"
-        android:textColor="?android:attr/textColorSecondary"/>
+        android:layout_height="wrap_content">
+
+        <TextView
+            android:id="@+id/message"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_marginTop="4dp"
+            android:textAppearance="?android:attr/textAppearanceMedium"
+            android:textColor="?android:attr/textColorSecondary"/>
+
+        <ProgressBar
+            android:id="@+id/progress"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            style="?android:attr/progressBarStyleHorizontal"
+            android:indeterminate="true"
+            android:layout_gravity="center_horizontal"
+            android:layout_marginTop="12dp" />
+    </LinearLayout>
 
     <LinearLayout
         android:orientation="vertical"
-        android:layout_marginLeft="48dip"
-        android:layout_marginRight="48dip"
-
         android:layout_width="wrap_content"
-        android:layout_height="match_parent">
+        android:layout_height="wrap_content">
 
         <Button
+            style="@style/ContactsUnavailableButtonStyle"
             android:id="@+id/add_account_button"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_marginTop="24dip"
-            android:layout_marginBottom="15dip"
+            android:layout_marginTop="50dp"
+            android:layout_marginBottom="10dp"
             android:textColor="@android:color/white"
             android:text="@string/contacts_unavailable_add_account" />
 
         <Button
+            style="@style/ContactsUnavailableButtonStyle"
             android:id="@+id/import_contacts_button"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
-            android:layout_marginBottom="15dip"
             android:textColor="@android:color/white"
             android:text="@string/contacts_unavailable_import_contacts" />
-
-        <ProgressBar
-            android:id="@+id/progress"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:layout_gravity="center_horizontal"
-            android:layout_marginBottom="15dip" />
     </LinearLayout>
 </LinearLayout>
diff --git a/res/layout/custom_action_bar.xml b/res/layout/custom_action_bar.xml
index 5b930ea..9604849 100644
--- a/res/layout/custom_action_bar.xml
+++ b/res/layout/custom_action_bar.xml
@@ -28,7 +28,7 @@
         android:layout_height="1px" >
         <requestFocus />
     </View>
-    <SearchView
+    <android.support.v7.widget.SearchView
         android:id="@+id/search_view"
         android:layout_width="match_parent"
         android:layout_height="match_parent"
diff --git a/res/layout/editor_account_selector.xml b/res/layout/editor_account_selector.xml
index 6ba18a9..a752ec5 100644
--- a/res/layout/editor_account_selector.xml
+++ b/res/layout/editor_account_selector.xml
@@ -51,17 +51,17 @@
             android:textSize="16sp"
             android:singleLine="true"
             android:textColor="@color/primary_text_color"
+            android:textAlignment="viewStart"
             android:ellipsize="end" />
 
         <TextView
              android:id="@+id/account_name_selector"
              android:layout_width="match_parent"
              android:layout_height="wrap_content"
-             android:paddingRight="8dip"
-             android:paddingEnd="8dip"
              android:textSize="14sp"
              android:singleLine="true"
              android:textColor="@color/secondary_text_color"
+             android:textAlignment="viewStart"
              android:ellipsize="end" />
 
     </LinearLayout>
diff --git a/res/layout/empty_content_view.xml b/res/layout/empty_content_view.xml
new file mode 100644
index 0000000..97ac4c7
--- /dev/null
+++ b/res/layout/empty_content_view.xml
@@ -0,0 +1,54 @@
+<?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.
+-->
+
+<merge xmlns:android="http://schemas.android.com/apk/res/android">
+    <ImageView
+        android:id="@+id/emptyListViewImage"
+        android:layout_height="wrap_content"
+        android:layout_width="match_parent"
+        android:gravity="center_horizontal" />
+
+    <TextView
+        android:id="@+id/emptyListViewMessage"
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:gravity="center_horizontal|top"
+        android:textSize="@dimen/empty_list_message_text_size"
+        android:textColor="@color/empty_list_text_color"
+        android:paddingRight="16dp"
+        android:paddingLeft="16dp"
+        android:paddingTop="8dp"
+        android:paddingBottom="8dp" />
+
+    <TextView
+        android:id="@+id/emptyListViewAction"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:gravity="center_horizontal"
+        android:layout_gravity="center_horizontal"
+        android:paddingRight="16dp"
+        android:paddingLeft="16dp"
+        android:paddingTop="8dp"
+        android:paddingBottom="8dp"
+        android:background="?android:attr/selectableItemBackground"
+        android:clickable="true"
+        style="@style/TextActionStyle" />
+
+    <Space
+        android:layout_width="match_parent"
+        android:layout_height="40dp" />
+
+</merge>
diff --git a/res/layout/item_group_membership.xml b/res/layout/item_group_membership.xml
index 8f9bc7a..0e56e47 100644
--- a/res/layout/item_group_membership.xml
+++ b/res/layout/item_group_membership.xml
@@ -33,6 +33,8 @@
         android:layout_height="wrap_content"
         android:minHeight="@dimen/editor_min_line_item_height"
         android:textSize="@dimen/editor_form_text_size"
+        android:singleLine="true"
+        android:ellipsize="end"
         android:focusable="true"
         android:layout_marginEnd="@dimen/editor_delete_button_size"
         android:layout_marginBottom="@dimen/editor_padding_between_editor_views"
diff --git a/res/layout/people_activity_toolbar.xml b/res/layout/people_activity_toolbar.xml
index cbb4d91..da1dae4 100644
--- a/res/layout/people_activity_toolbar.xml
+++ b/res/layout/people_activity_toolbar.xml
@@ -24,13 +24,15 @@
     <FrameLayout
         android:id="@+id/toolbar_frame"
         android:layout_width="match_parent"
-        android:layout_height="?android:attr/actionBarSize"
+        android:layout_height="?attr/actionBarSize"
         android:background="@color/actionbar_background_color">
 
-        <Toolbar
+        <!-- the attribute padding removes the gap between this Toolbar and its parent FrameLayout on tablet -->
+        <android.support.v7.widget.Toolbar
             android:layout_width="match_parent"
-            android:layout_height="?android:attr/actionBarSize"
+            android:layout_height="?attr/actionBarSize"
             android:id="@+id/toolbar"
+            android:padding="0dp"
             style="@style/ContactsToolbarStyle" />
 
     </FrameLayout>
@@ -38,7 +40,7 @@
     <com.android.contacts.common.list.ViewPagerTabs
         android:id="@+id/lists_pager_header"
         android:layout_width="match_parent"
-        android:layout_height="?android:attr/actionBarSize"
+        android:layout_height="?attr/actionBarSize"
         android:textAllCaps="true"
         android:orientation="horizontal"
         android:layout_gravity="top"
diff --git a/res/layout/quickcontact_expand_suggestion_card.xml b/res/layout/quickcontact_expand_suggestion_card.xml
index 7b27c86..1d91f87 100644
--- a/res/layout/quickcontact_expand_suggestion_card.xml
+++ b/res/layout/quickcontact_expand_suggestion_card.xml
@@ -155,6 +155,8 @@
                 android:id="@+id/link_button"
                 android:layout_width="wrap_content"
                 android:layout_height="wrap_content"
+                android:lines="1"
+                android:ellipsize="end"
                 android:text="@string/quickcontact_suggestion_link_button"/>
         </LinearLayout>
     </LinearLayout>
diff --git a/res/layout/search_edittext.xml b/res/layout/search_edittext.xml
new file mode 100644
index 0000000..2492ca9
--- /dev/null
+++ b/res/layout/search_edittext.xml
@@ -0,0 +1,17 @@
+<?xml version="1.0" encoding="utf-8"?>
+<view class="com.android.contacts.widget.SearchEditTextLayout"
+      xmlns:android="http://schemas.android.com/apk/res/android"
+      android:layout_width="match_parent"
+      android:layout_height="match_parent"
+      android:id="@+id/search_view_container"
+      android:orientation="horizontal"
+      android:layout_marginTop="0dp"
+      android:layout_marginBottom="0dp"
+      android:layout_marginLeft="0dp"
+      android:layout_marginRight="0dp"
+      android:background="@drawable/rounded_corner"
+      android:elevation="3dp">
+
+    <include layout="@layout/search_bar_expanded" />
+
+</view>
diff --git a/res/layout/selection_bar.xml b/res/layout/selection_bar.xml
index 34cdd60..f91c2b8 100644
--- a/res/layout/selection_bar.xml
+++ b/res/layout/selection_bar.xml
@@ -25,7 +25,7 @@
         android:layout_width="48dp"
         android:layout_height="48dp"
         android:src="@drawable/ic_back_arrow"
-        android:background="?android:attr/selectableItemBackgroundBorderless"
+        android:background="?attr/selectableItemBackgroundBorderless"
         android:contentDescription="@string/action_menu_back_from_search"
         android:layout_gravity="center_vertical|start"
         android:tint="@android:color/white" />
@@ -37,6 +37,6 @@
         android:layout_height="wrap_content"
         android:visibility="gone"
         android:layout_gravity="center_vertical|start"
-        style="@style/ContactsActionBarTitleText" />
+        style="@style/ContactsActionBarTitleTextAppCompat" />
 
 </FrameLayout>
diff --git a/res/layout/view_numbers_to_import_fragment.xml b/res/layout/view_numbers_to_import_fragment.xml
new file mode 100644
index 0000000..8f7331f
--- /dev/null
+++ b/res/layout/view_numbers_to_import_fragment.xml
@@ -0,0 +1,56 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2016 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.
+-->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:card_view="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:orientation="vertical"
+    android:background="@color/blocked_number_background">
+
+    <ListView android:id="@id/android:list"
+        android:layout_width="match_parent"
+        android:layout_height="0dp"
+        android:layout_weight="1"
+        android:divider="@null"
+        android:headerDividersEnabled="false" />
+
+    <RelativeLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_gravity="bottom"
+        android:paddingTop="8dp"
+        android:paddingBottom="8dp"
+        android:background="@android:color/white">
+
+        <Button android:id="@+id/import_button"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_alignParentEnd="true"
+            android:layout_marginEnd="@dimen/blocked_number_container_padding"
+            android:text="@string/blocked_call_settings_import_button"
+            style="@style/ContactsFlatButtonStyle" />
+
+        <Button android:id="@+id/cancel_button"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"
+            android:layout_below="@id/import_description"
+            android:layout_toLeftOf="@id/import_button"
+            android:text="@android:string/cancel"
+            style="@style/ContactsFlatButtonStyle" />
+
+    </RelativeLayout>
+
+</LinearLayout>
diff --git a/res/menu/people_options.xml b/res/menu/people_options.xml
index 1dd4dc4..af98f9d 100644
--- a/res/menu/people_options.xml
+++ b/res/menu/people_options.xml
@@ -13,12 +13,13 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<menu xmlns:android="http://schemas.android.com/apk/res/android">
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+      xmlns:contacts="http://schemas.android.com/apk/res-auto">
     <item
         android:id="@+id/menu_search"
         android:icon="@drawable/ic_ab_search"
         android:title="@string/menu_search"
-        android:showAsAction="ifRoom" />
+        contacts:showAsAction="ifRoom" />
 
     <item
         android:id="@+id/menu_contacts_filter"
@@ -33,6 +34,10 @@
         android:title="@string/menu_clear_frequents" />
 
     <item
+        android:id="@+id/menu_blocked_numbers"
+        android:title="@string/menu_blocked_numbers"/>
+
+    <item
         android:id="@+id/menu_accounts"
         android:title="@string/menu_accounts" />
 
diff --git a/res/menu/search_menu.xml b/res/menu/search_menu.xml
index 355442e..c890f20 100644
--- a/res/menu/search_menu.xml
+++ b/res/menu/search_menu.xml
@@ -13,10 +13,11 @@
      See the License for the specific language governing permissions and
      limitations under the License.
 -->
-<menu xmlns:android="http://schemas.android.com/apk/res/android">
+<menu xmlns:android="http://schemas.android.com/apk/res/android"
+      xmlns:contacts="http://schemas.android.com/apk/res-auto">
     <item
         android:id="@+id/menu_search"
         android:icon="@drawable/ic_ab_search"
         android:title="@string/menu_search"
-        android:showAsAction="always" />
+        contacts:showAsAction="always" />
 </menu>
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index 55964ba..61b0462 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakte"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakte"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Bekyk kontak"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Wysig kontak"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakte"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontak"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direk skakel"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Stel verstek op"</string>
     <string name="clear_default" msgid="7193185801596678067">"Vee verstek uit"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Teks gekopieer"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Verwerp jou veranderings?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Gooi weg"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Gooi jou veranderings weg en hou op om te wysig?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Gooi weg"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Hou aan wysig"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Stel my profiel op"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Voer persoon se naam in"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Alle foto\'s"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Kies foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Van <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Vee <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> uit"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Vee <xliff:g id="DATA_KIND">%s</xliff:g> uit"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto van <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> af is nie gemerk nie"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto van <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> af is gemerk"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto van onbekende rekening af is nie gemerk nie"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto van onbekende rekening af is gemerk"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaklys word tans opgedateer om die taalverandering te weerspieël.\n\nWag asseblief..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Geblokkeerde nommers"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Oproepe en SMS\'e van hierdie nommers af sal geblokkeer word."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Voeg nommer by"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokkeer nommer"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Gee nommer of soek in kontakte"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Oproepe en SMS\'e van hierdie nommer af sal geblokkeer word."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Deblokkeer <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DEBLOKKEER"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blokkeer <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKKEER"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> is geblokkeer"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> is gedeblokkeer"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> is ongeldig."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Oproepblokkering is tydelik af"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Oproepblokkering is gedeaktiveer omdat jy die afgelope 48 uur nooddienste van hierdie foon af gekontak het. Dit sal outomaties heraktiveer word sodra die 48-uurtydperk verstryk."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Jy het voorheen sommige kontakte gemerk om outomaties na stemboodskap gestuur te word. Voer daardie nommers hier in om oproepe én SMS\'e te blokkeer."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Voer in"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Bekyk nommers"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Voeg nommer by"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Oproepblokkering is vir 48 uur gedeaktiveer"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Gedeaktiveer omdat \'n noodoproep gemaak is."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ONTDOEN"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> is reeds geblokkeer."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Deblokkeer nommer"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontakbesonderhede van <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Kon nie invoer nie"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Voer nommers in"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Skakel die Kontakte-toestemmings aan om jou kontakte te deursoek."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Skakel aan"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Geblokkeerde nommers"</string>
 </resources>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index b4dbcfa..898077a 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"ዕውቂያዎች"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"ዕውቂያዎች"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"ዕውቂያ ይመልከቱ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"እውቂያን ያርትዑ"</string>
     <string name="contactsList" msgid="8661624236494819731">"እውቅያዎች"</string>
     <string name="shortcutContact" msgid="749243779392912958">"እውቅያ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ቀጥታ ደውል"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ነባሪ አዘጋጅ"</string>
     <string name="clear_default" msgid="7193185801596678067">"ነባሪ አጽዳ"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"ፅሁፍ ገልብጧል"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ለውጦችዎ ይጣሉ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"አስወግድ"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"ለውጦችዎ ይወገዱ እና ማርትዕ ይቁም?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"አስወግድ"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"አርትዖቱን ቀጥል"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"መገለጫዬን አዘጋጅ"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"የግለሰቡን ስም ተይብ"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"ከ<xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>ን ሰርዝ"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g>ን ሰርዝ"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"ከ<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> የመጣ ፎቶ አልተረጋገጠም"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"ከ<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> የመጣ ፎቶ ተረጋግጧል"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"ካልታወቀ መለያ የመጣ ፎቶ ምልክት አልተደረገበትም"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"ካልታወቀ መለያ የመጣ ፎቶ ምልክት ተደርጎበታል"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"የእውቅያ ዝርዝር የቋንቋ ለውጥን ለማንፀባረቅ ዘምኗል።\n\nእባክዎ ይጠብቁ....."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"የታገዱ ቁጥሮች"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ከእነዚህ ቁጥሮች የሚመጡ ጥሪዎች እና ጽሑፎች ይታገዳሉ።"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ቁጥር አክል"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"ቁጥርን አግድ"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"ቁጥር ያክሉ ወይም እውቂያዎችን ይፈልጉ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ከዚህ ቁጥር የሚመጡ ጥሪዎች እና ጽሑፎች ይታገዳሉ።"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"የ<xliff:g id="NUMBER">%1$s</xliff:g> እግድ ይነሳ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"እገዳ አንሳ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> ይታገድ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"አግድ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ታግዷል"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"የ<xliff:g id="NUMBER">%1$s</xliff:g> እገዳ ተነስቷል"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ልክ ያልኾነ ነው።"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ጥሪን ማገድ ለጊዜው ተሰናክሏል"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ባለፉት 48 ሰዓቶች ውስጥ ከዚህ ስልክ ሆነው የአስቸኳይ አደጋ አገልግሎቶችን ስላነጋገሩ ጥሪን ማገድ ተሰናክሏል። አንዴ የ48 ሰዓቱ ጊዜ ካለፈ በኋላ በራስ-ሰር ዳግም ይነቃል።"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ከዚህ ቀደም አንዳንድ እውቂያዎች በራስ-ሰር ወደ የድምፅ መልእክት እንዲላኩ ምልክት አድርገውባቸው ነበር። ሁለቱንም ጥሪዎች እና ጽሑፎች ለማገድ እነዚህን ቁጥሮች ወደዚህ ያስመጡ።"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"አስመጣ"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"ቁጥሮችን ይመልከቱ"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ቁጥር አክል"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"የጥሪ እገዳ ለ48 ሰዓቶች ተሰናክሏል።"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"የአስቸኳይ አደጋ ጥሪ ስለተደረገ ተሰናክሏል።"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ቀልብስ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ቀድሞውኑ ታግዷል።"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"ቁጥርን አታግድ"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"የ<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> እውቂያ ዝርዝሮች"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"ማስመጣት አልተሳካም"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"ቁጥሮችን አስመጣ"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"የእርስዎን እውቂያዎች ለመከታተል የእውቂያዎች ፍቃዶችን ያብሩ።"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"አብራ"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"የታገዱ ቁጥሮች"</string>
 </resources>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index a8334ba..4929d0a 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"جهات الاتصال"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"جهات الاتصال"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"عرض جهة الاتصال"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"تعديل جهة الاتصال"</string>
     <string name="contactsList" msgid="8661624236494819731">"جهات الاتصال"</string>
     <string name="shortcutContact" msgid="749243779392912958">"الاتصال بـ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"طلب مباشر"</string>
@@ -252,8 +254,9 @@
     <string name="set_default" msgid="4417505153468300351">"تعيين كافتراضي"</string>
     <string name="clear_default" msgid="7193185801596678067">"محو الإعدادات الافتراضية"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"تم نسخ النص"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"هل تريد تجاهل التغييرات؟"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"تجاهل"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"هل تريد تجاهل التغييرات ومغادرة التعديل؟"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"تجاهل"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"متابعة التعديلات"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"إعداد الملف الشخصي"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"اكتب اسم الشخص"</string>
@@ -364,4 +367,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"من <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"حذف <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"حذف <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"تم إلغاء تحديد صورة من <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"تم تحديد صورة من <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"لم يتم تحديد صورة من حساب غير معروف"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"تم تحديد صورة من حساب غير معروف"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"يتم تحديث قائمة جهات الاتصال لتعكس التغيير الذي حدث في اللغة.\n\nالرجاء الانتظار..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"الأرقام المحظورة"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"سيتم حظر المكالمات والرسائل النصية الواردة من هذه الأرقام."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"إضافة رقم"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"حظر الرقم"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"إضافة رقم أو البحث في جهات الاتصال"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"سيتم حظر المكالمات والرسائل النصية الواردة من هذا الرقم."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"هل تريد إزالة حظر <xliff:g id="NUMBER">%1$s</xliff:g>؟"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"إلغاء الحظر"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"هل تريد حظر الرقم <xliff:g id="NUMBER">%1$s</xliff:g>؟"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"حظر"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"تم حظر <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"تم إلغاء حظر <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> غير صالح."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"حظر المكالمات معطّل مؤقتًا"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"تم تعطيل حظر المكالمات لأنك اتصلت بخدمات الطوارئ خلال 48 ساعة ماضية. وستتم إعادة تمكينه تلقائيًا بعد انتهاء هذه الفترة التي تبلغ 48 ساعة."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"سبق لك تعيين بعض جهات الاتصال على الإرسال تلقائيًا إلى البريد الصوتي، فاسترد هذه الأرقام هنا لحظر المكالمات والرسائل النصية."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"استيراد"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"عرض الأرقام"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"إضافة رقم"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"تم تعطيل حظر المكالمات لمدة 48 ساعة."</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"تم التعطيل نظرًا لإجراء مكالمة طوارئ."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"تراجع"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"تم حظر <xliff:g id="NUMBER">%1$s</xliff:g>."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"إلغاء حظر الرقم"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"تفاصيل جهة الاتصال بـ <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"أخفق الاستيراد"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"استيراد الأرقام"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"للبحث عن جهات الاتصال، عليك تشغيل أذونات جهات الاتصال."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"تشغيل"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"الأرقام المحظورة"</string>
 </resources>
diff --git a/res/values-az-rAZ/strings.xml b/res/values-az-rAZ/strings.xml
index a78d1ea..9a4854d 100644
--- a/res/values-az-rAZ/strings.xml
+++ b/res/values-az-rAZ/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktlar"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktlar"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Kontakta baxın"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Kontaktları Redaktə Edin"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontaktlar"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Birbaşa nömrə yığımı"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Defolt ayarlayın"</string>
     <string name="clear_default" msgid="7193185801596678067">"Defoltu təmizləyin"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Mətn kopyalandı"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Dəyişiklikləriniz kənarlaşdırılsın?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Ləğv edin"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Dəyişiklikləriniz kənarlaşdırılsın və redaktə sonlandırılsın?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Ləğv edin"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Redaktəyə davam edin"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Profilimi quraşdırın"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Şəxsin adını yazın"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Bütün fotolar"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Foto seçin"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> hesabından"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> datasını silin"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> datasını silin"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>istifadəçisindən gələn foto yoxlanmadı"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> istifadəçisindən gələn foto yoxlandı"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Naməlum hesabdan olan foto yoxlanmadı"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Naməlum hesabdan olan foto yoxlandı"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontakt siyahısı dilin dəyişməsinə uyğun olaraq güncəlləşir.\n\nLütfən, gözləyin..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Bloklanmış nömrələr"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Bu nömrələrdən gələn zənglər və mətnlər blok ediləcək."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Nömrə əlavə edin"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Nömrəni blok edin"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Nömrə əlavə edin və ya kontaktlarda axtarın"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Bu nömrədən gələn zənglər və mətnlər blok ediləcək."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> nömrəsi blokdan çıxarılsın?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"BLOKDAN ÇIXARIN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> nömrəsi blok edilsin?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOK"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blok edilib"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> blokdan çıxarılıb"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> yanlışdır."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Çağrının blok edilməsi müvəqqəti olaraq deaktiv edilib"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Son 48 saat ərzində bu telefondan təcili yardım xidmətləri ilə əlaqə saxladığınız üçün Çağrı Bloklanması deaktiv edildi. 48 saatlıq müddət başa çatdıqda avtomatik olaraq yenidən aktiv ediləcək."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Əvvəlcədən qeyd etdiyiniz bəzi kontaktlar avtomatik olaraq səsli mesaja yönləndiriləcək. Zəngləri və mətnləri blok etmək üçün o nömrələri bura improt edin."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"İmport"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Rəqəmlərə baxın"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Nömrə əlavə edin"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Çağrının bloklanması 48 saatlıq deaktiv edildi"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Təcili zəng olduğu üçün deaktiv edildi."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"LƏĞV EDİN"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> artıq bloklanıb."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Nömrəni blokdan çıxarın"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> üçün kontakt detalları"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import alınmadı"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Nömrələri import edin"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kontaktlarınızı axtarmaq üçün, Kontakt icazələrini aktiv edin."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktiv edin"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Bloklanmış nömrələr"</string>
 </resources>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index d44f4f0..483567a 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Контакти"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Контакти"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Преглед на контакта"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Редактиране на контакта"</string>
     <string name="contactsList" msgid="8661624236494819731">"Контакти"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Контакт"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Директно набиране"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Задаване като стандартна настройка"</string>
     <string name="clear_default" msgid="7193185801596678067">"Изчистване на стандартната настройка"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Текстът бе копиран"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Да се отхвърлят ли направените от вас промени?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Отхвърляне"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Искате ли да отхвърлите направените от вас промени и да излезете от редактирането?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Отхвърляне"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Продължаване с редактирането"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Потребит. профил"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Въведете името на човека"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Всички снимки"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Избиране на снимка"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"От <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Изтриване на <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Изтриване на <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Снимката от <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> е без отметка"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Снимката от <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> е с отметка"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Неизбрана снимка от неизвестен профил"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Избрана снимка от неизвестен профил"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Списъкът с контакти се актуализира, за да отрази промяната на езика.\n\nМоля, изчакайте..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Блокирани номера"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Обажданията и текстовите съобщения от тези номера ще бъдат блокирани."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Добавяне на номер"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Блокиране на номера"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Доб. номер или потърс. контакт"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Обажданията и текстовите съобщения от този номер ще бъдат блокирани."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Да се отблокира ли <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ОТБЛОКИРАНЕ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Да се блокира ли <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БЛОКИРАНЕ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Блокирахте <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Отблокирахте <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> е невалиден."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Блокир. на обажданията е временно изкл."</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Блокирането на обажданията е деактивирано, защото в рамките на последните 48 часа сте се свързали със спешните служби от този телефон. То автоматично ще бъде активирано отново, когато периодът от 48 часа изтече."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"По-рано означихте обажданията от някои контакти автоматично да се прехвърлят към гласова поща. Импортирайте тези номера тук, за да блокирате обажданията и текстовите съобщения."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Импортиране"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Преглед на номерата"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Добавяне на номер"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Блокирането на обажданията е деактивирано за 48 часа"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Деактивирано, тъй като бе извършено спешно обаждане."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ОТМЯНА"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> вече е блокиран."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Отблокиране на номера"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Подробности за контакта за <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Импортирането не бе успешно"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Импортиране на номерата"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"За да търсите в контактите си, включете разрешенията за тях."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Включване"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Блокирани номера"</string>
 </resources>
diff --git a/res/values-bn-rBD/strings.xml b/res/values-bn-rBD/strings.xml
index ec93530..53309a4 100644
--- a/res/values-bn-rBD/strings.xml
+++ b/res/values-bn-rBD/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"পরিচিতিগুলি"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"পরিচিতিগুলি"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"পরিচিতি দেখুন"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"পরিচিতি সম্পাদনা করুন"</string>
     <string name="contactsList" msgid="8661624236494819731">"পরিচিতিগুলি"</string>
     <string name="shortcutContact" msgid="749243779392912958">"পরিচিতি"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"সরাসরি ডায়াল"</string>
@@ -148,9 +150,9 @@
     <string name="quickcontact_add_phone_number" msgid="731665835910658965">"ফোন নম্বর জুড়ুন"</string>
     <string name="quickcontact_add_email" msgid="739298028384348482">"ইমেল জুড়ুন"</string>
     <string name="missing_app" msgid="1466111003546611387">"এই ক্রিয়াটিকে চালনা করার জন্য কোনো অ্যাপ্লিকেশান পাওয়া যায়নি৷"</string>
-    <string name="menu_share" msgid="943789700636542260">"ভাগ করুন"</string>
+    <string name="menu_share" msgid="943789700636542260">"শেয়ার করুন"</string>
     <string name="menu_add_contact" msgid="3198704337220892684">"পরিচিতিগুলিতে জুড়ুন"</string>
-    <string name="share_via" msgid="563121028023030093">"এর মাধ্যমে পরিচিতি ভাগ করুন"</string>
+    <string name="share_via" msgid="563121028023030093">"এর মাধ্যমে পরিচিতি শেয়ার করুন"</string>
     <string name="dialog_new_group_account" msgid="2318032089273496830">"অ্যাকাউন্টের অধীনে গোষ্ঠী তৈরি করুন"</string>
     <string name="audio_chat" msgid="2535716629358298691">"ভয়েস চ্যাট"</string>
     <string name="video_chat" msgid="1872255818640336072">"ভিডিও চ্যাট"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ডিফল্ট সেট করুন"</string>
     <string name="clear_default" msgid="7193185801596678067">"ডিফল্ট সাফ করুন"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"পাঠ্য অনুলিপি হয়েছে"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"আপনার পরিবর্তনগুলি বাতিল করতে চান?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"বাতিল করুন"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"আপনার পরিবর্তনগুলি বাতিল করতে এবং সম্পাদনা থেকে প্রস্থান করতে চান?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"বাতিল করুন"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"সম্পাদনা করা চালিয়ে যান"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"আমার প্রোফাইল সেট করা"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"ব্যক্তির নাম লিখুন"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"সকল ফটো"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"ফটো চয়ন করুন"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> থেকে"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> মুছুন"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> মুছুন"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> এর থেকে ফটো পরীক্ষা করা হয়নি"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> এর থেকে ফটো পরীক্ষা করা হয়েছে"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"অজানা অ্যাকাউন্টের ফটোতে টিক চিহ্ন দেওয়া হয়নি"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"অজানা অ্যাকাউন্টের ফটোতে টিক চিহ্ন দেওয়া হয়েছে"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ভাষা পরিবর্তন দেখানোর জন্য পরিচিতির তালিকা আপডেট করা হচ্ছে৷\n\nঅনুগ্রহ করে অপেক্ষা করুন..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"অবরোধ করা নম্বরগুলি"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"এই নম্বরগুলি থেকে আসা কল এবং পাঠ্যবার্তাগুলিকে অবরোধ করা হবে৷"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"একটি নম্বর যোগ করুন"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"নম্বর অবরোধ করুন"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"সংখ্যা যোগ করুন বা পরিচিতিগুলি অনুসন্ধান করুন"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"এই নম্বর থেকে আসা কল এবং পাঠ্যবার্তাগুলিকে অবরোধ করা হবে৷"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> অবরোধ মুক্ত করবেন?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"অবরোধ মুক্ত করুন"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> অবরোধ করবেন?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"অবরোধ করুন"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> অবরোধ করা হয়েছে"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> অবরোধ মুক্ত করা হয়েছে"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> অবৈধ৷"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"কল অবরোধ সাময়িকভাবে বন্ধ রয়েছে"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"কল অবরোধ অক্ষম করা হয়েছে কারণ আপনি গত ২৮ ঘন্টার মধ্যে এই ফোন থেকে জরুরি পরিষেবায় যোগাযোগ করেছেন। ২৮ ঘন্টার সময়সীমা পেরিয়ে গেলেই এটি স্বয়ংক্রিয়ভাবে পুনরায় সক্ষম হবে।"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"আপনি আগে থেকেই স্বয়ংক্রিয়ভাবে ভয়েস মেলে পাঠানোর জন্য কিছু পরিচিতিকে চিহ্নিত করেছেন৷ কল এবং পাঠ্যবার্তা উভয়ই অবরোধ করার জন্য এখানে সেই নম্বরগুলিকে আমদানি করুন৷"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"আমদানি করুন"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"নম্বরগুলি দেখুন"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"একটি নম্বর যোগ করুন"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"৪৮ ঘন্টার জন্য কল অবরোধ করা অক্ষম করা হয়েছে"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"কোনো জরুরি কল করার কারণে অক্ষম করা হয়েছে৷"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"পূর্বাবস্থায় ফিরুন"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ইতিমধ্যেই অববোধ করা রয়েছে৷"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"নম্বর অবরোধ মুক্ত করুন"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> পরিচিতির বিশদ বিবরণ"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"আমদানি ব্যর্থ হয়েছে"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"নম্বরগুলি আমদানি করুন"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"আপনার পরিচিতিগুলি অনুসন্ধান করতে, পরিচিতির অনুমতিগুলি চালু করুন।"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"চালু করুন"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"অবরোধ করা নম্বরগুলি"</string>
 </resources>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index bbe31e5..671c0a3 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contactes"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contactes"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Mostra el contacte"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edita el contacte"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contactes"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contacte"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Marcatge directe"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Predeterminat"</string>
     <string name="clear_default" msgid="7193185801596678067">"Esborra els valors predeterminats"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text copiat"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Vols descartar els canvis?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Descarta"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Vols descartar els canvis i sortir del mode d\'edició?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Descarta"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Continua editant"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configura el perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Escriu el nom de la persona"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Totes les fotos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Tria una foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Del compte <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Suprimeix <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Suprimeix <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto del compte <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> no seleccionada"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto del compte <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> seleccionada"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"No s\'ha seleccionat la foto d\'un compte desconegut"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"S\'ha seleccionat la foto d\'un compte desconegut"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"La llista de contactes s\'està actualitzant per reflectir el canvi d\'idioma.\n\nEspereu-vos..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloquejats"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Es bloquejaran les trucades i els missatges de text d\'aquests números."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Afegeix un número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloqueja el número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Afegeix núm. o cerca contactes"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Es bloquejaran les trucades i els missatges de text d\'aquest número."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Vols desbloquejar el número <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEJA"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Vols bloquejar el número <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEJA"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"S\'ha bloquejat el número <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"S\'ha desbloquejat el número <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> no és vàlid."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bloqueig de trucades desactivat tempor."</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"El bloqueig de trucades s\'ha desactivat perquè has contactat amb els serveis d\'emergència des d\'aquest telèfon durant les últimes 48 hores. Es tornarà a activar automàticament una vegada transcorregut el període de 48 hores."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Has indicat que les trucades d\'alguns contactes s\'enviïn automàticament a la bústia de veu. Importa aquests números aquí per bloquejar tant les trucades com els missatges de text."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importa"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Mostra els números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Afegeix un número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"El bloqueig de trucades s\'ha desactivat durant 48 hores"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"S\'ha desactivat perquè s\'ha fet una trucada d\'emergència."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESFÉS"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ja està bloquejat."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloqueja el número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Dades de contacte de: <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Error en la importació"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importa els números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Per cercar els teus contactes, activa els permisos de Contactes."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activa"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloquejats"</string>
 </resources>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index eb895c6..f3bb534 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakty"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakty"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Zobrazit kontakt"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Upravit kontakt"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakty"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Přímé vytáčení"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Výchozí nastavení"</string>
     <string name="clear_default" msgid="7193185801596678067">"Vymazat výchozí nastavení"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text zkopírován"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Zahodit změny?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Zrušit"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Zahodit změny a ukončit úpravy?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Zrušit"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Pokračovat v úpravách"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Nastavit profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Zadejte jméno osoby"</string>
@@ -342,4 +345,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Z účtu <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Smazat <xliff:g id="DATA_KIND">%s</xliff:g> (<xliff:g id="DATA_TYPE">%s </xliff:g>)"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Smazat <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotka z účtu <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> není vybrána"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Vybrána fotka z účtu <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Fotka z neznámého účtu nebyla vybrána"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Fotka z neznámého účtu byla vybrána"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"V souvislosti se změnou jazyka probíhá aktualizace seznamu kontaktů.\n\nČekejte prosím..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokovaná čísla"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Volání a zprávy SMS z těchto čísel budou blokovány."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Přidat číslo"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokovat číslo"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Přidejte číslo nebo vyhledejte kontakty"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Volání a zprávy SMS z tohoto čísla budou blokovány."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Odblokovat číslo <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ODBLOKOVAT"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blokovat číslo <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKOVAT"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Číslo <xliff:g id="NUMBER">%1$s</xliff:g> zablokováno"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Číslo <xliff:g id="NUMBER">%1$s</xliff:g> odblokováno"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Číslo <xliff:g id="NUMBER">%1$s</xliff:g> je neplatné."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokování hovorů je dočasně vypnuto"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Protože jste z tohoto telefonu během posledních 48 hodin volali na tísňovou linku, bylo blokování hovorů vypnuto. Po uplynutí 48 hodin se automaticky znovu zapne."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Dříve jste některé kontakty označili k automatickému přesměrování do hlasové schránky. Chcete-li blokovat hovory i zprávy SMS, importujte tato čísla sem."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importovat"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Zobrazit čísla"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Přidat číslo"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blokování hovorů je vypnuto na 48 hodin"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Vypnuto z důvodu provedeného tísňového volání"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"VRÁTIT"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Číslo <xliff:g id="NUMBER">%1$s</xliff:g> je již blokováno."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Zrušit blokování čísla"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Podrobnosti kontaktu pro <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import se nezdařil."</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importovat čísla"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Chcete-li vyhledat kontakty, zapněte oprávnění Kontakty."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Zapnout"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokovaná čísla"</string>
 </resources>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 83a9294..e136993 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktpersoner"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktpersoner"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Se kontaktperson"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Rediger kontaktperson"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakter"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direkte opkald"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Indstil standard"</string>
     <string name="clear_default" msgid="7193185801596678067">"Ryd standarder"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Kopieret tekst"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Skal ændringerne slettes?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Kassér"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Vil du kassere ændringerne og afslutte redigering?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Kassér"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Fortsæt redigering"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Konfigurer min profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Indtast personens navn"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Alle billeder"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Vælg billede"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Fra <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Slet <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Slet <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Billede fra <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> er ikke valgt"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Billede fra <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> er valgt"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Der er ikke markeret et billede fra en ukendt konto"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Et billede fra en ukendt konto er markeret"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaktlisten opdateres for at afspejle ændringen af sprog.\n\nVent et øjeblik..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokerede telefonnumre"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Opkald og sms-beskeder fra disse numre blokeres."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Tilføj nummer"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloker nummer"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Tilføj nummer, eller søg i kontaktpersoner"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Opkald og sms-beskeder fra dette nummer blokeres."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Vil du fjerne blokeringen af <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"FJERN BLOKERING"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Vil du blokere <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKER"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> er blokeret"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> er ikke blokeret"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> er ugyldigt."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Opkaldsblokering er midlertidigt slået fra"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Opkaldsblokering er blevet deaktiveret, da du inden for de sidste 48 timer har kontaktet en alarmcentral. Blokeringen aktiveres automatisk igen, når perioden på 48 timer er udløbet."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Du har tidligere angivet, at nogle kontaktpersoner automatisk skal sendes til telefonsvareren. Importér disse numre hertil for at blokere både opkald og sms-beskeder."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importér"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Se numre"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Tilføj nummer"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Opkaldsblokering er blevet deaktiveret i 48 timer"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Deaktiveret, da du har foretaget et nødopkald."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"FORTRYD"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> er allerede blokeret."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Ophæv blokering af nummer"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontaktoplysninger for <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importen mislykkedes"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importér numre"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Hvis du vil søge i dine kontaktpersoner, skal du slå tilladelserne Kontaktpersoner til."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktivér"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokerede telefonnumre"</string>
 </resources>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index b85f2cb..0976e3b 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakte"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakte"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Kontakt ansehen"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Kontakt bearbeiten"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakte"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direktwahl"</string>
@@ -57,14 +59,14 @@
     <string name="menu_new_group_action_bar" msgid="3520232877587377175">"Gruppe hinzufügen"</string>
     <string name="splitConfirmation" msgid="7342030840130187290">"Verknüpfung dieses Kontakts aufheben, um mehrere Kontakte zu erstellen?"</string>
     <string name="splitConfirmation_positive_button" msgid="9129409098807939699">"Verknüpfung aufheben"</string>
-    <string name="splitConfirmationWithPendingChanges" msgid="7719062163511895696">"Möchten Sie die vorgenommenen Änderungen speichern und die Verknüpfung dieses Kontakts aufheben, um mehrere Kontakte zu erstellen?"</string>
+    <string name="splitConfirmationWithPendingChanges" msgid="7719062163511895696">"Möchtest du die vorgenommenen Änderungen speichern und die Verknüpfung dieses Kontakts aufheben, um mehrere Kontakte zu erstellen?"</string>
     <string name="splitConfirmationWithPendingChanges_positive_button" msgid="9073444264887244032">"Speichern und Verknüpfung aufheben"</string>
-    <string name="joinConfirmation" msgid="8262614843581924365">"Möchten Sie die vorgenommenen Änderungen speichern und diesen Kontakt mit dem ausgewählten Kontakt verknüpfen?"</string>
+    <string name="joinConfirmation" msgid="8262614843581924365">"Möchtest du die vorgenommenen Änderungen speichern und diesen Kontakt mit dem ausgewählten Kontakt verknüpfen?"</string>
     <string name="joinConfirmation_positive_button" msgid="4573092849769149516">"Speichern und verknüpfen"</string>
     <string name="menu_joinAggregate" msgid="3599512127797513606">"Verknüpfen"</string>
     <string name="menu_save" msgid="1727844363591825909">"Speichern"</string>
     <string name="titleJoinContactDataWith" msgid="6825255752748313944">"Kontakte verknüpfen"</string>
-    <string name="blurbJoinContactDataWith" msgid="5864256698061641841">"Wählen Sie einen Kontakt aus, den Sie mit <xliff:g id="NAME">%s</xliff:g> verknüpfen möchten:"</string>
+    <string name="blurbJoinContactDataWith" msgid="5864256698061641841">"Wähle einen Kontakt aus, den du mit <xliff:g id="NAME">%s</xliff:g> verknüpfen möchtest:"</string>
     <string name="showAllContactsJoinItem" msgid="2189695051430392383">"Alle Kontakte anzeigen"</string>
     <string name="separatorJoinAggregateSuggestions" msgid="2831414448851313345">"Vorgeschlagene Kontakte"</string>
     <string name="separatorJoinAggregateAll" msgid="7939932265026181043">"Alle Kontakte"</string>
@@ -75,17 +77,17 @@
     </plurals>
     <string name="menu_set_ring_tone" msgid="8728345772068064946">"Klingeltonwahl"</string>
     <string name="menu_redirect_calls_to_vm" msgid="4181789196416396656">"Alle Anrufe an Mailbox"</string>
-    <string name="readOnlyContactWarning" msgid="5526727661978307833">"Kontakte aus Ihren schreibgeschützten Konten können nicht gelöscht, sondern nur ausgeblendet werden."</string>
+    <string name="readOnlyContactWarning" msgid="5526727661978307833">"Kontakte aus deinen schreibgeschützten Konten können nicht gelöscht, sondern nur ausgeblendet werden."</string>
     <string name="readOnlyContactWarning_positive_button" msgid="6541862607313811926">"Ausblenden"</string>
     <string name="readOnlyContactDeleteConfirmation" msgid="8782086424739664753">"Der zu löschende Kontakt enthält Informationen aus mehreren Konten. Informationen aus schreibgeschützten Konten werden nicht gelöscht, sondern nur ausgeblendet."</string>
-    <string name="batch_link_single_contact_warning" msgid="1346058571502058767">"Wählen Sie für eine Verknüpfung mindestens zwei Kontakte aus."</string>
+    <string name="batch_link_single_contact_warning" msgid="1346058571502058767">"Wähle für eine Verknüpfung mindestens zwei Kontakte aus."</string>
     <string name="batch_link_confirmation" msgid="5845237114309114908">"Ausgewählte Kontakte verknüpfen?"</string>
     <string name="batch_link_confirmation_positive_button" msgid="5018899675473363525">"Verknüpfen"</string>
     <string name="single_delete_confirmation" msgid="3106905986948679720">"Diesen Kontakt löschen?"</string>
     <string name="batch_delete_confirmation" msgid="3984346060324014108">"Ausgewählte Kontakte löschen?"</string>
-    <string name="batch_delete_read_only_contact_confirmation" msgid="8411117621035639964">"Kontakte aus Ihren schreibgeschützten Konten können nicht gelöscht, sondern nur ausgeblendet werden."</string>
+    <string name="batch_delete_read_only_contact_confirmation" msgid="8411117621035639964">"Kontakte aus deinen schreibgeschützten Konten können nicht gelöscht, sondern nur ausgeblendet werden."</string>
     <string name="batch_delete_multiple_accounts_confirmation" msgid="8207205649127030030">"Die zu löschenden Kontakte enthalten Informationen aus mehreren Konten. Informationen aus schreibgeschützten Konten werden nicht gelöscht, sondern nur ausgeblendet."</string>
-    <string name="multipleContactDeleteConfirmation" msgid="5235324124905653550">"Wenn Sie diesen Kontakt löschen, werden Informationen aus mehreren Konten gelöscht."</string>
+    <string name="multipleContactDeleteConfirmation" msgid="5235324124905653550">"Wenn du diesen Kontakt löschst, werden Informationen aus mehreren Konten gelöscht."</string>
     <string name="deleteConfirmation" msgid="3512271779086656043">"Diesen Kontakt löschen?"</string>
     <string name="deleteConfirmation_positive_button" msgid="7857888845028586365">"Löschen"</string>
     <string name="menu_discard" msgid="6854657936970228164">"Änderungen verwerfen"</string>
@@ -106,9 +108,9 @@
     <string name="removePhoto" msgid="4898105274130284565">"Foto entfernen"</string>
     <string name="noContacts" msgid="4955659076981974652">"Keine Kontakte"</string>
     <string name="noGroups" msgid="8614664663561385253">"Keine Gruppen"</string>
-    <string name="noAccounts" msgid="7768267764545265909">"Sie benötigen ein Konto, um Gruppen erstellen zu können."</string>
+    <string name="noAccounts" msgid="7768267764545265909">"Du benötigst ein Konto, um Gruppen erstellen zu können."</string>
     <string name="emptyGroup" msgid="7502116218697177370">"Keine Personen in dieser Gruppe"</string>
-    <string name="addPeopleToGroup" msgid="7879585947222263516">"Bearbeiten Sie die Gruppe, um Personen hinzuzufügen."</string>
+    <string name="addPeopleToGroup" msgid="7879585947222263516">"Bearbeite die Gruppe, um Personen hinzuzufügen."</string>
     <string name="savingContact" msgid="4075751076741924939">"Kontakt wird gespeichert..."</string>
     <string name="contactSavedToast" msgid="9171862279493213075">"Kontakt gespeichert"</string>
     <string name="contactUnlinkedToast" msgid="7122823195786012553">"Verknüpfung der Kontakte wurde aufgehoben."</string>
@@ -144,7 +146,7 @@
     <string name="exporting_contact_list_progress" msgid="560522409559101193">"<xliff:g id="CURRENT_NUMBER">%s</xliff:g> von <xliff:g id="TOTAL_NUMBER">%s</xliff:g> Kontakten"</string>
     <string name="search_settings_description" msgid="2675223022992445813">"Namen meiner Kontakte"</string>
     <string name="quickcontact_missing_app" msgid="358168575340921552">"Für diese Aktion wurde keine App gefunden."</string>
-    <string name="quickcontact_transparent_view_description" msgid="987959416759562455">"Klicken Sie hier, um zum vorherigen Bildschirm zurückzukehren."</string>
+    <string name="quickcontact_transparent_view_description" msgid="987959416759562455">"Klicke hier, um zum vorherigen Bildschirm zurückzukehren."</string>
     <string name="quickcontact_add_phone_number" msgid="731665835910658965">"Telefonnummer hinzufügen"</string>
     <string name="quickcontact_add_email" msgid="739298028384348482">"E-Mail-Adresse hinzufügen"</string>
     <string name="missing_app" msgid="1466111003546611387">"Für diese Aktion wurde keine App gefunden."</string>
@@ -219,13 +221,14 @@
       <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> Personen</item>
       <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> Person</item>
     </plurals>
-    <string name="toast_join_with_empty_contact" msgid="1215465657839085613">"Geben Sie einen Namen für den Kontakt ein, bevor Sie ihn mit einem anderen Kontakt verknüpfen."</string>
+    <string name="toast_join_with_empty_contact" msgid="1215465657839085613">"Gib einen Namen für den Kontakt ein, bevor du ihn mit einem anderen Kontakt verknüpfst."</string>
     <string name="copy_text" msgid="3257145021583508761">"In Zwischenablage kopieren"</string>
     <string name="set_default" msgid="4417505153468300351">"Als Standard festlegen"</string>
     <string name="clear_default" msgid="7193185801596678067">"Als Standard löschen"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text kopiert"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Sollen die Änderungen verworfen werden?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Verwerfen"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Möchtest du die Änderungen verwerfen und den Bearbeitungsmodus beenden?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Verwerfen"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Bearbeitung fortsetzen"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Mein Profil einrichten"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Namen der Person eingeben"</string>
@@ -233,12 +236,12 @@
     <string name="local_profile_title" msgid="2021416826991393684">"Mein lokales Profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Mein <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>-Profil"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Alle Kontakte werden angezeigt."</string>
-    <string name="no_account_prompt" msgid="6424883302325061025">"Die App \"Kontakte\" funktioniert am besten mit einem Google-Konto.\n\n• Sie können über alle Webbrowser darauf zugreifen.\n• Sichern und schützen Sie Ihre Kontakte."</string>
-    <string name="generic_no_account_prompt" msgid="7218827704367325460">"Synchronisierung mit einem Online-Service: Ihre Kontakte sind dann auch sicher, wenn Sie Ihr Telefon verlieren."</string>
+    <string name="no_account_prompt" msgid="6424883302325061025">"Die App \"Kontakte\" funktioniert am besten mit einem Google-Konto.\n\n• Du kannst über alle Webbrowser darauf zugreifen.\n• Sichere und schütze deine Kontakte."</string>
+    <string name="generic_no_account_prompt" msgid="7218827704367325460">"Synchronisierung mit einem Online-Service: Deine Kontakte sind dann auch sicher, wenn du dein Telefon verlierst."</string>
     <string name="generic_no_account_prompt_title" msgid="753783911899054860">"Konto hinzufügen"</string>
-    <string name="contact_editor_prompt_zero_accounts" msgid="1785345895691886499">"Ihr neuer Kontakt wird nicht gesichert. Konto für die Online-Sicherung von Kontakten hinzufügen?"</string>
+    <string name="contact_editor_prompt_zero_accounts" msgid="1785345895691886499">"Dein neuer Kontakt wird nicht gesichert. Konto für die Online-Sicherung von Kontakten hinzufügen?"</string>
     <string name="contact_editor_prompt_one_account" msgid="3087691056345099310">"Neue Kontakte werden in <xliff:g id="ACCOUNT_NAME">%1$s</xliff:g> gespeichert."</string>
-    <string name="contact_editor_prompt_multiple_accounts" msgid="8565761674283473549">"Wählen Sie ein Standardkonto für neue Kontakte:"</string>
+    <string name="contact_editor_prompt_multiple_accounts" msgid="8565761674283473549">"Wähle ein Standardkonto für neue Kontakte:"</string>
     <string name="contact_editor_title_new_contact" msgid="7192223018128934940">"Kontakt hinzufügen"</string>
     <string name="contact_editor_title_existing_contact" msgid="4898475703683187798">"Kontakt bearbeiten"</string>
     <string name="keep_local" msgid="1258761699192993322">"Lokal speichern"</string>
@@ -282,12 +285,12 @@
     <string name="content_description_recent_call_type_missed" msgid="7371810920196048204">"Verpasst"</string>
     <string name="content_description_recent_call" msgid="5183800406316723676">"Letzter Anruf. <xliff:g id="CALL_TYPE">%s</xliff:g>. <xliff:g id="PHONE_NUMBER">%s</xliff:g>. <xliff:g id="DATE">%s</xliff:g>. Für Rückruf klicken."</string>
     <string name="message_from_you_prefix" msgid="7180706529908434482">"Ich: <xliff:g id="SMS_BODY">%s</xliff:g>"</string>
-    <string name="contact_editor_hangouts_im_alert" msgid="114855385615225735">"Hangouts funktioniert besser, wenn Sie die Hangouts-ID der Person in das E-Mail- oder Telefonfeld eingeben."</string>
+    <string name="contact_editor_hangouts_im_alert" msgid="114855385615225735">"Hangouts funktioniert besser, wenn du die Hangouts-ID der Person in das E-Mail- oder Telefonfeld eingibst."</string>
     <string name="compact_editor_more_fields" msgid="5987638193568699600">"Weitere Felder"</string>
     <string name="compact_editor_change_photo_content_description" msgid="5495487714301211540">"Foto ändern"</string>
     <string name="compact_editor_failed_to_load" msgid="4557094426388044958">"Fehler beim Öffnen des Editors."</string>
     <string name="compact_editor_account_selector_title" msgid="5119592614151786601">"Speichern in"</string>
-    <string name="compact_editor_account_selector_description" msgid="2127184829759350507">"Wird derzeit in <xliff:g id="ACCOUNT_NAME">%s</xliff:g> gespeichert. Doppeltippen Sie, um ein anderes Konto auszuwählen."</string>
+    <string name="compact_editor_account_selector_description" msgid="2127184829759350507">"Wird derzeit in <xliff:g id="ACCOUNT_NAME">%s</xliff:g> gespeichert. Tippe doppelt, um ein anderes Konto auszuwählen."</string>
     <plurals name="compact_editor_linked_contacts_selector_title" formatted="false" msgid="9156207930915878316">
       <item quantity="other">Verknüpfte Kontakte (<xliff:g id="COUNT">%d</xliff:g>)</item>
       <item quantity="one">Verknüpfter Kontakt</item>
@@ -311,15 +314,48 @@
     <string name="quickcontact_suggestion_account_type" msgid="5878263654735376962">"<xliff:g id="ACCOUNT_TYPE_0">%s</xliff:g><xliff:g id="ACCOUNT_TYPE_NUMBER">%s</xliff:g>"</string>
     <string name="suggestion_card_this_contact_title" msgid="3039457405374454914">"Dieser Kontakt"</string>
     <string name="suggestion_card_duplicates_title" msgid="9107788743178980902">"Mögliche Duplikate"</string>
-    <string name="suggestion_card_help_message" msgid="4474061044387181093">"Bei diesen Kontakten könnte es sich um dieselbe Person handeln. Sie können sie zu einem einzigen Kontakt verknüpfen."</string>
+    <string name="suggestion_card_help_message" msgid="4474061044387181093">"Bei diesen Kontakten könnte es sich um dieselbe Person handeln. Du kannst sie zu einem einzigen Kontakt verknüpfen."</string>
     <string name="compact_editor_linked_contacts_title" msgid="4417919183651782674">"Verknüpfte Kontakte"</string>
     <string name="from_your_accounts" msgid="1746293107836889912">"Aus meinen Konten"</string>
     <string name="take_a_photo_button" msgid="6268693854069113488">"Foto aufnehmen"</string>
     <string name="all_photos_button" msgid="1943122929420111351">"Alle Fotos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Foto auswählen"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Von <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> löschen"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> löschen"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto von <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>nicht ausgewählt"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto von <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ausgewählt"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto aus unbekanntem Konto nicht ausgewählt"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto aus unbekanntem Konto ausgewählt"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Die Kontaktliste wird an die geänderte Sprache angepasst.\n\nBitte warten..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blockierte Nummern"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Anrufe und SMS von diesen Nummern werden blockiert."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Nummer hinzufügen"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Nummer blockieren"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Nummer hinzufügen oder in Kontakten suchen"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Anrufe und SMS von dieser Nummer werden blockiert."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Blockierung von <xliff:g id="NUMBER">%1$s</xliff:g> aufheben?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"BLOCKIERUNG AUFHEBEN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> blockieren?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCKIEREN"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blockiert"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Blockierung von <xliff:g id="NUMBER">%1$s</xliff:g> aufgehoben"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ist ungültig."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Anrufblockierung vorübergehend aus"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Die Anrufblockierung wurde deaktiviert, weil du innerhalb der letzten 48 Stunden mit diesem Telefon den Notruf gewählt hast. Nach Ablauf dieser 48-Stunden-Frist wird die Blockierung automatisch wieder aktiviert."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Du hast zuvor einige Kontakte markiert, die automatisch an die Mailbox weitergeleitet werden. Importiere diese Kontakte, damit sowohl Anrufe als auch SMS von diesen Nummern blockiert werden."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importieren"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Nummern anzeigen"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Nummer hinzufügen"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Anrufblockierung für 48 Stunden deaktiviert"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Deaktiviert, da ein Notruf getätigt wurde."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"Rückgängig"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ist bereits blockiert."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Blockierung der Nummer aufheben"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontaktdetails für <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import fehlgeschlagen"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Nummern importieren"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Aktiviere die Berechtigungen \"Kontakte\", um deine Kontakte zu suchen."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktivieren"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blockierte Nummern"</string>
 </resources>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 718f2f8..54d5221 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Επαφές"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Επαφές"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Προβολή επαφής"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Επεξεργασία επαφής"</string>
     <string name="contactsList" msgid="8661624236494819731">"Επαφές"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Επαφή"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Άμεση κλήση"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Ορισμός ως προεπιλογή"</string>
     <string name="clear_default" msgid="7193185801596678067">"Εκκαθάριση προεπιλεγμένων"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Το κείμενο αντιγράφηκε"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Να απορριφθούν οι αλλαγές σας;"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Απόρριψη"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Να απορριφθούν οι αλλαγές που πραγματοποιήσατε και να τερματιστεί η επεξεργασία;"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Απόρριψη"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Συνέχεια επεξεργασίας"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Ρύθμιση του προφίλ μου"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Πληκτρολογήστε το όνομα του ατόμου"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Από <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Διαγραφή <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Διαγραφή <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Δεν επιλέχθηκε φωτογραφία από <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Επιλέχθηκε φωτογραφία από <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Δεν επιλέχθηκε φωτογραφία από άγνωστο λογαριασμό"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Επιλέχθηκε φωτογραφία από άγνωστο λογαριασμό"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Η λίστα επαφών ενημερώνεται ώστε να αντικατοπτρίζει την αλλαγή γλώσσας.\n\nΠεριμένετε..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Αποκλεισμένοι αριθμοί"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Οι κλήσεις και τα μηνύματα που προέρχονται από αυτούς τους αριθμούς θα αποκλείονται."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Προσθήκη αριθμού"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Αποκλεισμός αριθμού"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Προσθήκη αριθμού ή αναζήτηση επαφών"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Οι κλήσεις και τα μηνύματα από αυτόν τον αριθμό θα αποκλειστούν."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Να καταργηθεί ο αποκλεισμός του αριθμού <xliff:g id="NUMBER">%1$s</xliff:g>;"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ΚΑΤΑΡΓΗΣΗ ΑΠΟΚΛΕΙΣΜΟΥ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Να αποκλειστεί ο αριθμός <xliff:g id="NUMBER">%1$s</xliff:g>;"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ΑΠΟΚΛΕΙΣΜΟΣ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Ο αριθμός <xliff:g id="NUMBER">%1$s</xliff:g> αποκλείστηκε"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Ο αποκλεισμός του αριθμού <xliff:g id="NUMBER">%1$s</xliff:g> καταργήθηκε"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Ο αριθμός <xliff:g id="NUMBER">%1$s</xliff:g> δεν είναι έγκυρος."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Προσωρινά απενεργοποιημένη φραγή κλήσεων"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Η φραγή κλήσεων έχει απενεργοποιηθεί προσωρινά επειδή επικοινωνήσατε με τις υπηρεσίες έκτακτης ανάγκης από αυτό το τηλέφωνο μέσα στις τελευταίες 48 ώρες. Θα ενεργοποιηθεί ξανά αυτόματα μόλις λήξει η περίοδος των 48 ωρών."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Στο παρελθόν, επισημάνατε ορισμένες επαφές ώστε να προωθούνται αυτόματα στον αυτόματο τηλεφωνητή. Εισαγάγετε αυτούς τους αριθμούς εδώ για να αποκλείσετε τόσο τις κλήσεις όσο και τα μηνύματα από αυτούς."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Εισαγωγή"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Προβολή αριθμών"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Προσθήκη αριθμού"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Η φραγή κλήσεων απενεργοποιήθηκε για 48 ώρες"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Απενεργοποιημένο επειδή πραγματοποιήθηκε κλήση έκτακτης ανάγκης."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ΑΝΑΙΡΕΣΗ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Ο αριθμός <xliff:g id="NUMBER">%1$s</xliff:g> αποκλείστηκε ήδη."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Κατάργηση αποκλεισμού αριθμού"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Στοιχεία επικοινωνίας του <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Αποτυχία εισαγωγής"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Εισαγωγή αριθμών"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Για να κάνετε αναζήτηση στις επαφές σας, ενεργοποιήστε τις άδειες \"Επαφές\"."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Ενεργοποίηση"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Αποκλεισμένοι αριθμοί"</string>
 </resources>
diff --git a/res/values-en-rAU/strings.xml b/res/values-en-rAU/strings.xml
index 2a56b13..3e0a562 100644
--- a/res/values-en-rAU/strings.xml
+++ b/res/values-en-rAU/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contacts"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contacts"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"View contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edit Contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contacts"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contact"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direct dial"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Set default"</string>
     <string name="clear_default" msgid="7193185801596678067">"Clear default"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text copied"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Discard your changes?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Discard"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Discard your changes and quit editing?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Discard"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Keep editing"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Set up my profile"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Type person\'s name"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"From <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Delete <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Delete <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Photo from <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>not checked"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Photo from <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>checked"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Photo from unknown account not selected"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Photo from unknown account selected"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Contact list is being updated to reflect the change of language.\n\nPlease wait..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blocked numbers"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Calls and texts from these numbers will be blocked."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Add number"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Block number"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Add number or search contacts"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Calls and texts from this number will be blocked."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Unblock <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"UNBLOCK"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Block <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCK"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blocked"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> unblocked"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> is invalid."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Call blocking temporarily off"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Call blocking has been disabled because you contacted emergency services from this phone within the last 48 hours. It will be automatically re-enabled once the 48 hour period expires."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"You previously marked some contacts to be automatically sent to voicemail. Import those numbers here to block both calls and texts."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Import"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"View Numbers"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Add number"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Call blocking disabled for 48 hours"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Disabled because an emergency call was made."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"UNDO"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> is already blocked."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Unblock number"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Contact details for <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import failed"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Import numbers"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"To search your contacts, turn on the Contacts permissions."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Turn on"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blocked numbers"</string>
 </resources>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 2a56b13..3e0a562 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contacts"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contacts"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"View contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edit Contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contacts"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contact"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direct dial"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Set default"</string>
     <string name="clear_default" msgid="7193185801596678067">"Clear default"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text copied"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Discard your changes?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Discard"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Discard your changes and quit editing?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Discard"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Keep editing"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Set up my profile"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Type person\'s name"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"From <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Delete <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Delete <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Photo from <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>not checked"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Photo from <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>checked"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Photo from unknown account not selected"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Photo from unknown account selected"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Contact list is being updated to reflect the change of language.\n\nPlease wait..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blocked numbers"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Calls and texts from these numbers will be blocked."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Add number"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Block number"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Add number or search contacts"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Calls and texts from this number will be blocked."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Unblock <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"UNBLOCK"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Block <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCK"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blocked"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> unblocked"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> is invalid."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Call blocking temporarily off"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Call blocking has been disabled because you contacted emergency services from this phone within the last 48 hours. It will be automatically re-enabled once the 48 hour period expires."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"You previously marked some contacts to be automatically sent to voicemail. Import those numbers here to block both calls and texts."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Import"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"View Numbers"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Add number"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Call blocking disabled for 48 hours"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Disabled because an emergency call was made."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"UNDO"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> is already blocked."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Unblock number"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Contact details for <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import failed"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Import numbers"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"To search your contacts, turn on the Contacts permissions."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Turn on"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blocked numbers"</string>
 </resources>
diff --git a/res/values-en-rIN/strings.xml b/res/values-en-rIN/strings.xml
index 2a56b13..3e0a562 100644
--- a/res/values-en-rIN/strings.xml
+++ b/res/values-en-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contacts"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contacts"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"View contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edit Contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contacts"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contact"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direct dial"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Set default"</string>
     <string name="clear_default" msgid="7193185801596678067">"Clear default"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text copied"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Discard your changes?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Discard"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Discard your changes and quit editing?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Discard"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Keep editing"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Set up my profile"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Type person\'s name"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"From <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Delete <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Delete <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Photo from <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>not checked"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Photo from <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>checked"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Photo from unknown account not selected"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Photo from unknown account selected"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Contact list is being updated to reflect the change of language.\n\nPlease wait..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blocked numbers"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Calls and texts from these numbers will be blocked."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Add number"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Block number"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Add number or search contacts"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Calls and texts from this number will be blocked."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Unblock <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"UNBLOCK"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Block <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCK"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blocked"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> unblocked"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> is invalid."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Call blocking temporarily off"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Call blocking has been disabled because you contacted emergency services from this phone within the last 48 hours. It will be automatically re-enabled once the 48 hour period expires."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"You previously marked some contacts to be automatically sent to voicemail. Import those numbers here to block both calls and texts."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Import"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"View Numbers"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Add number"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Call blocking disabled for 48 hours"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Disabled because an emergency call was made."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"UNDO"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> is already blocked."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Unblock number"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Contact details for <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import failed"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Import numbers"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"To search your contacts, turn on the Contacts permissions."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Turn on"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blocked numbers"</string>
 </resources>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index f706f9c..3f0611a 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contactos"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contactos"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ver contacto"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editar contacto"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contactos"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contacto"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Marcado directo"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Establecer como predeterminado"</string>
     <string name="clear_default" msgid="7193185801596678067">"Eliminar predeterminado"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texto copiado"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"¿Deseas descartar los cambios?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"¿Deseas descartar los cambios y salir del editor?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Seguir editando"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurar mi perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Escribe el nombre de la persona."</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Todas las fotos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Elegir foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Desde <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Borrar <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Borrar <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"No se seleccionó la foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Se seleccionó la foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"No se seleccionó la foto de una cuenta desconocida"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Se seleccionó la foto de una cuenta desconocida"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"La lista de contactos se está actualizando para reflejar el cambio de idioma.\n\n Espera."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloqueados"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Se bloquearán las llamadas y los mensajes de texto de estos números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Agregar número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquear número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Agregar número o buscar contactos"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Se bloquearán las llamadas y los mensajes de texto de este número."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"¿Deseas desbloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEAR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"¿Deseas bloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEAR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> bloqueado"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> desbloqueado"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> no es válido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bloqueo de llamadas desactivado temporalmente"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Se inhabilitó el bloqueo de llamadas porque te comunicaste con servicios de emergencia en las últimas 48 horas desde este teléfono. Se volverá a habilitar de forma automática una vez que venza el período de 48 horas."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Marcaste algunos contactos para que se enviaran de forma automática al buzón de voz. Importa esos números aquí para bloquear las llamadas y los mensajes de texto."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ver números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Agregar número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"El bloqueo de llamadas se inhabilitó durante 48 horas"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Se inhabilitó porque se realizó una llamada de emergencia."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESHACER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ya está bloqueado."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloquear número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Datos de contacto de <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Error al importar"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importar números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Para buscar contactos, activa el permiso Contactos."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activar"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloqueados"</string>
 </resources>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 7c22452..2b7cf69 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contactos"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contactos"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ver contacto"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editar contacto"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contactos"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contacto"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Llamada directa"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Establecer como predeterminado"</string>
     <string name="clear_default" msgid="7193185801596678067">"Borrar predeterminado"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texto copiado"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"¿Seguro que quieres descartar los cambios?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"¿Descartar los cambios y dejar de editar?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Seguir editando"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurar mi perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Escribe el nombre de la persona"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"De <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Eliminar <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Eliminar <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> no seleccionada"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> seleccionada"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"No se ha seleccionado una foto de una fuente desconocida"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Se ha seleccionado una foto de una fuente desconocida"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"La lista de contactos se está actualizando para reflejar el cambio de idioma.\n\nPor favor, espera..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloqueados"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Las llamadas y los mensajes de texto de esos números se bloquearán."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Añadir número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquear número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Añade número o busca contactos"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Se bloquearán las llamadas y los mensajes de texto de este número."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"¿Desbloquear el número <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEAR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"¿Bloquear el número <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEAR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Se ha bloqueado el número <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Se ha desbloqueado el número <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> no es válido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bloqueo de llamadas desactivado temporalmente"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Se ha inhabilitado el bloqueo de llamadas porque te has puesto en contacto con los servicios de emergencia desde este teléfono en las últimas 48 horas. Se volverá a habilitar automáticamente cuando finalice este periodo de tiempo."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anteriormente marcaste algunos contactos para que se enviaran automáticamente al buzón de voz. Importa aquí esos números para bloquear tanto las llamadas como los mensajes de texto."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ver números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Añadir número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Bloqueo de llamadas inhabilitado durante 48 horas"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Inhabilitado porque has hecho una llamada de emergencia."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESHACER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ya está bloqueado."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloquear número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Información de contacto de <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Error al importar"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importar números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Para poder buscar tus contactos, activa los permisos de contactos."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activar"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloqueados"</string>
 </resources>
diff --git a/res/values-et-rEE/strings.xml b/res/values-et-rEE/strings.xml
index c4fa68d..4eef033 100644
--- a/res/values-et-rEE/strings.xml
+++ b/res/values-et-rEE/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktid"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktid"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Kuva kontakt"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Muuda kontakti"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontaktid"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Otsevalimine"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Määra vaikeseadeks"</string>
     <string name="clear_default" msgid="7193185801596678067">"Kustuta vaikeseaded"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Tekst on kopeeritud"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Kas loobute oma muudatustest?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Loobu"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Kas soovite muudatustest loobuda ja muutmise lõpetada?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Loobu"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Jätka muutmist"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Minu profiili seadistamine"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Sisestage isiku nimi"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Kontolt <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Kustuta <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Kustuta <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto kasutajalt <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> pole märgitud"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto kasutajalt <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> on märgitud"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Tundmatult kontolt pärinev foto pole märgitud"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Tundmatult kontolt pärinev foto on märgitud"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaktiloendit värskendatakse keele muutmise kajastamiseks.\n\nPalun oodake ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokeeritud numbrid"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Kõned ja tekstsõnumid nendelt numbritelt blokeeritakse."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Lisa number"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokeeri number"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Lisage nr või otsige kontakte"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Kõned ja tekstsõnumid sellelt numbrilt blokeeritakse."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Kas soovite deblokeerida numbri <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DEBLOKEERI"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Kas soovite blokeerida numbri <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKEERI"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Number <xliff:g id="NUMBER">%1$s</xliff:g> on blokeeritud"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Number <xliff:g id="NUMBER">%1$s</xliff:g> on deblokeeritud"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> on kehtetu."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Kõnede blokeerimine on ajutiselt väljas"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Kõnede blokeerimine on keelatud, kuna võtsite sellelt telefonilt viimase 48 tunni jooksul ühendust hädaabiteenustega. See lubatakse 48 tunni möödumisel automaatselt uuesti."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Märkisite varem, et osad kontaktid tuleb automaatselt kõneposti saata. Nii kõnede kui ka tekstsõnumite blokeerimiseks importige need numbrid siia."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Impordi"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Vaata numbreid"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Lisa number"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Kõnede blokeerimine on 48 tunniks keelatud"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Keelatud, kuna tehti hädaabikõne."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"VÕTA TAG."</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> on juba blokeeritud."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Numbri deblokeerimine"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontakti <xliff:g id="NAMEORNUMBER">%1$s</xliff:g> üksikasjad"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importimine ebaõnnestus"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Impordi numbrid"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kontaktide otsimiseks lülitage sisse kontaktiload."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Lülita sisse"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokeeritud numbrid"</string>
 </resources>
diff --git a/res/values-eu-rES/strings.xml b/res/values-eu-rES/strings.xml
index 4210459..a0a8132 100644
--- a/res/values-eu-rES/strings.xml
+++ b/res/values-eu-rES/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktuak"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktuak"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ikusi kontaktua"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editatu kontaktua"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontaktuak"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontaktua"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Markatze zuzena"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Ezarri lehenetsi gisa"</string>
     <string name="clear_default" msgid="7193185801596678067">"Garbitu metodo lehenetsia"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Testua kopiatu da"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Aldaketak baztertu nahi dituzu?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Baztertu"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Aldaketak baztertu eta editatzeko modutik irten nahi duzu?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Baztertu"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Jarraitu editatzen"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> (<xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>)"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Konfiguratu nire profila"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Idatzi pertsonaren izena"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Argazki guztiak"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Aukeratu argazkia"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Kontua: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Ezabatu <xliff:g id="DATA_TYPE">%s </xliff:g> <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Ezabatu <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Ez da hautatu <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> erabiltzailearen kontuko argazkia"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Hautatu da <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> erabiltzailearen kontuko argazkia"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Kontu ezezaguneko argazkia hautatu gabe dago"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Kontu ezezaguneko argazkia hautatu da"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaktuen zerrenda eguneratzen ari da hizkuntzaren aldaketa aplikatzeko.\n\nItxaron, mesedez…"</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokeatutako zenbakiak"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Blokeatu egingo dira zenbaki hauetatik jasotzen diren deiak eta testu-mezuak."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Gehitu zenbakia"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokeatu zenbakia"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Gehitu zk. edo bilatu kontaktua"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Blokeatu egingo dira zenbaki honetatik jasotzen diren deiak eta testu-mezuak."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> desblokeatu nahi duzu?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOKEATU"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> blokeatu nahi duzu?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKEATU"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blokeatuta"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> desblokeatuta"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> zenbakiak ez du balio."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Deien blokeoa aldi baterako desgaituta"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Deiak blokeatzeko aukera desgaitu egin da, azken 48 orduetan larrialdi-zerbitzuekin harremanetan jarri zarelako telefono honetatik. Berriro gaituko da 48 orduko epea igaro ondoren."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Deitzaile batzuk automatikoki erantzungailura bidaltzeko dauzkazu konfiguratuta. Inporta itzazu zenbaki horiek, haien deiak eta testu-mezuak blokea ditzagun."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Inportatu"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ikusi zenbakiak"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Gehitu zenbakia"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Deiak blokeatzeko aukera desgaituta egongo da 48 orduan"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Desgaituta dago, larrialdi-dei bat egin delako."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESEGIN"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> blokeatuta dago dagoeneko."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desblokeatu zenbakia"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> kontaktuaren xehetasunak"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Ezin izan da inportatu"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Inportatu zenbakiak"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kontaktuak bilatzeko, aktibatu kontaktuak atzitzeko baimenak."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktibatu"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokeatutako zenbakiak"</string>
 </resources>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index eb20c12..ff5a557 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"مخاطبین"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"مخاطبین"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"مشاهده مخاطب"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"ویرایش مخاطب"</string>
     <string name="contactsList" msgid="8661624236494819731">"مخاطبین"</string>
     <string name="shortcutContact" msgid="749243779392912958">"مخاطب"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"شماره گیری مستقیم"</string>
@@ -200,7 +202,7 @@
     <string name="widget_name_and_phonetic" msgid="8739586586600099979">"<xliff:g id="DISPLAY_NAME">%1$s</xliff:g> (<xliff:g id="PHONETIC_NAME">%2$s</xliff:g>)"</string>
     <string name="date_year_toggle" msgid="7122002148518724139">"سال لحاظ شود"</string>
     <string name="social_widget_label" msgid="6378905543028924592">"مخاطب"</string>
-    <string name="social_widget_loading" msgid="5327336597364074608">"در حال بارگیری..."</string>
+    <string name="social_widget_loading" msgid="5327336597364074608">"در حال بارکردن…"</string>
     <string name="contacts_unavailable_create_contact" msgid="7014525713871959208">"ایجاد مخاطب جدید"</string>
     <string name="contacts_unavailable_add_account" msgid="4347232421410561500">"افزودن حساب"</string>
     <string name="contacts_unavailable_import_contacts" msgid="4957393255392437529">"وارد کردن مخاطبین"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"تنظیم پیش‌فرض"</string>
     <string name="clear_default" msgid="7193185801596678067">"پاک کردن پیش فرض‌ها"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"متن کپی شده"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"از تغییرات صرف‌نظر می‌کنید؟"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"صرف‌نظر کردن"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"از تغییراتتان صرف‌نظر می‌کنید و از ویرایش خارج می‌شوید؟"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"صرف‌نظر کردن"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"حفظ ویرایش"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"راه‌اندازی نمایه من"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"نام شخص را تایپ کنید"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"از <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"حذف <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"حذف <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"عکس <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> انتخاب نشد"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"عکس <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> انتخاب شد"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"عکس از حساب نامشخص انتخاب نشده است"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"عکس از حساب نامشخص انتخاب شده است"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"لیست مخاطبین جهت اعمال تغییر زبان در حال به‌روزرسانی است.\n\nلطفاً منتظر بمانید..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"شماره‌های مسدودشده"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"تماس‌ها و پیامک‌های این شماره‌ها مسدود خواهند شد."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"افزودن شماره"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"مسدود کردن شماره"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"افزودن شماره یا جستجوی مخاطب"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"تماس‌ها و پیامک‌ها از این شماره مسدود خواهند شد."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> گشوده شود؟"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"گشودن"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> مسدود شود؟"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"مسدود کردن"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> مسدود شد"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> گشوده شد"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> نامعتبر است."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"انسداد تماس موقتاً خاموش است"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"چون در ۴۸ ساعت گذشته با این تلفن با سرویس‌های اضطراری تماس گرفتید، انسداد تماس غیرفعال شده است. پس از گذشت ۴۸ ساعت، این قابلیت دوباره فعال می‌شود."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"قبلاً برخی از مخاطبین را علامت‌گذاری کردید تا به‌طور خودکار به پست‌ صوتی ارسال شوند. آن شماره‌ها را اینجا وارد کنید تا هم تماس‌ها و هم پیامک‌های آن‌ها مسدود شود."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"وارد کردن"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"مشاهده شماره‌ها"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"افزودن شماره"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"مسدود کردن تماس برای ۴۸ ساعت غیرفعال شد"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"به علت برقرار شدن تماس اضطراری، غیرفعال شد."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"واگرد"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> درحال‌حاضر مسدود شده است."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"گشودن شماره"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"جزئیات تماس برای <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"وارد کردن انجام نشد"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"وارد کردن شماره‌ها"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"برای جستجوی مخاطبینتان، مجوزهای مخاطبین را روشن کنید."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"روشن کردن"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"شماره‌های مسدودشده"</string>
 </resources>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 0775f17..b0ae286 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Yhteystiedot"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Yhteystiedot"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Näytä yhteystieto"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Muokkaa yhteystietoa"</string>
     <string name="contactsList" msgid="8661624236494819731">"Yhteystiedot"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Yhteystieto"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Puhelu"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Aseta oletukseksi"</string>
     <string name="clear_default" msgid="7193185801596678067">"Poista oletus"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Teksti kopioitu"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Hylätäänkö muutokset?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Hylkää"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Hylätäänkö muutokset ja lopetetaan muokkaaminen?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Hylkää"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Jatka muokkausta"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Luo profiili"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Kirjoita henkilön nimi"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Kaikki kuvat"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Valitse valokuva"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Tili: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Poista <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Poista <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Tilin <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> kuvaa ei ole valittuna."</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Tilin <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> kuva on valittuna."</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Tuntemattoman tilin kuva ei ole valittuna."</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Tuntemattoman tilin kuva on valittuna."</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Yhteystietoluetteloa päivitetään vaihdetun kielen mukaiseksi.\n\nOdota…"</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Estetyt numerot"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Näistä numeroista tulevat puhelut ja tekstiviestit estetään."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Lisää numero"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Estä numero"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Lisää numero tai hae yhteystiedoista"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Tästä numerosta tulevat puhelut ja tekstiviestit estetään."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Kumotaanko numeron <xliff:g id="NUMBER">%1$s</xliff:g> esto?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"KUMOA ESTO"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Estetäänkö <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ESTÄ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Numero <xliff:g id="NUMBER">%1$s</xliff:g> estetty"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Numeron <xliff:g id="NUMBER">%1$s</xliff:g> esto kumottu"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> on virheellinen."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Puheluesto väliaikaisesti pois käytöstä"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Puheluiden estäminen on poistettu käytöstä, koska olet ottanut yhteyttä hätäpalveluihin tästä puhelimesta viimeisen 48 tunnin aikana. Esto otetaan automaattisesti uudelleen käyttöön, kun puhelusta on kulunut 48 tuntia."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Valitsit aiemmin, että tiettyjen yhteystietojen puhelut siirretään suoraan vastaajaan. Tuomalla nämä yhteystiedot voit estää puhelut ja tekstiviestit."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Tuo"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Näytä numerot"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Lisää numero"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Puhelujen esto poistettiin käytöstä 48 tunnin ajaksi"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Toiminto poistettiin käytöstä hätäpuhelun vuoksi."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"KUMOA"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> on jo estetty."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Poista numeron esto"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Yhteystiedot: <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Tuonti epäonnistui."</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Tuo numerot"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Jos haluat hakea kontaktejasi, ota käyttöön kontaktien käyttöoikeudet."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Ota käyttöön"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Estetyt numerot"</string>
 </resources>
diff --git a/res/values-fr-rCA/strings.xml b/res/values-fr-rCA/strings.xml
index 0e3e905..9c910e5 100644
--- a/res/values-fr-rCA/strings.xml
+++ b/res/values-fr-rCA/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contacts"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contacts"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Afficher le contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Modifier le contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contacts"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contact"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Raccourci appel"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Définir par défaut"</string>
     <string name="clear_default" msgid="7193185801596678067">"Effacer les valeurs par défaut"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texte copié."</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Annuler les modifications?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Ignorer"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Annuler les modifications et quitter le mode d\'édition?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Ignorer"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Continuer les modifications"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurer mon profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Saisissez le nom de la personne"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Toutes les photos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Sélectionner une photo"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"De <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Effacer <xliff:g id="DATA_TYPE">%s </xliff:g> <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Effacer <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Photo <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> – <xliff:g id="USER_NAME">%s </xliff:g> non cochée"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Photo <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> – <xliff:g id="USER_NAME">%s </xliff:g> cochée"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Photo d\'un compte inconnu non sélectionnée"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Photo d\'un compte inconnu sélectionnée"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Mise à jour de la liste des contacts en cours suite au changement de langue.\n\nVeuillez patienter..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Numéros bloqués"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Les appels et les messages texte de ces numéros seront bloqués."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ajouter un numéro"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquer le numéro"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Ajouter nº ou chercher contact"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Les appels et les messages texte de ce numéro seront bloqués."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Débloquer le numéro <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DÉBLOQUER"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Bloquer le numéro <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUER"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Le numéro « <xliff:g id="NUMBER">%1$s</xliff:g> » est bloqué"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Le numéro « <xliff:g id="NUMBER">%1$s</xliff:g> » est débloqué"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Le numéro <xliff:g id="NUMBER">%1$s</xliff:g> n\'est pas valide."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blocage appels désactivé temporairement"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Le blocage des appels a été désactivé, car vous avez communiqué avec les services d\'urgence à partir de ce téléphone au cours des dernières 48 heures. Le blocage sera réactivé automatiquement après 48 heures."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Vous avez indiqué que certains appelants devaient automatiquement être renvoyés vers la messagerie vocale. Importez les numéros en question ici pour bloquer leurs appels et les messages texte."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importer"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Afficher les numéros"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ajouter un numéro"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blocage des appels désactivé pendant 48 heures"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Désactivé, car un appel d\'urgence a été effectué"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANNULER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Le numéro <xliff:g id="NUMBER">%1$s</xliff:g> est déjà bloqué."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Débloquer le numéro"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Coordonnées de <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Échec de l\'importation"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importer les numéros"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Pour rechercher vos contacts et les lieux à proximité, activez les autorisations Contacts."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activer"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Numéros bloqués"</string>
 </resources>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index ea86fee..aa784f6 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contacts"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contacts"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Afficher le contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Modifier le contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contacts"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contact"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Raccourci appel"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Définir par défaut"</string>
     <string name="clear_default" msgid="7193185801596678067">"Effacer les valeurs par défaut"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texte copié"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Annuler les modifications ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Supprimer"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Supprimer les modifications et quitter le mode d\'édition ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Supprimer"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Poursuivre les modifications"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurer mon profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Saisissez le nom de la personne"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Toutes les photos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Sélectionner une photo"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Du compte <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Supprimer l\'élément \"<xliff:g id="DATA_TYPE">%s </xliff:g> – <xliff:g id="DATA_KIND">%s</xliff:g>\""</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Supprimer l\'élément \"<xliff:g id="DATA_KIND">%s</xliff:g>\""</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Photo <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> – <xliff:g id="USER_NAME">%s </xliff:g> non cochée"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Photo <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> – <xliff:g id="USER_NAME">%s </xliff:g> cochée"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Photo d\'un compte inconnu non sélectionnée"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Photo d\'un compte inconnu sélectionnée"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Mise à jour de la liste des contacts en cours suite au changement de langue.\n\nVeuillez patienter..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Numéros bloqués"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Les appels et les SMS associés à ces numéros seront bloqués."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ajouter un numéro"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquer le numéro"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Ajouter num. ou rech. contacts"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Les appels et les SMS associés à ce numéro seront bloqués."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Débloquer le numéro \"<xliff:g id="NUMBER">%1$s</xliff:g>\" ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DÉBLOQUER"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Bloquer le numéro \"<xliff:g id="NUMBER">%1$s</xliff:g>\" ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUER"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Le numéro \"<xliff:g id="NUMBER">%1$s</xliff:g>\" est bloqué."</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Le numéro \"<xliff:g id="NUMBER">%1$s</xliff:g>\" est débloqué."</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Le numéro \"<xliff:g id="NUMBER">%1$s</xliff:g>\" n\'est pas valide."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blocage appels désactivé temporairement"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Le blocage des appels a été désactivé, car vous avez contacté les services d\'urgence à l\'aide de ce téléphone au cours des dernières 48 heures. Le blocage sera réactivé automatiquement après 48 heures."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Vous avez indiqué que certains contacts devaient automatiquement être renvoyés vers la messagerie vocale. Importez les numéros correspondants dans cette liste pour bloquer à la fois les appels et les SMS."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importer"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Afficher les numéros"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ajouter un numéro"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blocage des appels désactivé pendant 48 heures"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Désactivé, car un appel d\'urgence a été effectué"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANNULER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Le numéro \"<xliff:g id="NUMBER">%1$s</xliff:g>\" est déjà bloqué."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Débloquer le numéro"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Coordonnées associées à <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Échec lors de l\'importation."</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importer les numéros"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Pour rechercher vos contacts, activez l\'autorisation Contacts."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activer"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Numéros bloqués"</string>
 </resources>
diff --git a/res/values-gl-rES/strings.xml b/res/values-gl-rES/strings.xml
index bcce062..49e014e 100644
--- a/res/values-gl-rES/strings.xml
+++ b/res/values-gl-rES/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contactos"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contactos"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ver contacto"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editar contacto"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contactos"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contacto"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Marcación directa"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Definir como predeterminado"</string>
     <string name="clear_default" msgid="7193185801596678067">"Borrar valores predeterminados"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texto copiado"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Descartar os cambios?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Queres descartar os teus cambios e deixar de editar?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Seguir editando"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurar o meu perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Escribe o nome da persoa"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Todas as fotos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Escoller foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"De <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Eliminar <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Eliminar <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Non se seleccionou a foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Seleccionouse a foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Non se seleccionou a foto dunha conta descoñecida"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Seleccionouse a foto dunha conta descoñecida"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"A lista de contactos estase actualizando para reflectir o cambio do idioma.\n\nAgarda..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloqueados"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Bloquearanse as chamadas e as mensaxes destes números."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Engadir número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquear número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Engade número/busca contactos"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Bloquearanse as chamadas e as mensaxes de texto deste número."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Queres desbloquear o <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEAR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Queres bloquear o <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEAR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Bloqueouse o <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Desbloqueouse o <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"O <xliff:g id="NUMBER">%1$s</xliff:g> non e válido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"O bloqueo de chamadas desactivouse temporalmente"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"O bloqueo de chamadas desactivouse porque contactaches cos servizos de emerxencias desde este teléfono nas últimas 48 horas. Volverase activar automaticamente unha vez que pase o período de 48 horas."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Previamente marcaches algúns contactos para que se envíen automaticamente ao correo de voz. Importa eses números aquí para bloquear as chamadas e as mensaxes."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ver números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Engadir número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Desactivouse o bloqueo de chamadas durante 48 horas"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Desactivouse porque se realizou unha chamada de emerxencia."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESFACER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"O <xliff:g id="NUMBER">%1$s</xliff:g> xa está bloqueado."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloquear número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detalles de contacto de <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Produciuse un erro na importación"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importar números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Para buscar os teus contactos, activa os permisos de Contactos."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activar"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloqueados"</string>
 </resources>
diff --git a/res/values-gu-rIN/strings.xml b/res/values-gu-rIN/strings.xml
index 72c3001..220d3c3 100644
--- a/res/values-gu-rIN/strings.xml
+++ b/res/values-gu-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"સંપર્કો"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"સંપર્કો"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"સંપર્ક જુઓ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"સંપર્ક સંપાદિત કરો"</string>
     <string name="contactsList" msgid="8661624236494819731">"સંપર્કો"</string>
     <string name="shortcutContact" msgid="749243779392912958">"સંપર્ક"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"સીધું જ ડાયલ"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ડિફોલ્ટ સેટ કરો"</string>
     <string name="clear_default" msgid="7193185801596678067">"ડિફોલ્ટ સાફ કરો"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"ટેક્સ્ટ કૉપિ કર્યો"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"તમારા ફેરફારો છોડી દઈએ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"કાઢી નાખો"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"તમારા ફેરફારોને નિકાળીને સંપાદન છોડી દઈએ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"નિકાળો"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"સંપાદન ચાલુ રાખો"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"મારી પ્રોફાઇલ સેટ કરો"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"વ્યક્તિનું નામ લખો"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> માંથી"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> કાઢી નાખો"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> કાઢી નાખો"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ની તસ્વીર ચેક કરી નથી"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ની તસ્વીર ચેક કરી"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"અજાણ્યાં એકાઉન્ટનો ફોટો ચેક ન કર્યો"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"અજાણ્યાં એકાઉન્ટનો ફોટો ચેક કર્યો"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ભાષામાં ફેરફાર પ્રતિબિંબિત કરવા માટે સંપર્ક સૂચિને અપડેટ કરવામાં આવી રહી છે.\n\nકૃપા કરીને રાહ જુઓ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"અવરોધિત નંબરો"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"આ નંબરથી આવનારા કૉલ્સ અને ટેક્સ્ટ અવરોધિત કરવામાં આવશે."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"નંબર ઉમેરો"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"નંબર અવરોધિત કરો"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"નંબર ઉમેરો અથવા સંપર્કો શોધો"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"આ નંબરથી આવનારા કૉલ્સ અને ટેક્સ્ટ અવરોધિત કરવામાં આવશે."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> ને અનાવરોધિત કરીએ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"અનાવરોધિત કરો"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> ને અવરોધિત કરીએ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"અવરોધિત કરો"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> અવરોધિત કર્યો"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> અનાવરોધિત કર્યો"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> અમાન્ય છે."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"કૉલ અવરોધિત કરવાનું અસ્થાયીરૂપે બંધ છે"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"કૉલ અવરોધિત કરવાનું અક્ષમ કરવામાં આવ્યું છે કારણ કે તમે આ ફોનમાંથી છેલ્લા 48 કલાકમાં કટોકટીની સેવાઓનો સંપર્ક કર્યો હતો. એકવાર 48 કલાકનો સમયગાળો સમાપ્ત થાય, પછી તે આપમેળે ફરીથી સક્ષમ કરવામાં આવશે."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"તમે પહેલા કેટલાક સંપર્કોને વૉઇસમેઇલ પર આપમેળે મોકલવા માટે ચિહ્નિત કરેલા. કૉલ્સ અને ટેક્સ્ટ બંનેને અવરોધિત કરવા માટે તે નંબરોને અહીં આયાત કરો."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"આયાત કરો"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"સંખ્યા જુઓ"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"નંબર ઉમેરો"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"કૉલ અવરોધિત કરવાનું 48 કલાક માટે અક્ષમ કરાયું"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"અક્ષમ કરાયું કારણ કે એક કટોકટીનો કૉલ કરવામાં આવ્યો હતો."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"પૂર્વવત્ કરો"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ને પહેલેથી અવરોધિત કરવામાં આવ્યો છે."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"નંબર અનાવરોધિત કરો"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> માટે સંપર્ક વિગતો"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"આયાત નિષ્ફળ થયું"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"નંબર્સ આયાત કરો"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"તમારા સંપર્કો શોધવા માટે, સંપર્કોની પરવાનગીઓ ચાલુ કરો."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ચાલુ કરો"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"અવરોધિત નંબરો"</string>
 </resources>
diff --git a/res/values-hi/strings.xml b/res/values-hi/strings.xml
index 5127f8f..28cd1c3 100644
--- a/res/values-hi/strings.xml
+++ b/res/values-hi/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"संपर्क"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"संपर्क"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"संपर्क देखें"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"संपर्क संपादित करें"</string>
     <string name="contactsList" msgid="8661624236494819731">"संपर्क"</string>
     <string name="shortcutContact" msgid="749243779392912958">"संपर्क"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"कॉल करें"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"सामान्य सेट करें"</string>
     <string name="clear_default" msgid="7193185801596678067">"सामान्य साफ़ करें"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"लेख की प्रतिलिपि बनाई गई"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"आपके परिवर्तन हटा दें?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"ख़ारिज करें"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"अपने बदलावों को ख़ारिज करें और संपादन से बाहर निकलें?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"अभी नहीं"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"संपादित करते रहें"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"मेरी प्रोफ़ाइल सेट करें"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"व्‍यक्ति‍ का नाम लिखें"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> की ओर से"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> हटाएं"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> हटाएं"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>की फ़ोटो चेक नहीं की गई"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>की फ़ोटो चेक की गई"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"अज्ञात खाते की फ़ोटो नहीं जांची गई"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"अज्ञात खाते की फ़ोटो जांची गई"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"भाषा के परिवर्तन दिखाने के लिए संपर्क सूची से नई जानकारी मिल रही है.\n\nकृपया प्रतीक्षा करें..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"अवरोधित नंबर"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"इन नंबर के कॉल और लेख संदेशों को अवरुद्ध कर दिया जाएगा."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"नंबर जोड़ें"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"नंबर अवरुद्ध करें"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"नंबर जोड़ें या संपर्क खोजें"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"इस नंबर के कॉल और लेख संदेशों को अवरुद्ध कर दिया जाएगा."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> को अनवरोधित करें?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"अनवरोधित करें"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> को अवरुद्ध करें?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"अवरुद्ध करें"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> अवरोधित किया गया"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> अनवरोधित किया गया"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> अमान्य है."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"कॉल अवरुद्ध करना अस्‍थायी रूप से बंद है"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"कॉल अवरुद्ध किए जाने को अक्षम कर दिया गया है क्योंकि पिछले 48 घंटों में आपने इस फ़ोन से आपातकालीन सेवाओं से संपर्क किया है. 48 घंटे की अवधि बीत जाने पर यह अपने आप फिर से सक्षम हो जाएगी."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"आपने पहले कुछ संपर्कों को अपने आप वॉइसमेल पर भेजे जाने के लिए चिह्नित किया था. कॉल और लेख संदेशों को अवरुद्ध करने के लिए वे नंबर यहां आयात करें."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"आयात करें"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"नंबर देखें"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"नंबर जोड़ें"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"कॉल अवरुद्ध करना 48 घंटे के लिए अक्षम कर दिया गया"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"आपातकालीन कॉल किए जाने के कारण अक्षम कर दिया गया."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"वापस लाएं"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> पहले से अवरोधित है."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"नंबर अनवरोधित करें"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> का संपर्क विवरण"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"आयात करना विफल रहा"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"नंबर आयात करें"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"अपने संपर्कों की खोज करने के लिए, संपर्क अनुमतियों को चालू करें."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"चालू करें"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"अवरोधित नंबर"</string>
 </resources>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index c7099e3..066154a 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakti"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakti"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Prikaži kontakt"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Uredi kontakt"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakti"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Izravan poziv"</string>
@@ -231,8 +233,9 @@
     <string name="set_default" msgid="4417505153468300351">"Postavi zadano"</string>
     <string name="clear_default" msgid="7193185801596678067">"Izbriši zadano"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Tekst kopiran"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Odbaciti promjene?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Odbaci"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Želite li odbaciti promjene i prekinuti uređivanje?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Odbaci"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Nastavi uređivati"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Postavi moj profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Upišite ime osobe"</string>
@@ -329,8 +332,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Sve fotografije"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Odabir fotografije"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"S računa <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Izbriši <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Izbriši <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Slika s računa <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> nije odabrana"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotografija s računa <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> odabrana"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Fotografija s nepoznatog računa nije odabrana"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Fotografija s nepoznatog računa odabrana"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Popis kontakata ažurira se tako da odražava promjene jezika.\n\nPričekajte..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokirani brojevi"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Pozivi i SMS poruke s tih brojeva blokirat će se."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj broj"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokiraj broj"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Dodaj broj ili potraži kontakt"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Pozivi i SMS poruke s tog broja blokirat će se."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Želite li deblokirati <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DEBLOKIRAJ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Želite li blokirati <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKIRAJ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> blokiran"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> deblokiran"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Broj <xliff:g id="NUMBER">%1$s</xliff:g> nije važeći."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokiranje poziva privremeno isključeno"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Blokiranje poziva onemogućeno je jer ste kontaktirali hitne službe s ovog telefona u posljednjih 48 sati. Automatski će se ponovo omogućiti kada prođe 48 sati."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Neke ste kontakte automatski slali na govornu poštu. Uvezite te brojeve ovdje ako želite blokirati pozive i SMS poruke."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Uvezi"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Prikaži brojeve"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj broj"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blokiranje poziva onemogućeno je na 48 sati"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Onemogućeno jer je upućen hitni poziv."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"PONIŠTI"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Broj <xliff:g id="NUMBER">%1$s</xliff:g> već je blokiran."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Deblokiranje broja"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Pojedinosti o kontaktu <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Uvoz nije uspio"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Uvoz brojeva"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Da biste pretraživali kontakte, uključite dopuštenja za kontakte."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Uključi"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokirani brojevi"</string>
 </resources>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index d28ccd3..3bbf824 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Névjegyek"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Névjegyek"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Névjegy megtekintése"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Névjegy szerkesztése"</string>
     <string name="contactsList" msgid="8661624236494819731">"Címtár"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Névjegy"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Közvetlen tárcsázás"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Beállítás alapértelmezettként"</string>
     <string name="clear_default" msgid="7193185801596678067">"Alapértelmezés törlése"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Másolt szöveg"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Elveti a módosításokat?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Elvetés"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Elveti a módosításokat, és kilép a szerkesztésből?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Elvetés"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Szerkesztés folytatása"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> -- <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Saját profil beállítása"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Írja be a személy nevét"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Innen: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"A(z) <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> törlése"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"A(z) <xliff:g id="DATA_KIND">%s</xliff:g> törlése"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"A következőtől származó fotó nincs kiválasztva: <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"A következőtől származó fotó kiválasztva: <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Az ismeretlen fiókból származó kép nincs kiválasztva"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Ismeretlen fiókból származó kép kiválasztva"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"A nyelv módosítása miatt folyamatban van a Címtár frissítése.\n\nKérjük, várjon..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Letiltott számok"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Az ezekről a számokról érkező hívásokat és üzeneteket letiltja a rendszer."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Szám hozzáadása"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Szám tiltása"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Adjon meg egy számot, vagy keressen a névjegyek között"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Az erről a számról érkező hívásokat és üzeneteket letiltja a rendszer."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Feloldja a következő szám tiltását: <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"TILTÁS FELOLDÁSA"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Letiltja a következő számot: <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"LETILTÁS"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"A következő szám letiltva: <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"A következő szám tiltása feloldva: <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"A(z) <xliff:g id="NUMBER">%1$s</xliff:g> érvénytelen."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Hívástiltás átmenetileg felfüggesztve"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Felfüggesztettük a hívások tiltását, mert az elmúlt 48 órában tárcsázta a segélyhívót erről a telefonról. A funkciót automatikusan újból engedélyezzük 48 óra elteltével."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Korábban beállította, hogy bizonyos személyektől érkező hívásokat automatikusan a hangpostafiókba irányítson a rendszer. Importálja ezeket a számokat ide az onnan érkező hívások és üzenetek letiltásához."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importálás"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Számok megtekintése"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Szám hozzáadása"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"A hívások tiltása funkció kikapcsolva 48 órára"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Letiltva vészhívás miatt."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"VISSZAVONÁS"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"A következő szám már le van tiltva: <xliff:g id="NUMBER">%1$s</xliff:g>."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Szám tiltásának feloldása"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> részletes adatai."</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Az importálás nem sikerült"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Számok importálása"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"A névjegyek kereséséhez adja meg a Névjegyek engedélyeket."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Engedélyezés"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Letiltott számok"</string>
 </resources>
diff --git a/res/values-hy-rAM/strings.xml b/res/values-hy-rAM/strings.xml
index c616a19..cfc9017 100644
--- a/res/values-hy-rAM/strings.xml
+++ b/res/values-hy-rAM/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Կոնտակտներ"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Կոնտակտներ"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Դիտել կոնտակտը"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Խմբագրել կոնտակտը"</string>
     <string name="contactsList" msgid="8661624236494819731">"Կոնտակտներ"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Կոնտակտ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Ուղիղ համարհավաքում"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Սահմանել լռելյայն"</string>
     <string name="clear_default" msgid="7193185801596678067">"Մաքրել լռելյայն"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Տեքսը պատճենված է"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Հրաժարվե՞լ ձեր փոփոխություններից"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Անտեսել"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Անտեսե՞լ փոփոխությունները և դադարեցնել խմբագրումը:"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Անտեսել"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Շարունակել խմբագրումը"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Կարգավորել իմ պրոֆիլը"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Մուտքագրեք անձի անունը"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Բոլոր լուսանկարները"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Ընտրել լուսանկար"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> հաշվից"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Ջնջել <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Ջնջել <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> հաշվի լուսանկարը չի նշվել"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> հաշվի լուսանկարը նշվել է"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Անհայտ հաշվից լուսանկարն ընտրված չէ"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Անհայտ հաշվից լուսանկարն ընտրված է"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Կոնտակտների ցանկը թարմացվում է` լեզվի փոփոխությունները արտացոլելու համար:\n \nԽնդրում ենք սպասել..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Արգելափակված համարներ"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Այս համարներից ստացվող զանգերը և տեքստային հաղորդագրությունները կարգելափակվեն:"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ավելացնել համար"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Արգելափակել համարը"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Ավելացրեք համար/որոնեք կոնտակտներ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Այս համարից զանգերը և տեքստային հաղորդագրությունները կարգելափակվեն:"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Արգելաբացե՞լ <xliff:g id="NUMBER">%1$s</xliff:g> համարը:"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ԱՐԳԵԼԱԲԱՑԵԼ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Արգելափակե՞լ <xliff:g id="NUMBER">%1$s</xliff:g> համարը:"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ԱՐԳԵԼԱՓԱԿԵԼ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Արգելափակվել է <xliff:g id="NUMBER">%1$s</xliff:g> համար"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Արգելաբացվել է <xliff:g id="NUMBER">%1$s</xliff:g> համար"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> համարը սխալ է:"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Զանգերի արգելափակումը կասեցվել է"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Զանգերի արգելափակումը կասեցվել է, քանի որ վերջին 48 ժամվա ընթացքում դուք այս հեռախոսից զանգել եք արտակարգ իրավիճակների ծառայություններին: 48 ժամ տևողությամբ ժամանակահատվածի ավարտից հետո այն ավտոմատ կերպով կվերամիացվի:"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Դուք նախկինում նշել եք որոշ կոնտակտներ՝ ձայնային փոստին ավտոմատ կերպով ուղարկելու համար: Ներմուծեք դրանց համարներն այստեղ՝ ինչպես զանգերը, այնպես էլ տեքստային հաղորդագրությունները արգելափակելու համար:"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Ներմուծում"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Կոնտակտների թիվը"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ավելացնել համար"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Զանգերի արգելափակումն անջատվել է 48 ժամով"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Անջատվել է, քանի որ կատարվել է արտակարգ իրավիճակների զանգ:"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ՀԵՏԱՐԿԵԼ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> համարն արդեն արգելափակված է:"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Արգելաբացել համարը"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>-ի կոնտակտային տվյալները"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Ներմուծումը չհաջողվեց"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Ներմուծել համարները"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Կոնտակտները որոնելու համար միացրեք Կոնտակտների թույլտվությունները:"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Միացնել"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Արգելափակված համարներ"</string>
 </resources>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 656ea32..3b3f1a7 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontak"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontak"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Lihat Kontak"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edit Kontak"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontak"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontak"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Panggilan langsung"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Setel sebagai default"</string>
     <string name="clear_default" msgid="7193185801596678067">"Hapus default"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Teks disalin"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Buang perubahan Anda?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Buang"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Buang perubahan dan berhenti mengedit?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Buang"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Simpan pengeditan"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Siapkan profil saya"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Ketik nama seseorang"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Dari <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Hapus <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Hapus <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto dari <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>tidak dicentang"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto dari <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>dicentang"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto dari akun tak dikenal tidak dicentang"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto dari akun tak dikenal dicentang"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Daftar kontak sedang diperbarui untuk mencerminkan perubahan bahasa.\n\nHarap tunggu..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Nomor yang diblokir"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Panggilan telepon dan SMS dari nomor ini akan diblokir."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Tambahkan nomor"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokir nomor"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Tambahkan nomor atau telusuri kontak"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Panggilan telepon dan SMS dari nomor ini akan diblokir."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Bebaskan <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"BEBASKAN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blokir <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKIR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> diblokir"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> dibebaskan"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> tidak valid."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokir panggilan dinonaktifkan sementara"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Pemblokiran panggilan telepon telah dinonaktifkan karena Anda menghubungi layanan darurat dari telepon ini dalam 48 jam terakhir. Akan diaktifkan kembali secara otomatis setelah masa 48 jam berakhir."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anda sebelumnya menandai beberapa kontak agar dialihkan secara otomatis ke pesan suara. Impor nomor tersebut di sini untuk memblokir panggilan telepon dan SMS."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Impor"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Lihat Nomor"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Tambahkan nomor"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Pemblokiran panggilan dinonaktifkan selama 48 jam"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Dinonaktifkan karena panggilan darurat dilakukan."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"URUNGKAN"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> sudah diblokir."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Bebaskan nomor"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detail kontak untuk <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Impor gagal"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Impor nomor"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Untuk menelusuri kontak, aktifkan izin Kontak."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktifkan"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Nomor yang diblokir"</string>
 </resources>
diff --git a/res/values-is-rIS/strings.xml b/res/values-is-rIS/strings.xml
index fa44afe..6a63596 100644
--- a/res/values-is-rIS/strings.xml
+++ b/res/values-is-rIS/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Tengiliðir"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Tengiliðir"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Skoða tengilið"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Breyta tengilið"</string>
     <string name="contactsList" msgid="8661624236494819731">"Tengiliðir"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Tengiliður"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Bein lína"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Velja sem sjálfgefið"</string>
     <string name="clear_default" msgid="7193185801596678067">"Hreinsa sjálfgefið"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texti afritaður"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Hunsa breytingarnar?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Fleygja"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Viltu fleygja breytingum og hætta að breyta?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Fleygja"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Breyta áfram"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Setja upp prófílinn minn"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Sláðu inn nafn tengiliðar"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Allar myndir"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Velja mynd"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Af <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Eyða <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Eyða <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Mynd frá <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ekki valin"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Mynd frá <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>valin"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Mynd af óþekktum reikningi ekki valin"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Mynd af óþekktum reikningi valin"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Verið er að uppfæra tengiliðalistann í samræmi við nýja tungumálið.\n\nAugnablik..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Númer á bannlista"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Lokað verður fyrir símtöl og skilaboð úr þessum númerum."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Bæta númeri við"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Setja númer á bannlista"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Bættu við númeri eða tengilið"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Lokað verður fyrir símtöl og skilaboð úr þessu númeri."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Taka <xliff:g id="NUMBER">%1$s</xliff:g> af bannlista?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"TAKA AF BANNLISTA"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Setja <xliff:g id="NUMBER">%1$s</xliff:g> á bannlista?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"SETJA Á BANNLISTA"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Lokað fyrir <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> tekið af bannlista"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> er ógilt."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Tímabundið slökkt á lokun fyrir símtöl"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Lokun fyrir símtöl hefur verið gerð óvirk vegna þess að þú hafðir samband við neyðarþjónustu úr þessum síma á undanförnum tveimur sólarhringum. Lokunin verður aftur virk að þessum tveimur sólarhringum liðnum."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Þú merktir áður nokkra tengiliði þannig að þeir verða sjálfkrafa sendir í talhólfið. Flyttu inn þessi númer hér til að loka fyrir bæði símtöl og skilaboð."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Flytja inn"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Skoða tölur"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Bæta númeri við"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Slökkt á lokun símtala í 48 klukkustundir"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Óvirkt vegna þess að neyðarsímtal var hringt."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"AFTURKALLA"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> er nú þegar á bannlista."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Taka númer af bannlista"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Tengiliðaupplýsingar um <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Innflutningur mistókst"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Flytja inn númer"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kveiktu á heimildunum fyrir tengiliði til að leita að tengiliðum."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Kveikja"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Númer á bannlista"</string>
 </resources>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 9e83562..00b22fb 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contatti"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contatti"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Visualizza contatto"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Modifica contatto"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contatti"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contatto"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Composizione diretta"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Imposta come predefinito"</string>
     <string name="clear_default" msgid="7193185801596678067">"Cancella impostazione predefinita"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Testo copiato"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Annullare le modifiche?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Annulla"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Annullare le modifiche e uscire dalla modalità di modifica?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Ignora"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Continua la modifica"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Imposta il mio profilo"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Digita il nome della persona"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Tutte le foto"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Scegli foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Da <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Elimina <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Elimina <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto di <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> non selezionata"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto di <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> selezionata"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto di un account sconosciuto non selezionata"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto di un account sconosciuto selezionata"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"L\'elenco contatti verrà aggiornato per rispecchiare il cambio di lingua.\n\nAttendi..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Numeri bloccati"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Le chiamate e gli SMS da questi numeri verranno bloccati."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Aggiungi numero"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blocca numero"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Aggiungi numero/cerca contatti"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Le chiamate e gli SMS da questo numero verranno bloccati."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Sbloccare il numero <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"SBLOCCA"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Bloccare il numero <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCCA"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> bloccato"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> sbloccato"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> non è valido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blocco chiamate temporaneam. disattivato"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Il blocco chiamate è stato disattivato perché hai contattato servizi di emergenza da questo telefono nelle ultime 48 ore. Verrà riattivato automaticamente una volta trascorso il periodo di 48 ore."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Hai già contrassegnato alcuni contatti da inviare automaticamente alla segreteria. Importa qui i relativi numeri per bloccare chiamate e SMS."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importa"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Visualizza numeri"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Aggiungi numero"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Il blocco chiamate è stato disattivato per 48 ore"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Funzione disattivata: è stata fatta una chiamata di emergenza."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANNULLA"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> è già bloccato."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Sblocca numero"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Dettagli contatto <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importazione non riuscita"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importa numeri"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Per cercare nei tuoi contatti, attiva le autorizzazioni Contatti."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Attiva"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Numeri bloccati"</string>
 </resources>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 115ea95..b7cd885 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"אנשי קשר"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"אנשי קשר"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"הצג איש קשר"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"ערוך איש קשר"</string>
     <string name="contactsList" msgid="8661624236494819731">"אנשי קשר"</string>
     <string name="shortcutContact" msgid="749243779392912958">"איש קשר"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"חיוג ישיר"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"קבע כברירת מחדל"</string>
     <string name="clear_default" msgid="7193185801596678067">"נקה ברירת מחדל"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"טקסט שהועתק"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"למחוק את השינויים שביצעת?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"מחק"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"האם להתעלם מהשינויים שביצעת ולהפסיק לערוך?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"מחק"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"המשך לערוך"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"הגדרת הפרופיל שלי"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"הקלד שם של אדם"</string>
@@ -342,4 +345,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"מאת <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"מחק את <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"מחק <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"תמונה מ-<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>לא סומנה"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"תמונה מ-<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>סומנה"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"לא סומנה תמונה מחשבון לא ידוע"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"סומנה תמונה מחשבון לא ידוע"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"רשימת אנשי הקשר מתעדכנת כדי לשקף את החלפת השפה.\n\nהמתן..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"מספרים חסומים"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"שיחות והודעות טקסט ממספרים אלו ייחסמו."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"הוסף מספר"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"חסום מספר"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"הוסף מספר או חפש אנשי קשר"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"שיחות והודעות טקסט ממספר זה ייחסמו."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"האם לבטל את חסימת המספר <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ביטול חסימה"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"האם לחסום את המספר <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"חסום"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> חסום"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"בוטלה החסימה של <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> אינו חוקי."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"חסימת השיחות מושבתת באופן זמני"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"חסימת השיחות הושבתה מפני שיצרת קשר מטלפון זה עם שירותי חירום במהלך 48 השעות האחרונות. הפונקציה תופעל מחדש באופן אוטומטי בתום 48 השעות."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"בעבר סימנת כמה אנשי קשר שיישלחו באופן אוטומטי לדואר הקולי. ייבא לכאן את המספרים האלה כדי לחסום גם קבלת שיחות וגם הודעות טקסט."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"יבא"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"הצג מספרים"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"הוסף מספר"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"חסימת השיחות הושבתה ל-48 שעות"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"מושבתת מפני שבוצעה שיחת חירום."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"בטל"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> כבר חסום."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"בטל חסימת מספר"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"פרטי יצירת קשר עבור <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"הייבוא נכשל"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"יבא מספרים"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"כדי לחפש באנשי הקשר, הפעל את ההרשאה \'אנשי קשר\'."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"הפעל"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"מספרים חסומים"</string>
 </resources>
diff --git a/res/values-ja/donottranslate_config.xml b/res/values-ja/donottranslate_config.xml
deleted file mode 100644
index 7f53722..0000000
--- a/res/values-ja/donottranslate_config.xml
+++ /dev/null
@@ -1,38 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2010, 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>
-    <!-- If true, an option is shown in Display Options UI to choose a sort order -->
-    <bool name="config_sort_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_sort_order_primary">true</bool>
-
-    <!-- If true, an option is shown in Display Options UI to choose a name display order -->
-    <bool name="config_display_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_display_order_primary">true</bool>
-    
-    <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
-    <bool name="config_editor_field_order_primary">false</bool>
-
-    <!-- If true, phonetic name is included in the contact editor by default -->
-    <bool name="config_editor_include_phonetic_name">true</bool>
-</resources>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index ad0897c..a784cad 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"連絡先"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"連絡先"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"連絡先の表示"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"連絡先の編集"</string>
     <string name="contactsList" msgid="8661624236494819731">"連絡先"</string>
     <string name="shortcutContact" msgid="749243779392912958">"連絡先"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"直接発信"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"デフォルトに設定"</string>
     <string name="clear_default" msgid="7193185801596678067">"デフォルトを解除"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"テキストをコピーしました"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"変更を破棄しますか？"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"破棄"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"変更を破棄して編集を終了しますか？"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"破棄"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"編集を続ける"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"プロファイルを設定"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"名前を入力"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"送信元: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>を削除"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g>を削除"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> の写真は選択されていません"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> の写真は選択されています"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"不明なアカウントの写真は選択されていません"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"不明なアカウントの写真が選択されています"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"言語の変更に伴い連絡先リストを更新しています。\n\nしばらくお待ちください..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"ブロックした番号"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"この番号からの着信とテキスト メッセージがブロックされます。"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"電話番号を追加"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"番号をブロック"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"番号を追加するか連絡先を検索"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"この番号からの着信とテキスト メッセージがブロックされます。"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g>のブロックを解除しますか？"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ブロックを解除"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g>をブロックしますか？"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ブロック"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g>をブロックしました"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g>のブロックを解除しました"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g>は無効な番号です。"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"通話のブロックは一時的にOFFです"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"このスマートフォンから緊急通報番号への発信が過去48時間以内に行われているため、通話のブロックは無効になっています。48時間経過すると、通話のブロックは自動的に有効になります。"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"以前に一部の連絡先について自動的にボイスメールに転送するよう設定しています。ここにその番号をインポートすると、着信とテキスト メッセージの両方をブロックできます。"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"インポート"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"番号を表示"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"電話番号を追加"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"通話のブロックは48時間経過するまで無効になりました"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"緊急通報を行ったため無効になりました。"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"元に戻す"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g>は既にブロックしています。"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"番号のブロックを解除"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>の連絡先の詳細"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"インポートに失敗しました"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"番号をインポート"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"連絡先を検索するには、連絡先権限をONにしてください。"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ONにする"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"ブロックした番号"</string>
 </resources>
diff --git a/res/values-ka-rGE/strings.xml b/res/values-ka-rGE/strings.xml
index 2cddf7d..07e3113 100644
--- a/res/values-ka-rGE/strings.xml
+++ b/res/values-ka-rGE/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"კონტაქტები"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"კონტაქტები"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"კონტაქტის ნახვა"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"კონტაქტის რედაქტირება"</string>
     <string name="contactsList" msgid="8661624236494819731">"კონტაქტები"</string>
     <string name="shortcutContact" msgid="749243779392912958">"კონტაქტი"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"სწრაფი დარეკვა"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ნაგულისხმევად დაყენება"</string>
     <string name="clear_default" msgid="7193185801596678067">"ნაგულისხმევის წაშლა"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"კოპირებული ტექსტი"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"გსურთ ცვლილებების გაუქმება?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"გაუქმება"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"გსურთ ცვლილებების გაუქმება და რედაქტირებიდან გასვლა?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"გაუქმება"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"რედაქტირების გაგრძელება"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"პროფ. დაყენება"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"აკრიფეთ კონტაქტის სახელი"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"ყველა ფოტო"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"აირჩიეთ ფოტო"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g>-დან"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"წაიშალოს <xliff:g id="DATA_KIND">%s</xliff:g> (<xliff:g id="DATA_TYPE">%s </xliff:g>)"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"წაიშალოს <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"ფოტო <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>-დან არ არის მონიშნული"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"ფოტო <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>-დან მონიშნულია"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"ფოტო უცნობი ანგარიშიდან არ არის მონიშნული"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"ფოტო უცნობი ანგარიშიდან მონიშნულია"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"მიმდინარეობს კონტაქტების სიის განახლება ენის შეცვლის ასახვის მიზნით.\n\nგთხოვთ, დაილოდოთ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"დაბლოკილი ნომრები"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ამ ნომრებიდან შემოსული ზარები და ტექსტური შეტყობინებები დაიბლოკება."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ნომრის დამატება"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"ნომრის დაბლოკვა"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"დაამატეთ ნომერი ან მოიძიეთ კონტაქტებიდან"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ამ ნომრიდან შემოსული ზარები და ტექსტური შეტყობინებები დაიბლოკება."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"გსურთ, განბლოკოთ <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"განბლოკვა"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"გსურთ, დაბლოკოთ <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"დაბლოკვა"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> დაბლოკილია"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> განბლოკილია"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> არასწორია."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ზარების დაბლოკვა დროებით გამოირთო"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ზარების დაბლოკვა გაითიშა, რადგან ბოლო 48 საათში ამ ტელეფონიდან საგანგებო სამსახურებს დაუკავშირდით. 48 საათის გასვლის შემდეგ ის ავტომატურად ჩაირთვება."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"თქვენ მიერ ადრე ზოგიერთი კონტაქტის ხმოვან ფოსტაზე ავტომატური გადამისამართება მოინიშნა. დაამატეთ ეს ნომრები აქ, რათა დაბლოკოთ მათგან შემოსული ზარები და ტექსტური შეტყობინებები."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"იმპორტი"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"ნომრების ნახვა"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ნომრის დამატება"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ზარების დაბლოკვა გაითიშა 48 საათით"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"გათიშულია, რადგან განხორციელდა საგანგებო ზარი."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"დაბრუნება"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> უკვე დაბლოკილია."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"ნომრის განბლოკვა"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>-ის კონტაქტის დეტალები"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"იმპორტი ვერ მოხერხდა"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"ნომრების იმპორტი"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"თქვენი კონტაქტების მოსაძებნად ჩართეთ კონტაქტების ნებართვები."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ჩართვა"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"დაბლოკილი ნომრები"</string>
 </resources>
diff --git a/res/values-kk-rKZ/strings.xml b/res/values-kk-rKZ/strings.xml
index 11db4c9..5e286b2 100644
--- a/res/values-kk-rKZ/strings.xml
+++ b/res/values-kk-rKZ/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Контактілер"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Контактілер"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Контактіні көру"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Контактіні өңдеу"</string>
     <string name="contactsList" msgid="8661624236494819731">"Контактілер"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Контакт"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Тікелей теру"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Бастапқы ретінде орнату"</string>
     <string name="clear_default" msgid="7193185801596678067">"Бастапқыны өшіру"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Мәтін көшірмесі жасалды"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Өзгертулер сақталмай-ақ қойсын ба?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Жою"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Өзгертулерді алып тастап, өңдеуден шығу керек пе?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Алып тастау"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Өңдеуді жалғастыру"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Менің профайлымды реттеу"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Адамның атын теру"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Кімнен: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> жою"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> жою"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ішіндегі фотосуретке құсбелгі қойылмаған"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ішіндегі фотосуретке құсбелгі қойылған"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Белгісіз есептік жазбадан алынған фотосуретке құсбелгі қойылмады"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Белгісіз есептік жазбадан алынған фотосуретке құсбелгі қойылды"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Контактілер тізімі тілдің өзгеруін көрсету үшін жаңартылуда.\n\nКүтіңіз..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Бөгелген нөмірлер"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Бұл нөмірлерден қоңыраулар мен мәтіндік хабарлар бөгеледі."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Нөмір қосу"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Нөмірді бөгеу"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Нөмірді енгізіңіз немесе контактілерден іздеп табыңыз"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Бұл нөмірден қоңыраулар мен мәтіндік хабарлар бөгеледі."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгеуден шығару керек пе?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"БӨГЕУДЕН ШЫҒАРУ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгеу керек пе?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БӨГЕУ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгелген"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгеуден шығарылған"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> жарамсыз."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Қоңырауларға тыйым салу уақытша өшірулі"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Қоңырауларға тыйым салу өшірілді, өйткені сіз соңғы 48 сағат ішінде осы телефоннан төтенше қызметтерге хабарластыңыз. Ол 48 сағаттық кезең өткеннен кейін автоматты түрде қайта қосылады."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Сіз алдында кейбір контактілерді дауыстық поштаға автоматты түрде жіберу үшін белгілегенсіз. Қоңырауларды да, мәтіндік хабарларды да бөгеу үшін бұл нөмірлерді осында импорттаңыз."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Импорттау"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Нөмірлерді көру"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Нөмір қосу"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Қоңырауларға тыйым салу 48 сағат бойы өшірілген"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Өшірілген, өйткені төтенше қоңырау соғылған."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"КЕРІ ОРЫНДАУ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгеліп қойылған."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Нөмірді бөгеуден шығару"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> контакт деректері"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Импорттау сәтсіз аяқталды"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Нөмірлерді импорттау"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Контактілерді іздеу үшін \"Контактілер\" рұқсаттарын қосыңыз."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Қосу"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Бөгелген нөмірлер"</string>
 </resources>
diff --git a/res/values-km-rKH/strings.xml b/res/values-km-rKH/strings.xml
index 47aedc6..a86f785 100644
--- a/res/values-km-rKH/strings.xml
+++ b/res/values-km-rKH/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"ទំនាក់ទំនង"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"ទំនាក់ទំនង"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"មើលទំនាក់ទំនង"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"កែទំនាក់ទំនង"</string>
     <string name="contactsList" msgid="8661624236494819731">"ទំនាក់ទំនង"</string>
     <string name="shortcutContact" msgid="749243779392912958">"ទំនាក់ទំនង"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ហៅ​ដោយ​ផ្ទាល់"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"កំណត់​លំនាំដើម"</string>
     <string name="clear_default" msgid="7193185801596678067">"សម្អាត​លំនាំដើម"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"បាន​ចម្លង​អត្ថបទ"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"បោះបង់​ការ​ប្ដូរ​រ​របស់​អ្នក?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"បោះបង់"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"បោះបង់ការប្ដូររបស់អ្នក ហើយបញ្ឈប់ការកែសម្រួលមែនទេ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"បោះបង់"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"នៅ​បន្ត​កែសម្រួល"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"រៀបចំ​ប្រវត្តិរូប​របស់​ខ្ញុំ"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"វាយ​ឈ្មោះ​មនុស្ស"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"ពី <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"លុប <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"លុប <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"មិនបានជ្រើសរូបថតពី <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> នោះទេ"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"បានជ្រើសរូបថតពី <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"មិនបានជ្រើសរូបថតពីគណនីមិនស្គាល់ទេ"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"បានជ្រើសរូបថតពីគណនីមិនស្គាល់"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"កំពុង​ធ្វើ​បច្ចុប្បន្នភាព​ទំនាក់ទំនង​ដើម្បី​ឆ្លុះបញ្ចាំង​ការ​ប្ដូរ​ភាសា។\n\nសូម​រង់ចាំ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"លេខបានរារាំង"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ការហៅ និងការផ្ញើសារចេញពីលេខទាំងនេះនឹងត្រូវបានរារាំង"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"បន្ថែមលេខ"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"រារាំងលេខ"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"បន្ថែមលេខទូរស័ព្ទ ឬស្វែងរកទំនាក់ទំនង"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ការហៅ និងការផ្ញើសារចេញពីលេខនេះនឹងត្រូវបានរារាំង"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"ឈប់រារាំង <xliff:g id="NUMBER">%1$s</xliff:g> ឬ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ឈប់រារាំង"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"រារាំង <xliff:g id="NUMBER">%1$s</xliff:g> ឬ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"រារាំង"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"បានរារាំង <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"បានឈប់រារាំង <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> មិនត្រឹមត្រូវទេ"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ការរារាំងការហៅត្រូវបានបិទជាបណ្តោះអាសន្ន"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ការរារាំងការហៅត្រូវបានបិទដំណើរការ ដោយសារតែអ្នកបានទាក់ទងទៅសេវាអាសន្នចេញពីទូរស័ព្ទនេះក្នុងចន្លោះពេល 48 ម៉ោងកន្លងមកនេះ។ វានឹងបើកដំណើរការឡើងវិញ បន្ទាប់ពីរយៈពេល 48 ម៉ោងផុតកំណត់។"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"កាលពីមុនអ្នកបានដាក់សម្គាល់ឲ្យបញ្ជូនលេខទំនាក់ទំនងមួយចំនួនដោយស្វ័យប្រវត្តិទៅកាន់សារជាសំឡេង។ នាំចូលលេខទាំងនោះមកទីនេះដើម្បីរារាំងទាំងការហៅ និងការផ្ញើសារ។"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"នាំចូល"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"មើលលេខ"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"បន្ថែមលេខ"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ការរារាំងការហៅត្រូវបានបិទដំណើរការរយៈពេល 48 ម៉ោង"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"បានបិទដំណើរការពីព្រោះការហៅបន្ទាន់ត្រូវបានធ្វើឡើង"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"មិនធ្វើវិញ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ត្រូវបានទប់ស្កាត់រួចហើយ"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"ឈប់ទប់ស្កាត់លេខ"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"ព័ត៌មាន​លម្អិត​ទំនាក់ទំនង​សម្រាប់ <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"ការនាំចូលបានបរាជ័យ"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"នាំចូលលេខ"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"ដើម្បីស្វែងរកទំនាក់ទំនងរបស់អ្នក សូមបើកសិទ្ធិអនុញ្ញាតទំនាក់ទំនង។"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"បើក"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"លេខបានរារាំង"</string>
 </resources>
diff --git a/res/values-kn-rIN/strings.xml b/res/values-kn-rIN/strings.xml
index 7e41ef0..591fa1c 100644
--- a/res/values-kn-rIN/strings.xml
+++ b/res/values-kn-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"ಸಂಪರ್ಕಗಳು"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"ಸಂಪರ್ಕಗಳು"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"ಸಂಪರ್ಕ ವೀಕ್ಷಿಸಿ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"ಸಂಪರ್ಕ ಸಂಪಾದಿಸು"</string>
     <string name="contactsList" msgid="8661624236494819731">"ಸಂಪರ್ಕಗಳು"</string>
     <string name="shortcutContact" msgid="749243779392912958">"ಸಂಪರ್ಕ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ನೇರ ಡಯಲ್"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ಡೀಫಾಲ್ಟ್ ಹೊಂದಿಸಿ"</string>
     <string name="clear_default" msgid="7193185801596678067">"ಡೀಫಾಲ್ಟ್‌ ತೆರವುಗೊಳಿಸಿ"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"ಪಠ್ಯವನ್ನು ನಕಲಿಸಲಾಗಿದೆ"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ತಿರಸ್ಕರಿಸುವುದೇ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"ತ್ಯಜಿಸು"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"ನಿಮ್ಮ ಬದಲಾವಣೆಗಳನ್ನು ತ್ಯಜಿಸಿ ಸಂಪಾದನೆಯನ್ನು ನಿರ್ಗಮಿಸುವುದೇ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"ತ್ಯಜಿಸು"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"ಸಂಪಾದಿಸುತ್ತಿರಿ"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"ನನ್ನ ಪ್ರೊಫೈಲ್ ಹೊಂದಿಸು"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"ವ್ಯಕ್ತಿಯ ಹೆಸರನ್ನು ಟೈಪ್‌ ಮಾಡಿ"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> ನಿಂದ"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> ಅಳಿಸು"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> ಅಳಿಸು"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="USER_NAME">%s </xliff:g><xliff:g id="ACCOUNT_TYPE">%s </xliff:g> ಅವರಿಂದ ಫೋಟೋ ಗುರುತಿಸಲಾಗಿಲ್ಲ"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="USER_NAME">%s </xliff:g><xliff:g id="ACCOUNT_TYPE">%s </xliff:g> ಅವರಿಂದ ಫೋಟೋ ಗುರುತಿಸಲಾಗಿದೆ"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"ಅಜ್ಞಾತ ಖಾತೆಯಿಂದ ಫೋಟೋವನ್ನು ಗುರುತಿಸಲಾಗಿಲ್ಲ"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"ಅಜ್ಞಾತ ಖಾತೆಯಿಂದ ಫೋಟೋವನ್ನು ಗುರುತಿಸಲಾಗಿದೆ"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ಭಾಷೆಯ ಬದಲಾವಣೆಯನ್ನು ಪ್ರತಿಬಿಂಬಿಸಲು ಸಂಪರ್ಕ ಪಟ್ಟಿಯನ್ನು ಅಪ್‌ಡೇಟ್ ಮಾಡಲಾಗುತ್ತಿದೆ.\n\nದಯವಿಟ್ಟು ಕಾಯಿರಿ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"ನಿರ್ಬಂಧಿಸಲಾದ ಸಂಖ್ಯೆಗಳು"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ಈ ಸಂಖ್ಯೆಗಳಿಂದ ಕರೆಗಳು ಮತ್ತು ಪಠ್ಯ ಸಂದೇಶಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲಾಗುತ್ತದೆ."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸಿ"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"ಸಂಖ್ಯೆಯನ್ನು ನಿರ್ಬಂಧಿಸು"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"ಸಂ. ಸೇರಿಸಿ ಅಥವಾ ಸಂಪರ್ಕ ಹುಡುಕಿ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ಈ ಸಂಖ್ಯೆಯಿಂದ ಕರೆಗಳು ಮತ್ತು ಸಂದೇಶಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲಾಗುತ್ತದೆ."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> ನಿರ್ಬಂಧ ತೆಗೆಯುವುದೇ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ನಿರ್ಬಂಧ ತೆಗೆ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> ನಿರ್ಬಂಧಿಸುವುದೇ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ನಿರ್ಬಂಧಿಸು"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> ನಿರ್ಬಂಧ ತೆಗೆಯಲಾಗಿದೆ"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ಅಮಾನ್ಯವಾಗಿದೆ."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ಕರೆ ನಿರ್ಬಂಧಿಸುವಿಕೆ ತಾತ್ಕಾಲಿಕ ಆಫ್ ಮಾಡಲಾಗಿದೆ"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ನೀವು ಕಳೆದ 48 ಗಂಟೆಗಳಲ್ಲಿ ಈ ಫೋನ್‌ನಿಂದ ತುರ್ತು ಸೇವೆಗಳಿಗೆ ಸಂಪರ್ಕಿಸಿರುವ ಕಾರಣದಿಂದ ಕರೆ ನಿರ್ಬಂಧಿಸುವಿಕೆಯನ್ನು ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ. ಒಮ್ಮೆ 48 ಗಂಟೆಗಳ ಅವಧಿಯು ಮುಕ್ತಾಯಗೊಂಡ ನಂತರ ಅದನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಮರುಸಕ್ರಿಯಗೊಳಿಸಲಾಗುವುದು."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ಕೆಲವು ಸಂಪರ್ಕಗಳನ್ನು ಸ್ವಯಂಚಾಲಿತವಾಗಿ ಧ್ವನಿಮೇಲ್‌ಗೆ ಕಳುಹಿಸಲು ನೀವು ಈ ಹಿಂದೆ ಗುರುತಿಸಿರುವಿರಿ. ಕರೆಗಳು ಮತ್ತು ಪಠ್ಯ ಸಂದೇಶಗಳನ್ನು ನಿರ್ಬಂಧಿಸಲು ಆ ಸಂಖ್ಯೆಗಳನ್ನು ಆಮದು ಮಾಡಿ."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"ಆಮದು ಮಾಡಿ"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"ಸಂಖ್ಯೆಗಳನ್ನು ವೀಕ್ಷಿಸಿ"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ಸಂಖ್ಯೆಯನ್ನು ಸೇರಿಸಿ"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ಕರೆ ನಿರ್ಬಂಧಿಸುವಿಕೆ 48 ಗಂಟೆಗಳವರೆಗೆ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"ತುರ್ತು ಕರೆಯನ್ನು ಮಾಡಿರುವ ಕಾರಣದಿಂದ ನಿಷ್ಕ್ರಿಯಗೊಳಿಸಲಾಗಿದೆ."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ರದ್ದುಮಾಡು"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ಈಗಾಗಲೇ ನಿರ್ಬಂಧಿಸಲಾಗಿದೆ."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"ಸಂಖ್ಯೆಯನ್ನು ಅನಿರ್ಬಂಧಿಸು"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> ಗೆ ಸಂಪರ್ಕ ವಿವರಗಳು"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"ಆಮದು ವಿಫಲವಾಗಿದೆ"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"ಸಂಖ್ಯೆಗಳನ್ನು ಆಮದು ಮಾಡಿ"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"ನಿಮ್ಮ ಸಂಪರ್ಕಗಳನ್ನು ಹುಡುಕಲು, ಸಂಪರ್ಕಗಳ ಅನುಮತಿಗಳನ್ನು ಆನ್ ಮಾಡಿ."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ಆನ್ ಮಾಡು"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"ನಿರ್ಬಂಧಿಸಲಾದ ಸಂಖ್ಯೆಗಳು"</string>
 </resources>
diff --git a/res/values-ko/donottranslate_config.xml b/res/values-ko/donottranslate_config.xml
deleted file mode 100644
index e52f490..0000000
--- a/res/values-ko/donottranslate_config.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2010, 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>
-    <!-- If true, an option is shown in Display Options UI to choose a sort order -->
-    <bool name="config_sort_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_sort_order_primary">false</bool>
-
-    <!-- If true, an option is shown in Display Options UI to choose a name display order -->
-    <bool name="config_display_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_display_order_primary">false</bool>
-
-    <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
-    <bool name="config_editor_field_order_primary">false</bool>
-</resources>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index d25363b..3624837 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"주소록"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"주소록"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"연락처 보기"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"연락처 수정"</string>
     <string name="contactsList" msgid="8661624236494819731">"주소록"</string>
     <string name="shortcutContact" msgid="749243779392912958">"연락처"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"바로 전화 걸기"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"기본으로 설정"</string>
     <string name="clear_default" msgid="7193185801596678067">"기본 설정 지우기"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"텍스트 복사됨"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"변경사항을 삭제하시겠습니까?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"취소"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"변경사항을 취소하고 수정을 중단하시겠습니까?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"취소"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"계속 수정"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"내 프로필 설정"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"이름 입력"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"모든 사진"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"사진 선택"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"저장된 계정: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> 삭제"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> 삭제"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>의 사진 선택 안됨"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>의 사진 선택됨"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"알 수 없는 계정의 사진이 선택되지 않음"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"알 수 없는 계정의 사진이 선택됨"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"변경된 언어를 반영하도록 연락처 목록을 업데이트하는 중입니다.\n\n잠시 기다려 주세요."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"차단된 번호"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"이러한 번호로부터 수신되는 전화와 문자가 차단됩니다."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"번호 추가"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"번호 차단"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"번호 추가 또는 연락처 검색"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"이 번호로부터 수신되는 전화와 문자가 차단됩니다."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g>번을 차단 해제할까요?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"차단 해제"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g>번을 차단할까요?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"차단"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> 차단됨"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> 차단 해제됨"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g>번은 잘못된 번호입니다."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"통화 차단 기능이 일시적으로 중지됨"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"지난 48시간 이내에 이 휴대전화를 사용해 응급 서비스에 연락했으므로 통화 차단 기능이 중지되었습니다. 48시간이 지나면 통화 차단 기능이 자동으로 다시 사용 설정됩니다."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"이전에 일부 연락처를 자동으로 음성사서함으로 보내도록 표시했습니다. 전화와 문자를 모두 차단하려면 이러한 번호를 여기로 가져오세요."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"가져오기"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"개수 보기"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"번호 추가"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"통화 차단이 48시간 동안 중지됨"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"긴급 통화를 사용했기 때문에 중지되었습니다."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"실행취소"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g>번은 이미 차단되었습니다."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"번호 차단 해제"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>의 연락처 세부정보"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"가져오지 못했습니다."</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"번호 가져오기"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"주소록을 검색하려면 주소록 권한을 사용하도록 설정하세요."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"사용"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"차단된 번호"</string>
 </resources>
diff --git a/res/values-ky-rKG/strings.xml b/res/values-ky-rKG/strings.xml
index 080e288..594d65a 100644
--- a/res/values-ky-rKG/strings.xml
+++ b/res/values-ky-rKG/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Байланыштар"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Байланыштар"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Байланышты көрүү"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Байланышты түзөтүү"</string>
     <!-- no translation found for contactsList (8661624236494819731) -->
     <skip />
     <!-- no translation found for shortcutContact (749243779392912958) -->
@@ -297,8 +299,9 @@
     <string name="clear_default" msgid="7193185801596678067">"Негизгини тазалоо"</string>
     <!-- no translation found for toast_text_copied (5143776250008541719) -->
     <skip />
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Өзгөртүүлөр жокко чыгарылсынбы?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Жокко чыгаруу"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Өзгөртүүлөр жарактан чыгарылып, түзөтүү жабылсынбы?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Жарактан чыгаруу"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Түзөтө берүү"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Профайлымды тууралоо"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Кишинин атын киргизиңиз"</string>
@@ -391,8 +394,42 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Бардык сүрөттөр"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Сүрөт тандаңыз"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> дегенден"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> жок кылуу"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> жок кылуу"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> дегенден сүрөт белгиленген жк"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> дегенден сүрөт белгиленди"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Белгисиз каттоо эсебинен келген сүрөт тандалган жок"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Белгисиз каттоо эсебинен келген сүрөт тандалды"</string>
+    <!-- no translation found for locale_change_in_progress (1124266507671178413) -->
     <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Бөгөттөлгөн номерлер"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Бул номерлерден келген чалуулар менен SMS билдирүүлөр бөгөттөлөт."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Номер кошуу"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Номерди бөгөттөө"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Номер кошуңуз же байлнш издңз"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Бул номерден келген чалуулар менен SMS билдирүүлөр бөгөттөлөт."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгөттөн чыгарылсынбы?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"БӨГӨТТӨН ЧЫГАРУУ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгөттөлсүнбү?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БӨГӨТТӨӨ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгөттөлдү"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> бөгөттөн чыгарылды"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> - жараксыз."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Чалууну бөгөттөө убактылуу өчүрүлгөн"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Акыркы 48 саат ичинде бул телефондон өзгөчө кырдаал кызматына байланышкандыктан чалууну бөгөттөө өчүрүлдү. 48 сааттык мөөнөтү аяктагандан кийин ал автоматтык түрдө кайра иштетилет."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Мурда айрым байланыштарга автоматтык түрдө үн почтасы жөнөтүлгүдөй кылып белгилегенсиз. Чалуулар менен SMS билдирүүлөрдү бөгөттөө үчүн ошол номерлерди импорттоңуз."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Импорттоо"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Номерлерди көрүү"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Номер кошуу"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Чалууну бөгөттөө 48 саатка өчүрүлгөн"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Шашылыш чалуу аткарылгандыктан өчүрүлгөн."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"КАЙТАРУУ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> мурунтан эле бөгөттөлгөн."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Номерди бөгөттөн чыгаруу"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> байланыш маалыматтары"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Импорттолбой калды"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Номерлерди импорттоо"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Байланыштарыңызды издөө үчүн, Байланыштарга уруксатты күйгүзүңүз."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Күйгүзүү"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Бөгөттөлгөн номерлер"</string>
 </resources>
diff --git a/res/values-lo-rLA/strings.xml b/res/values-lo-rLA/strings.xml
index f5425dc..4ab10b1 100644
--- a/res/values-lo-rLA/strings.xml
+++ b/res/values-lo-rLA/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"ລາຍຊື່ຜູ່ຕິດຕໍ່"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"ລາຍຊື່ຜູ່ຕິດຕໍ່"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"ເບິ່ງລາຍຊື່ຜູ້ຕິດຕໍ່"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"ແກ້ໄຂລາຍຊື່ຜູ້ຕິດຕໍ່"</string>
     <string name="contactsList" msgid="8661624236494819731">"ລາຍຊື່ຜູ່ຕິດຕໍ່"</string>
     <string name="shortcutContact" msgid="749243779392912958">"ລາຍຊື່ຜູ່ຕິດຕໍ່"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ໂທຫາໂດຍກົງ"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ຕັ້ງຄ່າເລີ່ມຕົ້ນ"</string>
     <string name="clear_default" msgid="7193185801596678067">"ລຶບຄ່າເລີ່ມຕົ້ນ"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"ສຳເນົາຂໍ້ຄວາມແລ້ວ"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ຍົກເລີກການແກ້ໄຂຂອງທ່ານ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"ລຶບ​ຖິ້​ມ"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"ຍົກເລີກການປ່ຽນແປງຂອງທ່ານ ແລະ ອອກຈາກການແກ້ໄຂບໍ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"ຍົກເລີກ"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"ສືບຕໍ່ແກ້ໄຂ"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"ຕັ້ງຄ່າໂປຣໄຟລ໌ຂອງຂ້ອຍ"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"ພິມຊື່ຄົນ"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"ຮູບທັງໝົດ"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"ເລືອກ​ຮູບ"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"ຈາກ <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"ລຶບ <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"ລຶບ <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"ຮູບຖ່າຍ​ຈາກ <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ບໍ່​ໄດ້​ຮັບ​ການກວດ"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"ຮູບຖ່າຍ​ຈາກ <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ໄດ້​ຮັບ​ການກວດ​ແລ້ວ"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"ບໍ່ໄດ້ໝາຍເອົາຮູບຖ່າຍຈາກບັນຊີທີ່ບໍ່ຮູ້ຈັກແລ້ວ"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"ໝາຍເອົາຮູບຖ່າຍຈາກບັນຊີທີ່ບໍ່ຮູ້ຈັກແລ້ວ"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ລາຍຊື່ຜູ່ຕິດຕໍ່ກຳລັງຖືກອັບເດດ ຕາມການປ່ຽນແປງຂອງພາສາ.\n\nກະລຸນາລໍຖ້າ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"ເບີໂທທີ່ບລັອກໄວ້"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ການໂທ ແລະ ຂໍ້ຄວາມຈາກເບີເຫຼົ່ານີ້ຈະຖືກບລັອກໄວ້."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ເພີ່ມໝາຍເລກ"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"ບ​ລັອກ​ໝາຍ​ເລກ"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"ເພີ່ມ​ເບີ​ໂທ​ລະ​ສັບ ຫຼື ຊອກ​ຫາ​ລາຍ​ຊື່​ຕິດ​ຕໍ່"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ການໂທ ແລະ ຂໍ້ຄວາມຈາກເບີນີ້ຈະຖືກບລັອກໄວ້."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"ປົດ​ບ​ລັອກ <xliff:g id="NUMBER">%1$s</xliff:g> ບ​ໍ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"​ປົດ​ບລັອກ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"ບ​ລັອກ <xliff:g id="NUMBER">%1$s</xliff:g> ບໍ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ບລັອກ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ຖືກບ​ລັອກໄວ້​ແລ້ວ"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> ຖືກບ​ລັອກໄວ້​ແລ້ວ"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ບໍ່ຖືກຕ້ອງ."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ການບ​ລັອກ​ສາຍ​ໂທ​ປິດ​ຊົ່ວ​ຄາວ"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ການບ​ລັອກ​ສາຍ​ໂທ​ຖືກ​ປິດ​ໃຊ້​ງານ​ແລ້ວ ເພາະ​ວ່າ​ທ່ານ​ໄດ້​ຕິດ​ຕໍ່​ຫາ​ຝ່າຍ​ບໍ​ລິ​ການ​ສຸກ​ເສີນ​ຈາກ​ໂທ​ລະ​ສັບ​ນີ້​ພາຍ​ໃນ 48 ຊົ່ວ​ໂມງ​ສຸດ​ທ້າຍ. ມັນ​ຈະ​ຖືກ​ເປີດ​ໃຊ້​ງານ​ອີກ​ໂດຍ​ອັດ​ຕະ​ໂນ​ມັດ ເມື່ອ​ໝົດ​ໄລ​ຍະ 48 ຊົ່ວ​ໂມງ​ໄປ​ແລ້ວ."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ກ່ອນໜ້ານີ້ທ່ານໄດ້ໝາຍບາງລາຍຊື່ຜູ້ຕິດຕໍ່ໃຫ້ຖືກສົ່ງຫາຂໍ້ຄວາມສຽງໂດຍອັດຕະໂນມັດ. ນຳເຂົ້າເບີໂທເຫຼົ່ານັ້ນທີ່ນີ້ເພື່ອບລັອກທັງການໂທ ແລະ ຂໍ້ຄວາມ."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"ນໍາເຂົ້າ"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"ເບິ່ງ​ຕົວ​ເລກ"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ເພີ່ມໝາຍເລກ"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ການບ​ລັອກ​ສາຍ​ໂທ​ຖືກ​ປິດ​ໃຊ້​ງານ​ແລ້ວ​ເປັນ​ເວ​ລາ 48 ຊົ່​ວ​ໂມງ"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"ປິດ​ໃຊ້​ງານ​ແລ້ວ ເພາະ​ວ່າ​ໄດ້​ມີ​ການ​ໂທ​ສຸກ​ເສີນ."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ບໍ່​ເຮັດ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ຖືກ​ບ​ລັອກ​ແລ້ວ."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"ປົດ​ບ​ລັອກ​ໝາຍ​ເລກ"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"ລາຍລະອຽດ​ລາຍຊື່​ຜູ່ຕິດຕໍ່​ສຳລັບ <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"ນຳ​ເຂົ້າ​ລົ້ມ​ເຫລວ"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"ນຳ​ຕົວ​ເລກ​ເຂົ້າ"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"ເພື່ອຄົ້ນຫາລາຍາຊື່ຂອງທ່ານ, ໃຫ້ເປີດການອະນຸຍາດລາຍຊື່."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ເປີດ​"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"ເບີໂທບລັອກໄວ້"</string>
 </resources>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index 0dfdb62..6049529 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktai"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktai"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Žiūrėti kontaktą"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Redaguoti kontaktą"</string>
     <string name="contactsList" msgid="8661624236494819731">"Adresinė"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Adresatas"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Tiesioginis numerio rinkimas"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Nustatyti numatytuosius nustatymus"</string>
     <string name="clear_default" msgid="7193185801596678067">"Išvalyti numatytuosius nustatymus"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Tekstas nukopijuotas"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Atmesti pakeitimus?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Atmesti"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Atmesti pakeitimus ir baigti redagavimą?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Atmesti"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Toliau redaguoti"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Nustatyti mano profilį"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Įveskite asmens vardą ir (arba) pavardę"</string>
@@ -340,8 +343,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Visos nuotraukos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Pasirinkti nuotrauką"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Iš <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Ištrinti <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Ištrinti <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Nuotrauka iš <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> nepažymėta"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Nuotrauka iš <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> pažymėta"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Nepažymėta nuotrauka iš nežinomos paskyros"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Pažymėta nuotrauka iš nežinomos paskyros"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Adresatų sąrašas atnaujinamas, kad būtų pakeista kalba.\n\nPalaukite..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Užblokuoti numeriai"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Skambučiai ir teksto pranešimai iš šių numerių bus užblokuoti."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Pridėti numerį"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokuoti numerį"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Prid. nr. arba iešk. kontaktų"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Skambučiai ir teksto pranešimai iš šio numerio bus užblokuoti."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Panaikinti numerio <xliff:g id="NUMBER">%1$s</xliff:g> blokavimą?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"PANAIKINTI BLOKAVIMĄ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blokuoti numerį <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKUOTI"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> užblokuotas"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Panaikintas <xliff:g id="NUMBER">%1$s</xliff:g> blokavimas"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> yra netinkamas numeris."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Skamb. blokavimo funkcija laikinai išj."</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Skambučių blokavimo funkcija buvo išjungta, nes iš šio telefono buvote susisiekę su pagalbos tarnybomis per pastarąsias 48 val. Ši funkcija bus automatiškai įgalinta iš naujo, kai 48 val. laikotarpis pasibaigs."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anksčiau buvote pažymėję, kad kai kurie kontaktai būtų automatiškai nusiųsti į balso paštą. Importuokite šiuos numerius čia, kad užblokuotumėte skambučius ir teksto pranešimus."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importuoti"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Žr. skaičius"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Pridėti numerį"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Skambučių blokavimas išjungtas 48 val."</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Išjungta, nes skambinta pagalbos numeriu."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANULIUOTI"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> jau užblokuotas."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Panaikinti numerio blokavimą"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Išsami kontaktinė informacija: <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importuoti nepavyko"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importuoti numerius"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kad galėtumėte ieškoti kontaktų, įjunkite Kontaktų leidimus."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Įjungti"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Užblokuoti numeriai"</string>
 </resources>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index ab6b9fe..68e14d5 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktpersonas"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktpersonas"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Kontaktpersonas datu skatīšana"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Kontaktpersonas datu rediģēšana"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontaktpersonas"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontaktpersona"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Tiešais zvans"</string>
@@ -231,8 +233,9 @@
     <string name="set_default" msgid="4417505153468300351">"Iestatīt kā noklusējumu"</string>
     <string name="clear_default" msgid="7193185801596678067">"Notīrīt noklusējuma iestatījumus"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Teksts ir nokopēts"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Vai atmest veiktās izmaiņas?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Atmest"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Vai atmest veiktās izmaiņas un beigt rediģēšanu?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Atmest"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Turpināt rediģēšanu"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> — <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Iestatīt savu profilu"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Rakstiet personas vārdu."</string>
@@ -329,8 +332,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Visi fotoattēli"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Fotoattēla izvēle"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"No: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Dzēst: <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Dzēst: <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotoattēls no <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> nav atlasīts."</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotoattēls no <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ir atlasīts."</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Nav atzīmēts fotoattēls no nezināma konta"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Atzīmēts fotoattēls no nezināma konta"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaktpersonu saraksts tiek atjaunināts, lai atainotu valodas maiņu.\n\nLūdzu, uzgaidiet..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Bloķētie numuri"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"No šiem numuriem saņemtie zvani un ziņojumi tiks bloķēti."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Pievienot numuru"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloķēt numuru"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Pievienojiet numuru vai meklējiet kontaktpersonas"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"No šī numura saņemtie zvani un ziņojumi tiks bloķēti."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Vai atbloķēt numuru <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ATBLOĶĒT"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Vai bloķēt numuru <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOĶĒT"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> bloķēts"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> atbloķēts"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> nav derīgs."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Zvanu bloķēšana ir īslaicīgi izslēgta"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Zvanu bloķēšana ir atspējota, jo pēdējo 48 stundu laikā jūs sazinājāties ar ārkārtas palīdzības dienestiem, izmantojot šo tālruni. Zvanu bloķēšana tiks automātiski iespējota, tiklīdz beigsies 48 stundu periods."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Jūs iepriekš atzīmējāt dažas kontaktpersonas, kuras automātiski jānovirza uz balss pastu. Importējiet šo kontaktpersonu tālruņa numurus šeit, lai bloķētu no tiem saņemtos zvanus un ziņojumus."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importēt"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Skatīt numurus"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Pievienot numuru"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Zvanu bloķēšana atspējota uz 48 stundām"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Zvanu bloķēšana atspējota, jo tika veikts ārkārtas zvans."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ATSAUKT"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> jau ir bloķēts."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Atbloķēt numuru"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontaktpersonas informācija: <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importēšana neizdevās"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importēt numurus"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Lai meklētu savas kontaktpersonas, ieslēdziet atļauju Kontaktpersonas."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Ieslēgt"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Bloķētie numuri"</string>
 </resources>
diff --git a/res/values-mk-rMK/strings.xml b/res/values-mk-rMK/strings.xml
index 23309aa..58a107e 100644
--- a/res/values-mk-rMK/strings.xml
+++ b/res/values-mk-rMK/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Контакти"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Контакти"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Прикажи го контактот"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Уреди го контактот"</string>
     <string name="contactsList" msgid="8661624236494819731">"Контакти"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Контакт"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Директно бирање"</string>
@@ -101,7 +103,7 @@
     <string name="photoPickerNotFoundText" product="tablet" msgid="6247290728908599701">"Не се достапни слики на таблетот."</string>
     <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Не се достапни слики на телефонот."</string>
     <string name="attach_photo_dialog_title" msgid="5599827035558557169">"Фотографија за контакт"</string>
-    <string name="customLabelPickerTitle" msgid="1081475101983255212">"Прилагоди име на етикета"</string>
+    <string name="customLabelPickerTitle" msgid="1081475101983255212">"Приспособи име на етикета"</string>
     <string name="send_to_voicemail_checkbox" msgid="9001686764070676353">"Испрати повици директно на говорна пошта"</string>
     <string name="removePhoto" msgid="4898105274130284565">"Отстрани фотографија"</string>
     <string name="noContacts" msgid="4955659076981974652">"Нема контакти"</string>
@@ -188,8 +190,8 @@
     <string name="add_to_my_contacts" msgid="1068274916793627723">"Додај во Мои контакти"</string>
     <string name="contact_directory_description" msgid="683398073603909119">"Адресар <xliff:g id="TYPE">%1$s</xliff:g>"</string>
     <string name="list_filter_custom" msgid="8910173055702057002">"Прилагодено"</string>
-    <string name="activity_title_settings" msgid="5464130076132770781">"Подесувања"</string>
-    <string name="menu_settings" msgid="377929915873428211">"Подесувања"</string>
+    <string name="activity_title_settings" msgid="5464130076132770781">"Поставки"</string>
+    <string name="menu_settings" msgid="377929915873428211">"Поставки"</string>
     <string name="menu_help" msgid="1680178646764069976">"Помош и повратни информации"</string>
     <string name="preference_displayOptions" msgid="1341720270148252393">"Опции за екран"</string>
     <string name="organization_company_and_title" msgid="6718207751363732025">"<xliff:g id="COMPANY_0">%2$s</xliff:g>, <xliff:g id="COMPANY_1">%1$s</xliff:g>"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Подеси стандарден метод"</string>
     <string name="clear_default" msgid="7193185801596678067">"Исчисти стандарден метод"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Текстот е копиран"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Отфрли ги своите промени?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Отфрли"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Дали да се отфрлат промените и да се прекине уредувањето?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Отфрли"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Продолжи со уредување"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Подеси мој профил"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Впиши име на лице"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Сите фотографии"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Избери фотографија"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Од <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Избриши <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Избриши <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Фотографијата од <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>не е избрана"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Фотографијата од <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>е избрана"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Не е избрана фотографија од непозната сметка"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Избрана е фотографија од непозната сметка"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Списокот со контакти се ажурира за да ја одрази промената на јазикот.\n\nПочекајте..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Блокирани броеви"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Повиците и пораките од овие броеви ќе се блокираат."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Додај број"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Блокирај го бројот"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Додајте број или побарајте контакти"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Повиците и пораките од овој број ќе се блокираат."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Деблокирај го <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ДЕБЛОКИРАЈ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Блокирај го <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БЛОКИРАЈ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> е блокиран"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> е деблокиран"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> не е важечки."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Блокирањето повик е привремено исклучено"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Блокирањето повици е исклучено бидејќи ја контактиравте службата за итни случаи од телефонов во изминатите 48 часа. Повторно ќе се овозможи автоматски откако ќе истече периодот од 48 часа."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Претходно означивте неколку контакти да се праќаат автоматски кон говорната пошта. Увезете ги тие броеви тука за да се блокираат повиците и пораките."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Увези"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Прикажи броеви"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Додај број"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Блокирањето на повикот е оневозможено 48 часа"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Оневозможено е затоа што беше направен итен повик."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ВРАТИ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> веќе е блокиран."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Деблокирај го бројот"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Детали за контакт за <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Увоз не успеа"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Увези броеви"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"За да ги пребарувате контактите, вклучете ги дозволите за контакти."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Вклучи"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Блокирани броеви"</string>
 </resources>
diff --git a/res/values-ml-rIN/strings.xml b/res/values-ml-rIN/strings.xml
index 4709673..f7c0c88 100644
--- a/res/values-ml-rIN/strings.xml
+++ b/res/values-ml-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"വിലാസങ്ങൾ"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"വിലാസങ്ങൾ"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"കോൺടാക്റ്റ് കാണുക"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"കോൺടാ‌ക്‌റ്റ് എഡിറ്റുചെയ്യുക"</string>
     <string name="contactsList" msgid="8661624236494819731">"വിലാസങ്ങൾ"</string>
     <string name="shortcutContact" msgid="749243779392912958">"കോൺടാക്റ്റ്"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"നേരിട്ടുള്ള ഡയൽ"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"സ്ഥിരമായി സജ്ജമാക്കുക"</string>
     <string name="clear_default" msgid="7193185801596678067">"സ്ഥിരമായത് മായ്‌ക്കുക"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"വാചകം പകർത്തി"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"നിങ്ങളുടെ മാറ്റങ്ങൾ നിരസിക്കണോ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"തള്ളിക്കളയുക"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"നിങ്ങളുടെ മാറ്റങ്ങൾ തള്ളിക്കളയുകയും എഡിറ്റുചെയ്യൽ ഉപേക്ഷിക്കുകയും ചെയ്യണോ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"തള്ളിക്കളയുക"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"എഡിറ്റുചെയ്യുന്നത് തുടരുക"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"പ്രൊഫൈൽ സജ്ജമാക്കൂ"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"വ്യക്തിയുടെ പേര് ടൈപ്പുചെയ്യുക"</string>
@@ -246,7 +249,7 @@
     <string name="add_new_account" msgid="5748627740680940264">"പുതിയ അക്കൗണ്ട് ചേർക്കുക"</string>
     <string name="menu_export_database" msgid="2659719297530170820">"ഡാറ്റാബേസ് ഫയലുകൾ എക്‌സ്‌പോർട്ടുചെയ്യുക"</string>
     <string name="action_menu_add_new_contact_button" msgid="3180222523336380017">"പുതിയവ ചേർക്കൂ"</string>
-    <string name="expanding_entry_card_view_see_more" msgid="3779194067124758079">"കൂടുതല്‍ കാണുക"</string>
+    <string name="expanding_entry_card_view_see_more" msgid="3779194067124758079">"കൂടുതൽ‍ കാണുക"</string>
     <string name="expanding_entry_card_view_see_less" msgid="5344160551629714168">"കുറച്ച് കാണുക"</string>
     <string name="expanding_entry_card_view_see_all" msgid="3845258737661412627">"എല്ലാം കാണുക"</string>
     <string name="recent_card_title" msgid="8982782042698001695">"പുതിയത്"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"എല്ലാ ഫോട്ടോകളും"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"ഫോട്ടോ തിരഞ്ഞെടുക്കുക"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> എന്നതിൽ നിന്ന്"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> ഇല്ലാതാക്കുക"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> ഇല്ലാതാക്കുക"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> എന്നതിൽ നിന്നുള്ള ഫോട്ടോ ചെക്കുചെയ്തില്ല"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> എന്നതിൽ നിന്നുള്ള ഫോട്ടോ ചെക്കുചെയ്തു"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"തിരിച്ചറിയാനാകാത്ത അക്കൗണ്ടിൽ നിന്നുള്ള ഫോട്ടോ തിരഞ്ഞെടുത്തിട്ടില്ല"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"തിരിച്ചറിയാനാകാത്ത അക്കൗണ്ടിൽ നിന്നുള്ള ഫോട്ടോ തിരഞ്ഞെടുത്തു"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ഭാഷാ മാറ്റം പ്രതിഫലിപ്പിക്കുന്നതിന് കോൺടാക്റ്റ് ലിസ്റ്റ് അപ്‌ഡേറ്റ് ചെയ്തുകൊണ്ടിരിക്കുന്നു.\n\nകാക്കുക..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"ബ്ലോക്കുചെയ്ത നമ്പറുകൾ"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ഈ കമ്പറുകളിൽ നിന്നുള്ള കോളുകളും ടെക്സ്റ്റുകളും ബ്ലോക്കുചെയ്യും."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"നമ്പർ ചേർക്കുക"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"നമ്പർ ബ്ലോക്കുചെയ്യുക"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"നമ്പർ ചേർക്കുക അല്ലെങ്കിൽ കോൺടാക്റ്റുകൾ തിരയുക"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ഈ നമ്പറിൽ നിന്നുള്ള കോളുകളും ടെക്‌സ്റ്റും ബ്ലോക്കുചെയ്യും,"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> അൺബ്ലോക്കുചെയ്യണോ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"അൺബ്ലോക്കുചെയ്യുക"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> ബ്ലോക്കുചെയ്യണോ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ബ്ലോക്കുചെയ്യുക"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ബ്ലോക്കുചെയ്തു"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> അൺബ്ലോക്കുചെയ്തു"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> അസാധുവാണ്."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"കോൾ ബ്ലോക്കുചെയ്യൽ താൽക്കാലികമായി ഓഫാണ്"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"കഴിഞ്ഞ 48 മണിക്കൂറിനുള്ളിൽ നിങ്ങൾ ഈ ഫോണിൽ നിന്ന് അടിയന്തിര സേവനങ്ങളുമായി ബന്ധപ്പെട്ടതിനാൽ കോൾ ബ്ലോക്കുചെയ്യൽ പ്രവർത്തനരഹിതമാക്കി. 48 മണിക്കൂർ സമയപരിധി കഴിഞ്ഞയുടൻ ഇത് സ്വയമേവ പ്രവർത്തനക്ഷമമാക്കപ്പെടും."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ചില കോൺടാക്റ്റുകളെ, വോയ്സ്‌മെയിലിലേക്ക് സ്വയമേവ അയയ്ക്കുന്ന തരത്തിൽ, നിങ്ങൾ മുമ്പ് അടയാളപ്പെടുത്തി. ഇവരിൽ നിന്നുള്ള കോളുകളും ടെക്‌സ്റ്റുകളും ബ്ലോക്കുചെയ്യുന്നതിന് ഇവരുടെ നമ്പറുകൾ ഇവിടെ ഇമ്പോർട്ടുചെയ്യുക."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"ഇമ്പോർട്ടുചെയ്യുക"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"നമ്പറുകൾ കാണുക"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"നമ്പർ ചേർക്കുക"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"48 മണിക്കൂർ നേരത്തേക്ക് കോൾ ബ്ലോക്കുചെയ്യൽ പ്രവർത്തനരഹിതമാക്കി"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"എമർജൻസി കോൾ നടത്തിയതിനാൽ പ്രവർത്തനരഹിതമാക്കി."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"പഴയപടിയാക്കുക"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"ഇതിനകം തന്നെ <xliff:g id="NUMBER">%1$s</xliff:g> ബ്ലോക്കുചെയ്തിരിക്കുന്നു"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"നമ്പർ അൺബ്ലോക്കുചെയ്യുക"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> എന്നതിന്റെ കോൺ‌ടാക്റ്റ് വിശദാംശങ്ങൾ"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"ഇമ്പോർട്ടുചെയ്യൽ പരാജയപ്പെട്ടു"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"നമ്പറുകൾ ഇമ്പോർട്ടുചെയ്യുക"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"നിങ്ങളുടെ കോൺടാക്റ്റുകൾ തിരയുന്നതിന് കോൺടാക്റ്റുകൾക്കുള്ള അനുമതികൾ ഓണാക്കുക."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ഓണാക്കുക"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"ബ്ലോക്കുചെയ്ത നമ്പറുകൾ"</string>
 </resources>
diff --git a/res/values-mn-rMN/strings.xml b/res/values-mn-rMN/strings.xml
index 634a9a3..32848bb 100644
--- a/res/values-mn-rMN/strings.xml
+++ b/res/values-mn-rMN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Харилцагчид"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Харилцагчид"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Харилцагчийн хаягийг харах"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Харилцагчийн хаягийг засварлах"</string>
     <string name="contactsList" msgid="8661624236494819731">"Харилцагчид"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Харилцагч"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Шууд залгах"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Үндсэн болгох"</string>
     <string name="clear_default" msgid="7193185801596678067">"Үндсэнээс хасах"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Текст хуулагдав"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Өөрчлөлтүүдээ цуцлах уу?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Устгах"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Таны өөрчлөлтийн устгал, засварыг болих уу?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Устгах"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Үргэлжлүүлэн засах"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Миний профайлийн тохиргоо"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Хүний нэрийг бичнэ үү"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Бүх зураг"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Зураг сонгох"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Илгээгч: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>-г устгах"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g>-г устгах"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>-н зургийг сонгоогүй"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>-н зургийг сонгосон"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Үл мэдэгдэх бүртгэлийн зургийг сонгоогүй"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Үл мэдэгдэх бүртгэлийн зургийг сонгосон"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Хэлний өөрчлөлтийг тусгахын тулд харилцагчдын жагсаалтыг шинэчилж байна.\n\nТүр хүлээнэ үү..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Блоклосон дугаар"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Эдгээр дугаараас ирэх дуудлага, зурвасыг блоклох болно."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Дугаар нэмэх"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Дугаар блоклох"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Дугаар нэмэх болон харилцагч хайх"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Энэ дугаараас ирэх дуудлага, зурвасыг блоклох болно."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g>-г блокоос гаргах уу?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"БЛОКООС ГАРГАХ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g>-г блоклох уу?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БЛОКЛОХ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g>-г блоклосон"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g>-г блокоос гаргасан"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> хүчингүй байна."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Дуудлага блоклох тохиргоог түр хугацаагаар унтраасан"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Та сүүлийн 48 цагийн дотор энэ утсаар тусламжийн дуудлага хийсэн тул дуудлага блоклох тохиргоог идэвхгүй болгосон. Энэ тохиргоо нь 48 цагийн хугацаа дуусахад автоматаар идэвхэжнэ."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Та зарим харилцагчдын дуудлагыг автоматаар дуут шууданд илгээхээр тохируулсан. Тэднээс ирэх дуудлага, зурвасыг блоклохын тулд дугаарыг нь энд импортолно уу."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Импортлох"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Дугаар харах"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Дугаар нэмэх"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Дуудлага блоклохыг 48 цагийн турш идэвхгүй болгосон."</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Яаралтай дуудлага хийсэн тул идэвхгүй болгосон."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"БУЦААХ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g>-г аль хэдийн блоклосон байна."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Дугаар блокноос гаргах"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>-н харилцагчийн мэдээлэл"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Импортолж чадсангүй"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Импортын тоо"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Харилцагчаа хайхын тулд, Харилцагчийн жагсаалтын зөвшөөрлийг идэвхжүүлнэ үү."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Идэвхжүүлэх"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Блоклосон дугаар"</string>
 </resources>
diff --git a/res/values-mr-rIN/strings.xml b/res/values-mr-rIN/strings.xml
index 698ec5b..945e351 100644
--- a/res/values-mr-rIN/strings.xml
+++ b/res/values-mr-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"संपर्क"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"संपर्क"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"संपर्क पहा"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"संपर्क संपादित करा"</string>
     <string name="contactsList" msgid="8661624236494819731">"संपर्क"</string>
     <string name="shortcutContact" msgid="749243779392912958">"संपर्क"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"थेट डायल करा"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"डीफॉल्ट म्हणून सेट करा"</string>
     <string name="clear_default" msgid="7193185801596678067">"डीफॉल्ट साफ करा"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"मजकूर कॉपी केला"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"आपले बदल टाकून द्यायचे?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"टाकून द्या"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"आपले बदल टाकून देऊन संपादन सोडायचे?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"टाकून द्या"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"संपादन करणे सुरु ठेवा"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"माझे प्रोफाईल सेट करा"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"व्‍यक्तीचे नाव टाईप करा"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> कडील"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> हटवा"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> हटवा"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>कडील फोटो चेक केला नाही"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>कडील फोटो चेक केला"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"अज्ञात खात्यामधील फोटो चेक केला नाही"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"अज्ञात खात्यामधील फोटो चेक केला"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"भाषेचे बदल प्रतिबिंबित करण्यासाठी संपर्क सूची अद्यतनित केली जात आहे. \n\nकृपया प्रतीक्षा करा..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"अवरोधित केलेले नंबर"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"या नंबरवरील कॉल आणि मजकूर अवरोधित केले जातील."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"नंबर जोडा"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"नंबर अवरोधित करा"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"नंबर जोडा किंवा संपर्क शोधा"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"या नंबरवरील कॉल आणि मजकूर अवरोधित केले जातील."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> ला अनावरोधित करायचे?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"अनावरोधित करा"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> अवरोधित करायचा?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"अवरोधित करा"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> अवरोधित केला"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> अनावरोधित केला"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> अवैध आहे."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"कॉल अवरोधित करणे तात्पुरते बंद"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"आपण मागील 48 तासात या फोनवरून आणीबाणी सेवांशी संपर्क साधला असल्याने कॉल अवरोधित करणे अक्षम केले गेले आहे. एकदा 48 तासांचा कालावधी कालबाह्य झाला की ते स्वयंचलितपणे पुन्हा सक्षम केले जाईल."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"आपण पूर्वी काही संपर्कांना व्हॉइसमेलकडे स्वयंचलितपणे पाठविले जाण्यासाठी चिन्हांकित केले. कॉल आणि मजकूर दोन्हीना अवरोधित करण्यासाठी ते नंबर येथे आयात करा."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"आयात करा"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"नंबर पहा"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"नंबर जोडा"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"कॉल अवरोधित करणे 48 तासांसाठी अक्षम केले"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"एक आणीबाणीचा कॉल केल्‍याने अक्षम केले."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"पूर्ववत करा"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> आधीच अवरोधित केलेला आहे."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"नंबर अनावरोधित करा"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> साठी संपर्क तपशील"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"आयात अयशस्वी झाले"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"नंबर अायात करा"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"आपले संपर्क शोधण्‍यासाठी, संपर्क परवानग्या चालू करा."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"चालू करा"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"अवरोधित केलेले नंबर"</string>
 </resources>
diff --git a/res/values-ms-rMY/strings.xml b/res/values-ms-rMY/strings.xml
index 95f991e..87a8b5e 100644
--- a/res/values-ms-rMY/strings.xml
+++ b/res/values-ms-rMY/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kenalan"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kenalan"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Lihat Kenalan"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edit Kenalan"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kenalan"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kenalan"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Dail terus"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Tetapkan lalai"</string>
     <string name="clear_default" msgid="7193185801596678067">"Kosongkan lalai"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Teks disalin"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Buang perubahan anda?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Buang"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Buang perubahan anda dan keluar daripada pengeditan?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Buang"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Teruskan mengedit"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Sediakan profil saya"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Taip nama orang"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Daripada <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Padamkan <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Padamkan <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto daripada <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>tidak ditandai"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto daripada <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ditandai"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto daripada akaun yang tidak diketahui tidak ditandai"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto daripada akaun yang tidak diketahui ditandai"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Senarai kenalan sedang dikemas kini untuk menggambarkan penukaran bahasa.\n\nSila tunggu..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Nombor yang disekat"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Panggilan dan teks daripada nombor ini akan disekat."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Tambah nombor"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Sekat nombor"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Tambahkn no. atau cari kenalan"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Panggilan dan teks daripada nombor ini akan disekat."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Nyahsekat <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"NYAHSEKAT"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Sekat <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"SEKAT"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> disekat"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> dinyahsekat"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> tidak sah."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Sekatan panggilan dimatikan sementara"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Sekatan panggilan telah dilumpuhkan kerana anda menghubungi perkhidmatan kecemasan daripada telefon ini dalam masa 48 jam yang lalu. Ciri ini akan didayakan semula secara automatik apabila tempoh 48 jam berakhir."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Sebelum ini anda telah menandai beberapa kenalan supaya dihantar ke mel suara secara automatik. Import nombor itu ke sini untuk menyekat panggilan dan juga teks."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Import"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Lihat nombor"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Tambah nombor"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Sekatan panggilan dilumpuhkan selama 48 jam"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Dilumpuhkan kerana panggilan kecemasan telah dibuat."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"BUAT ASAL"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> sudah disekat."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Nyahsekat nombor"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Butiran hubungan untuk <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Pengimportan gagal"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Import nombor"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Untuk mencari kenalan anda, hidupkan kebenaran Kenalan."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Hidupkan"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Nombor yang disekat"</string>
 </resources>
diff --git a/res/values-my-rMM/strings.xml b/res/values-my-rMM/strings.xml
index 2b0c2c6..955466d 100644
--- a/res/values-my-rMM/strings.xml
+++ b/res/values-my-rMM/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"အဆက်အသွယ်များ"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"အဆက်အသွယ်များ"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"အဆက်အသွယ်ကို ကြည့်ပါ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"အဆက်အသွယ်ကို တည်းဖြတ်ပါ"</string>
     <string name="contactsList" msgid="8661624236494819731">"အဆက်အသွယ်များ"</string>
     <string name="shortcutContact" msgid="749243779392912958">"အဆက်အသွယ်"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"တိုက်ရိုက်ခေါ်ဆိုခြင်း"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ပုံသေအဖြစ် သတ်မှတ်ခြင်း"</string>
     <string name="clear_default" msgid="7193185801596678067">"မူရင်းများကို ရှင်းလင်းခြင်း"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"စာသားကူးယူပြီး"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ပြင်မှုများအား စွန့်ပစ်မလား"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"စွန့်ပစ်ပါ"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"သင့်ပြောင်းလဲမှုများကို စွန့်ပစ်ပြီး တည်းဖြတ်မှုကို ရပ်မလား။"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"စွန့်ပစ်ရန်"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"ဆက်လက်တည်းဖြတ်ပါ"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"မိမိကိုယ်ရေးအကောင့်အား ပြုလုပ်ရန်"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"လူနာမည်ရိုက်ထည့်ပါ"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> မှ"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> ကိုဖျက်ပါ"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> ကိုဖျက်ပါ"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ထံမှ ဓာတ်ပုံကို မစစ်ကြည့်ရသေးပါ"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>ထံမှ ဓာတ်ပုံကို စစ်ကြည့်ပြီးပြီ"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"အမည်မသိအကောင့်မှ ဓာတ်ပုံဓာတ်ပုံ မစစ်ဆေးရသေးပါ"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"အမည်မသိအကောင့်မှ ဓာတ်ပုံ စစ်ဆေးပြီးပါပြီ"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ဆက်သွယ်ရန် စာရင်းကို ဘာသာစကားဆိုင်ရာ အပြောင်းအလဲအား ထင်ဟပ်ပေးရန် အပ်ဒိတ် လုပ်ပေးနေပါသည်။ \n\nခဏစောင့်ပါ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"ပိတ်ဆို့ထားသည့် နံပါတ်များ"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ဤနံပါတ်များမှ ခေါ်ဆိုမှုများနှင့် စာများကို ပိတ်ဆို့သွားပါမည်။"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"နံပါတ် ထည့်သွင်းပါ"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"နံပါတ်ကို ပိတ်ဆို့ရန်"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"နံပါတ်ပေါင်းထည့်ပါ သို့မဟုတ် အဆက်အသွယ်များ ရှာဖွေပါ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ဤနံပါတ်မှ ခေါ်ဆိုမှုများနှင့်စာများကို ပိတ်ဆို့သွားပါမည်။"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> အား ပိတ်ဆို့မှု ဖယ်ရှားလိုက်ရမလား။"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ပိတ်ဆို့ခြင်းမှ ဖယ်ရှားပါ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g>ကို ပိတ်ဆို့မလား။"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ပိတ်ဆို့ပါ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ကိုပိတ်ဆို့လိုက်ပါပြီ"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> ကိုပိတ်ဆို့ခြင်းမှ ဖယ်ရှားလိုက်ပါပြီ"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> သည်တရားမဝင်ပါ။"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ခေါ်ဆိုမှုပိတ်ဆို့ခြင်း ယာယီပိတ်ထားသည်"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"သင်သည် လွန်ခဲ့သည့် ၄၈ နာရီအတွင်း ဤဖုန်းဖြင့် အရေးပေါ်ဌာနကိုဖုန်း ခေါ်ဆိုခဲ့သောကြောင့် ခေါ်ဆိုမှုပိတ်ဆို့ခြင်းကို ဖြုတ်ထားသည်။ ၄၈ နာရီကျော်လွန်သည်နှင့် ၎င်းကိုအလိုအလျောက် ပြန်ဖွင့်ပေးပါမည်။"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"အချို့အဆက်အသွယ်များကို အသံစာသို့အလိုအလျောက်ပို့ရန် ယခင်က သင်သတ်မှတ်ထားခဲ့သည်။ ခေါ်ဆိုမှုများနှင့် စာများအားလုံးကို ပိတ်ဆို့ရန် ၎င်းနံပါတ်များကို ဤနေရာသို့သွင်းပါ။"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"တင်သွင်းရန်"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"နံပါတ်များကို ကြည့်ရန်"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"နံပါတ် ထည့်သွင်းပါ"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ခေါ်ဆိုမှုပိတ်ဆို့ခြင်းကို ၄၈ နာရီပိတ်ထားသည်"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"အရေးပေါ်ခေါ်ဆိုမှု ပြုလုပ်ခဲ့သည့်အတွက် ပိတ်ထားပါသည်။"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"နောက်ပြန်လုပ်ပါ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> အားပိတ်ဆို့ထားပြီးပါပြီ။"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"နံပါတ်ကို ဖွင့်မည်"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> ရဲ့ အဆက်အသွယ် အသေးစိတ်"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"တင်သွင်းမှု မအောင်မြင်ပါ"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"နံပါတ်များ သွင်းရန်"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"သင့်အဆက်အသွယ်များကို ရှာဖွေရန်၊ အဆက်အသွယ်ခွင့်ပြုချက်များကို ဖွင့်ပါ။"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ဖွင့်ထားရန်"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"ပိတ်ဆို့ထားသည့် နံပါတ်များ"</string>
 </resources>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 99dc681..b351636 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakter"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakter"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Se kontakten"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Endre kontakten"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakter"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Ring"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Angi som standard"</string>
     <string name="clear_default" msgid="7193185801596678067">"Fjern som standard"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Tekst kopiert"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Vil du forkaste endringene?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Forkast"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Vil du forkaste endringene og avslutte endringsmodusen?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Forkast"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Fortsett å endre"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Konfigurer profilen"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Tast inn personens navn"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Alle bildene"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Velg bilde"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Fra <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Slett <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Slett <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Bilde fra <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> er ikke markert"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Bilde fra <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> er markert"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Det er ikke merket av for noe bilde fra en ukjent konto"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Det er merket av for et bilde fra en ukjent konto"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaktlisten er oppdatert med nytt språk.\n\nVent litt ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokkerte telefonnumre"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Anrop og tekstmeldinger fra disse numrene blir blokkert."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Legg til nummer"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokkér nummeret"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Legg til nummer eller søk etter kontakter"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Anrop og tekstmeldinger fra dette nummeret blir blokkert."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Vil du oppheve blokkeringen av <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"OPPHEV BLOKKERINGEN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Vil du blokkere <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKKÉR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> er blokkert"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Blokkeringen av <xliff:g id="NUMBER">%1$s</xliff:g> er opphevet"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> er ugyldig."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokkering av anrop er midlertidig slått av"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Blokkering av anrop er slått av fordi du kontaktet nødtjenester fra denne telefonen i løpet av de siste 48 timene. Funksjonen blir automatisk slått på igjen når perioden på 48 timer er utløpt."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Du har tidligere markert at noen kontakter skal automatisk sendes til talepost. Importér disse numrene her for å blokkere både anrop og tekstmeldinger."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importér"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Se numre"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Legg til nummer"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Anropsblokkering er slått av i 48 timer"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Slått av fordi du foretok et nødanrop."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANGRE"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> er allerede blokkert."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Opphev blokkeringen av nummeret"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontaktinformasjon for <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importeringen mislyktes"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importér numre"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"For å søke i kontaktene dine, slå på tillatelser for Kontakter."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Slå på"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokkerte telefonnumre"</string>
 </resources>
diff --git a/res/values-ne-rNP/strings.xml b/res/values-ne-rNP/strings.xml
index 13eecfc..91e9c28 100644
--- a/res/values-ne-rNP/strings.xml
+++ b/res/values-ne-rNP/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"सम्पर्कहरू"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"सम्पर्कहरू"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"सम्पर्क हेर्नुहोस्"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"सम्पर्क सम्पादन गर्नुहोस्"</string>
     <string name="contactsList" msgid="8661624236494819731">"सम्पर्क"</string>
     <string name="shortcutContact" msgid="749243779392912958">"ठेगाना"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"सिधा डायल गर्नुहोस्"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"पूर्वनिर्धारित मिलाउनुहोस्"</string>
     <string name="clear_default" msgid="7193185801596678067">"पूर्वनिर्धारित हटाउनुहोस्"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"पाठको प्रतिलिपि  गरियो"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"तपाईँका परिवर्तनहरू रद्द गर्ने?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"खारेज गर्नुहोस्"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"तपाईंका परिवर्तनहरू खारेज गरी सम्पादनलाई छाड्ने हो?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"खारेज गर्नुहोस्"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"सम्पादन गरिरहनुहोस्"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"मेरो प्रोफाइल मिलाउनुहोस्"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"व्यक्तिको नाम टाइप गर्नुहोस्"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> बाट"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> मेट्नुहोस्"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> मेट्नुहोस्"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> बाट तस्बिर जाँच गरिएको छैन"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> बाट तस्बिर जाँच गरियो"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"अज्ञात खाताको तस्बिर जाँच गरिएन"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"अज्ञात खाताको तस्बिर जाँच गरियो"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"भाषा परिवर्तन प्रतिविम्ब गराउन सम्पर्क सूची अद्यावधिक भइरहेको छ। \n \n कृपया प्रतीक्षा गर्नुहोस्..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"रोकिएका नम्बरहरू"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"यी नम्बरका कल र पाठ सन्देशलाई रोक लगाइनेछ।"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"नम्बर थप्नुहोस्"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"नम्बरलाई निषेध गर्नुहोस्"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"नम्बर थप्नुहोस् वा सम्पर्कहरू खोज्नुहोस्"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"यस नम्बरका कल र पाठ सन्देशलाई रोक लगाइनेछ।"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> माथिको रोक हटाउने हो?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"रोक हटाउनुहोस्"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> माथि रोक लगाउने हो?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"रोक्नुहोस्"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> रोकियो"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> रोकियो"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> अमान्य छ।"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"कल अवरुद्ध अस्थायी रुपमा निष्क्रिय"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"कल अवरुद्ध अस्थायी रुपमा असक्षम गरिएको छ किनभने तपाईँले अन्तिम ४८ घण्टा भित्र यस फोनबाट आपत्कालीन सेवाहरू सम्पर्क गर्नुभयो। एकपटक ४८ घण्टा अवधि समाप्त भएपछि यो स्वचालित रूपले पुनः सक्रिय हुनेछ।"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"तपाईंले पहिले नै भ्वाइस मेलमा स्वत: पठाउन केही सम्पर्कहरूमा चिन्ह लगाउनुभएको थियो। कल र पाठ सन्देश दुबैलाई रोक्न ती नम्बरहरूलाई यहाँ आयात गर्नुहोस्।"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"आयात गर्नुहोस्"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"नम्बरहरू हेर्नुहोस्"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"नम्बर थप्नुहोस्"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"४८ घण्टाको लागि कल निषेध असक्षम गरियो"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"आपत्कालीन कल गरिएको हुनाले असक्षम गरियो।"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"अनडू गर्नुहोस्"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> पहिले नै रोकिएको छ।"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"नम्बरमाथिको रोक हटाउनुहोस्"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> को लागि सम्पर्क विवरणहरू"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"आयात असफल भयो"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"नम्बरहरू आयात गर्नुहोस्"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"तपाईँको सम्पर्कहरू खोज गर्न सम्पर्क अनुमतिहरू सक्रिय गर्नुहोस्।"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"सक्रिय पार्नुहोस्"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"रोकिएका नम्बरहरू"</string>
 </resources>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 384ef6f..5e1a5b5 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contacten"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contacten"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Contact bekijken"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Contact bewerken"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contacten"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contacten"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direct bellen"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Standaard instellen"</string>
     <string name="clear_default" msgid="7193185801596678067">"Standaardwaarden wissen"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Tekst gekopieerd"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Wijzigingen weggooien?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Verwijderen"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Je wijzigingen weggooien en ophouden met bewerken?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Weggooien"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Blijven bewerken"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Mijn profiel instellen"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Typ de naam van de persoon"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Van <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> verwijderen"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> verwijderen"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto van <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> niet aangevinkt"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto van <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> aangevinkt"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto uit onbekend account niet aangevinkt"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto uit onbekend account aangevinkt"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Lijst met contacten wordt bijgewerkt om de gewijzigde taal te weerspiegelen.\n\nEen ogenblik geduld..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Geblokkeerde nummers"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Oproepen en sms\'jes van deze nummers worden geblokkeerd."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Nummer toevoegen"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Nummer blokkeren"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Voeg nummer toe of zoek contacten"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Oproepen en sms\'jes van dit nummer worden geblokkeerd."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Blokkering van <xliff:g id="NUMBER">%1$s</xliff:g> opheffen?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"BLOKKERING OPHEFFEN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> blokkeren?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKKEREN"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> geblokkeerd"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Blokkering van <xliff:g id="NUMBER">%1$s</xliff:g> opgeheven"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> is ongeldig."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Oproepblokkering tijdelijk uitgeschakeld"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Oproepblokkering is uitgeschakeld omdat je in de afgelopen 48 uur contact met de noodhulpdiensten hebt opgenomen via deze telefoon. De functie wordt automatisch weer ingeschakeld nadat de periode van 48 uur is verstreken."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Je hebt eerder al aangegeven dat bepaalde contacten automatisch moeten worden doorgeschakeld naar de voicemail. Importeer die nummers hier om oproepen en sms\'jes te blokkeren."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importeren"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Nummers bekijken"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Nummer toevoegen"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Oproepblokkering is 48 uur uitgeschakeld"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Uitgeschakeld omdat een noodoproep is geplaatst."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ONGEDAAN MAKEN"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> is al geblokkeerd."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Blokkeren van nummer opheffen"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Contactgegevens voor <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importeren mislukt"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Nummers importeren"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Als je naar contacten wilt zoeken, schakel je de contacttoestemming in."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Inschakelen"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Geblokkeerde nummers"</string>
 </resources>
diff --git a/res/values-pa-rIN/strings.xml b/res/values-pa-rIN/strings.xml
index cdd30f5..6c431f5 100644
--- a/res/values-pa-rIN/strings.xml
+++ b/res/values-pa-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"ਸੰਪਰਕ"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"ਸੰਪਰਕ"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"ਸੰਪਰਕ ਦੇਖੋ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"ਸੰਪਰਕ ਬਣਾਓ"</string>
     <string name="contactsList" msgid="8661624236494819731">"ਸੰਪਰਕ"</string>
     <string name="shortcutContact" msgid="749243779392912958">"ਸੰਪਰਕ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ਸਿੱਧਾ ਡਾਇਲ ਕਰੋ"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ਡਿਫੌਲਟ ਸੈਟ ਕਰੋ"</string>
     <string name="clear_default" msgid="7193185801596678067">"ਡਿਫੌਲਟ ਹਟਾਓ"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"ਟੈਕਸਟ ਕਾਪੀ ਕੀਤਾ"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ਕੀ ਬਦਲਾਵ ਬਰਖਾਸਤ ਕਰਨੇ ਹਨ?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"ਰੱਦ ਕਰੋ"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"ਕੀ ਆਪਣੀਆਂ ਤਬਦੀਲੀਆਂ ਨੂੰ ਛੱਡਣਾ ਅਤੇ ਸੰਪਾਦਨ ਨੂੰ ਰੱਦ ਕਰਨਾ ਹੈ?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"ਛੱਡੋ"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"ਸੋਧ ਕਰਦੇ ਰਹੋ"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"ਮੇਰੀ ਪ੍ਰੋਫਾਈਲ ਸੈਟ ਅਪ ਕਰੋ"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"ਵਿਅਕਤੀ ਦਾ ਨਾਮ ਟਾਈਪ ਕਰੋ"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> ਵੱਲੋਂ"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> ਹਟਾਓ"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> ਹਟਾਓ"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ਵੱਲੋਂ ਫੋਟੋ ਨਹੀਂ ਜਾਂਚੀ ਗਈ"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ਵਲੋਂ ਫੋਟੋ ਜਾਂਚੀ ਗਈ"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"ਅਗਿਆਤ ਖਾਤੇ ਦੀ ਫੋਟੋ ਨਹੀਂ ਜਾਂਚੀ ਗਈ"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"ਅਗਿਆਤ ਖਾਤੇ ਦੀ ਫੋਟੋ ਜਾਂਚੀ ਗਈ"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"ਭਾਸ਼ਾ ਵਿੱਚ ਕੀਤੀ ਤਬਦੀਲੀ ਨੂੰ ਦਰਸਾਉਣ ਲਈ ਸੰਪਰਕ ਸੂਚੀ ਅੱਪਡੇਟ ਕੀਤੀ ਜਾ ਰਹੀ ਹੈ।\n\nਕਿਰਪਾ ਕਰਕੇ ਉਡੀਕ ਕਰੋ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"ਬਲੌਕ ਕੀਤੇ ਨੰਬਰ"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ਇਹਨਾਂ ਨੰਬਰਾਂ ਤੋਂ ਕਾਲਾਂ ਅਤੇ ਟੈਕਸਟ ਬਲੌਕ ਕੀਤੇ ਜਾਣਗੇ।"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ਨੰਬਰ ਜੋੜੋ"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"ਨੰਬਰ ਨੂੰ ਬਲੌਕ ਕਰੋ"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"ਨੰਬਰ ਜੋੜੋ ਜਾਂ ਸੰਪਰਕ ਖੋਜੋ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ਇਸ ਨੰਬਰ ਤੋਂ ਕਾਲਾਂ ਅਤੇ ਟੈਕਸਟ ਨੂੰ ਬਲੌਕ ਕਰ ਦਿੱਤਾ ਜਾਵੇਗਾ।"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"ਕੀ <xliff:g id="NUMBER">%1$s</xliff:g> ਅਨਲੌਕ ਕਰਨਾ ਹੈ?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ਅਨਬਲੌਕ ਕਰੋ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"ਕੀ <xliff:g id="NUMBER">%1$s</xliff:g> ਬਲੌਕ ਕਰਨਾ ਹੈ?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ਬਲੌਕ ਕਰੋ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ਬਲੌਕ ਕੀਤਾ"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> ਅਨਬਲੌਕ ਕੀਤਾ"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ਅਪ੍ਰਮਾਣਿਕ ਹੈ।"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ਕਾਲ ਬਲੌਕਿੰਗ ਆਰਜ਼ੀ ਤੌਰ ਤੇ ਬੰਦ ਹੈ"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ਕਾਲ ਬਲੌਕਿੰਗ ਅਸਮਰੱਥ ਕਰ ਦਿੱਤੀ ਗਈ ਹੈ ਕਿਉਂਕਿ ਤੁਸੀਂ ਇਸ ਫੋਨ ਦੁਆਰਾ ਪਿਛਲੇ 48 ਘੰਟਿਆਂ ਤੋਂ ਐਮਰਜੈਂਸੀ ਸੇਵਾਵਾਂ ਨਾਲ ਕਨੈਕਟ ਕੀਤਾ ਹੋਇਆ ਹੈ। ਇਹ 48 ਘੰਟਿਆਂ ਦਾ ਸਮਾਂ ਪੂਰਾ ਹੋਣ ਤੇੋਂ ਬਾਅਦ ਆਟੋਮੈਟਿਕਲੀ ਮੁੜ-ਸਮਰੱਥ ਹੋ ਜਾਵੇਗੀ।"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ਤੁਸੀਂ ਪਹਿਲਾਂ ਕੁਝ ਸੰਪਰਕਾਂ ਨੂੰ ਸਵੈਚਾਲਿਤ ਤੌਰ \'ਤੇ ਵੌਇਸਮੇਲ ਨੂੰ ਭੇਜਣ ਲਈ ਚਿੰਨ੍ਹਿਤ ਕੀਤਾ। ਕਾਲਾਂ ਅਤੇ ਟੈਕਸਟ ਦੋਵਾਂ ਨੂੰ ਬਲੌਕ ਕਰਨ ਲਈ ਉਹਨਾਂ ਨੰਬਰਾਂ ਨੂੰ ਇੱਥੇ ਆਯਾਤ ਕਰੋ।"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"ਆਯਾਤ ਕਰੋ"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"ਨੰਬਰ ਵਿਖਾਓ"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"ਨੰਬਰ ਜੋੜੋ"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ਕਾਲ ਬਲੋੌਕਿੰਗ 48 ਘੰਟਿਆਂ ਲਈ ਅਯੋਗ ਕੀਤੀ ਗਈ"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"ਆਯੋਗ ਕੀਤਾ ਕਿਉਂਕਿ ਇੱਕ ਸੰਕਟ ਕਾਲ ਕੀਤੀ ਗਈ ਸੀ।"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ਪਹਿਲਾਂ ਵਰਗਾ ਕਰੋ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ਪਹਿਲਾਂ ਹੀ ਬਲੌਕ ਕੀਤਾ ਹੋਇਆ ਹੈ।"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"ਨੰਬਰ ਨੂੰ ਅਨਬਲੌਕ ਕਰੋ"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> ਲਈ ਸੰਪਰਕ ਵੇਰਵੇ"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"ਆਯਾਤ ਅਸਫਲ ਹੋਇਆ"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"ਆਯਾਤ ਨੰਬਰ"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"ਆਪਣੇ ਸੰਪਰਕਾਂ ਦੀ ਖੋਜ ਕਰਨ ਲਈ,, ਸੰਪਰਕ ਅਨੁਮਤੀਆਂ ਨੂੰ ਚਾਲੂ ਕਰੋ।"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ਚਾਲੂ ਕਰੋ"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"ਬਲੌਕ ਕੀਤੇ ਨੰਬਰ"</string>
 </resources>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index f679fd7..5d58b16 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakty"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakty"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Wyświetl kontakt"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Edytuj kontakt"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakty"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Telefon do osoby"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Ustaw jako wartość domyślną"</string>
     <string name="clear_default" msgid="7193185801596678067">"Wyczyść wartość domyślną"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Tekst skopiowany"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Odrzucić zmiany?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Odrzuć"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Odrzucić zmiany i zakończyć edycję?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Odrzuć"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Edytuj dalej"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Skonfiguruj profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Wpisz imię osoby"</string>
@@ -340,8 +343,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Wszystkie zdjęcia"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Wybierz zdjęcie"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Z konta <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Usuń <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Usuń <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Zdjęcie z konta <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> – niezaznaczone"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Zdjęcie z konta <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> – zaznaczone"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Nie wybrano zdjęcia z nieznanego konta"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Wybrano zdjęcie z nieznanego konta"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Lista kontaktów jest aktualizowana, aby odzwierciedlić zmianę języka.\n\nCzekaj..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Zablokowane numery"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Połączenia i SMS-y z tych numerów będą blokowane."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj numer"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Zablokuj numer"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Dodaj numer lub wyszukaj kontakty"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Połączenia i SMS-y z tego numeru będą blokowane."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Odblokować numer <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ODBLOKUJ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Zablokować numer <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ZABLOKUJ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> zablokowany"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> odblokowany"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Numer <xliff:g id="NUMBER">%1$s</xliff:g> jest nieprawidłowy."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokada połączeń tymczasowo wyłączona"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Blokada połączeń została wyłączona, ponieważ w ciągu ostatnich 48 godzin dzwoniono z tego telefonu na numer alarmowy. Blokada zostanie automatycznie przywrócona po upływie 48 godzin."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Zgodnie z wcześniejszymi ustawieniami niektóre kontakty są automatycznie przekierowywane na pocztę głosową. Zaimportuj te numery tutaj, by zablokować połączenia i SMS-y z tych numerów."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importuj"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Pokaż numery"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj numer"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blokada połączeń została wyłączona na 48 godzin"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Wyłączona, ponieważ wykonano połączenie alarmowe."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"COFNIJ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Numer <xliff:g id="NUMBER">%1$s</xliff:g> jest już zablokowany."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Odblokuj numer"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Szczegóły kontaktu: <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Nie udało się zaimportować"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Zaimportuj numery"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Aby wyszukać kontakty, włącz uprawnienia Kontakty."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Włącz"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Zablokowane numery"</string>
 </resources>
diff --git a/res/values-pt-rBR/strings.xml b/res/values-pt-rBR/strings.xml
index 7df707d..1f70056 100644
--- a/res/values-pt-rBR/strings.xml
+++ b/res/values-pt-rBR/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contatos"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contatos"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ver contato"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editar contato"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contatos"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contato"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Discagem direta"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Definir padrão"</string>
     <string name="clear_default" msgid="7193185801596678067">"Limpar padrão"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texto copiado"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Descartar as alterações?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Descartar as alterações e sair da edição?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Continuar edição"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurar meu perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Digite o nome da pessoa"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Todas as fotos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Escolher foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"De <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Excluir <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Excluir <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>não marcada"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>marcada"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto de conta desconhecida não verificada"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto de conta desconhecida verificada"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"A lista de contatos está sendo atualizada para refletir a alteração do idioma.\n\nAguarde..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloqueados"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Chamadas e mensagens de texto desses números serão bloqueadas."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adicionar número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquear número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Adicionar número ou pesquisar contatos"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Chamadas e mensagens de texto deste número serão bloqueadas."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Desbloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEAR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Bloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEAR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Número <xliff:g id="NUMBER">%1$s</xliff:g> bloqueado"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Número <xliff:g id="NUMBER">%1$s</xliff:g> desbloqueado"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"O número <xliff:g id="NUMBER">%1$s</xliff:g> é inválido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bloqueio de chamadas temporiamente desativado"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"O bloqueio de chamadas foi desativado porque você entrou em contato com serviços de emergência usando este telefone nas últimas 48 horas. Ele será reativado automaticamente depois de um período de 48 horas."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anteriormente, você marcou alguns contatos para serem enviados automaticamente ao correio de voz. Importe esses números para cá para bloquear chamadas e mensagens de texto."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ver números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adicionar número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Bloqueio de chamadas desativado por 48 horas"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Desativado porque foi feita uma chamada de emergência."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESFAZER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"O número <xliff:g id="NUMBER">%1$s</xliff:g> já está bloqueado."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloquear número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detalhes de contato para <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Falha na importação"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importar números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Para pesquisar seus contatos, ative as permissões para \"Contatos\"."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Ativar"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloqueados"</string>
 </resources>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index bea5166..431b3ab 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contactos"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contactos"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ver contacto"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editar contacto"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contactos"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contacto"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Marcação directa"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Definir a predefinição"</string>
     <string name="clear_default" msgid="7193185801596678067">"Limpar predefinição"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texto copiado"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Rejeitar as alterações?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Rejeitar"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Pretende rejeitar as alterações e sair do editor?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Rejeitar"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Continuar a editar"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Config. o perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Introduza o nome da pessoa"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"De <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Eliminar <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Eliminar <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> não marcada"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> marcada"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto de conta desconhecida desmarcada"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto de conta desconhecida marcada"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"A lista de contactos está a ser atualizada para reflectir a alteração do idioma.\n\nAguarde..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloqueados"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"As chamadas e mensagens de texto a partir destes números serão bloqueadas."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adicionar número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquear número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Adic. n.º ou pesq. contactos"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"As chamadas e mensagens de texto a partir deste número serão bloqueadas."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Pretende desbloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEAR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Pretende bloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEAR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> bloqueado"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> desbloqueado"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> é inválido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bloqueio de chamadas tempor. desativado"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"O bloqueio de chamadas foi desativado porque contactou os serviços de emergência a partir deste telemóvel nas últimas 48 horas. O bloqueio será automaticamente reativado assim que expirar o período de 48 horas."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anteriormente, marcou alguns contactos para serem automaticamente enviados para o correio de voz. Importe esses números aqui para bloquear chamadas e mensagens de texto."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ver números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adicionar número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Bloqueio de chamadas desativado durante 48 horas"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Desativado porque foi efetuada uma chamada de emergência."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANULAR"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> já está bloqueado."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloquear número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detalhes de contacto para <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Falha ao importar"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importar números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Para pesquisar os seus contactos, ative as autorizações Contactos."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Ativar"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloqueados"</string>
 </resources>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index 7df707d..1f70056 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Contatos"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Contatos"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ver contato"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editar contato"</string>
     <string name="contactsList" msgid="8661624236494819731">"Contatos"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contato"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Discagem direta"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Definir padrão"</string>
     <string name="clear_default" msgid="7193185801596678067">"Limpar padrão"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texto copiado"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Descartar as alterações?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Descartar as alterações e sair da edição?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Descartar"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Continuar edição"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurar meu perfil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Digite o nome da pessoa"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Todas as fotos"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Escolher foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"De <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Excluir <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Excluir <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>não marcada"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Foto de <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>marcada"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Foto de conta desconhecida não verificada"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Foto de conta desconhecida verificada"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"A lista de contatos está sendo atualizada para refletir a alteração do idioma.\n\nAguarde..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Números bloqueados"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Chamadas e mensagens de texto desses números serão bloqueadas."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adicionar número"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Bloquear número"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Adicionar número ou pesquisar contatos"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Chamadas e mensagens de texto deste número serão bloqueadas."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Desbloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DESBLOQUEAR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Bloquear <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOQUEAR"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Número <xliff:g id="NUMBER">%1$s</xliff:g> bloqueado"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Número <xliff:g id="NUMBER">%1$s</xliff:g> desbloqueado"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"O número <xliff:g id="NUMBER">%1$s</xliff:g> é inválido."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bloqueio de chamadas temporiamente desativado"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"O bloqueio de chamadas foi desativado porque você entrou em contato com serviços de emergência usando este telefone nas últimas 48 horas. Ele será reativado automaticamente depois de um período de 48 horas."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anteriormente, você marcou alguns contatos para serem enviados automaticamente ao correio de voz. Importe esses números para cá para bloquear chamadas e mensagens de texto."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ver números"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adicionar número"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Bloqueio de chamadas desativado por 48 horas"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Desativado porque foi feita uma chamada de emergência."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"DESFAZER"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"O número <xliff:g id="NUMBER">%1$s</xliff:g> já está bloqueado."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Desbloquear número"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detalhes de contato para <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Falha na importação"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importar números"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Para pesquisar seus contatos, ative as permissões para \"Contatos\"."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Ativar"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Números bloqueados"</string>
 </resources>
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 8f22253..b60a252 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Agendă"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Agendă"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Afișați persoana de contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Editați persoana de contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Agendă"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Persoană din Agendă"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Apel direct"</string>
@@ -32,31 +34,31 @@
     <string name="frequentList" msgid="7154768136473953056">"Frecvent"</string>
     <string name="strequentList" msgid="5640192862059373511">"Favorite"</string>
     <string name="viewContactTitle" msgid="7989394521836644384">"Detalii ale persoanei din agendă"</string>
-    <string name="editContactDescription" msgid="2947202828256214947">"Modificaţi informațiile despre persoana din agendă"</string>
+    <string name="editContactDescription" msgid="2947202828256214947">"Modificați informațiile despre persoana din agendă"</string>
     <string name="insertContactDescription" msgid="4709878105452681987">"Creați persoana din agendă"</string>
     <string name="editGroupDescription" msgid="6321161304201540561">"Editați grupul"</string>
     <string name="insertGroupDescription" msgid="5658512271662210139">"Creați grupul"</string>
     <string name="contactDetailAbout" msgid="5430408883907061400">"Despre"</string>
     <string name="contactDetailUpdates" msgid="3780588624763446941">"Actualizări"</string>
-    <string name="searchHint" msgid="8482945356247760701">"Căutaţi în Agendă"</string>
+    <string name="searchHint" msgid="8482945356247760701">"Căutați în Agendă"</string>
     <string name="menu_viewContact" msgid="2795575601596468581">"Vizualizați persoana din agendă"</string>
     <string name="menu_addStar" msgid="2908478235715404876">"Adăugați la lista de favorite"</string>
-    <string name="menu_removeStar" msgid="5844227078364227030">"Eliminaţi din lista de favorite"</string>
+    <string name="menu_removeStar" msgid="5844227078364227030">"Eliminați din lista de favorite"</string>
     <string name="description_action_menu_remove_star" msgid="4699640108012265178">"S-a eliminat din preferințe"</string>
     <string name="description_action_menu_add_star" msgid="3327186327234177456">"Adăugat la preferințe"</string>
     <string name="menu_editContact" msgid="9042415603857662633">"Editați"</string>
-    <string name="menu_deleteContact" msgid="6788644058868189393">"Ștergeţi"</string>
+    <string name="menu_deleteContact" msgid="6788644058868189393">"Ștergeți"</string>
     <string name="menu_change_photo" msgid="7769177631511496210">"Schimbați fotografia"</string>
     <string name="menu_create_contact_shortcut" msgid="1217971915748509640">"Plasați în ecranul de pornire"</string>
-    <string name="menu_call" msgid="3992595586042260618">"Apelaţi persoana din agendă"</string>
+    <string name="menu_call" msgid="3992595586042260618">"Apelați persoana din agendă"</string>
     <string name="menu_sendSMS" msgid="5535886767547006515">"Trimiteți mesaj text către o persoană din agendă"</string>
-    <string name="menu_splitAggregate" msgid="2627252205317945563">"Separați"</string>
+    <string name="menu_splitAggregate" msgid="2627252205317945563">"Disociați"</string>
     <string name="menu_editGroup" msgid="5062005185370983720">"Editați"</string>
-    <string name="menu_deleteGroup" msgid="3486380004411482874">"Ștergeţi"</string>
+    <string name="menu_deleteGroup" msgid="3486380004411482874">"Ștergeți"</string>
     <string name="menu_new_contact_action_bar" msgid="7263362129442119188">"Adăugați o persoană de contact"</string>
     <string name="menu_new_group_action_bar" msgid="3520232877587377175">"Adăugați un grup"</string>
     <string name="splitConfirmation" msgid="7342030840130187290">"Separați această persoană de contact în mai multe persoane de contact?"</string>
-    <string name="splitConfirmation_positive_button" msgid="9129409098807939699">"Separați"</string>
+    <string name="splitConfirmation_positive_button" msgid="9129409098807939699">"Disociați"</string>
     <string name="splitConfirmationWithPendingChanges" msgid="7719062163511895696">"Doriți să salvați modificările pe care le-ați făcut deja și să separați această persoană de contact în mai multe persoane de contact?"</string>
     <string name="splitConfirmationWithPendingChanges_positive_button" msgid="9073444264887244032">"Salvați și separați"</string>
     <string name="joinConfirmation" msgid="8262614843581924365">"Doriți să salvați modificările pe care le-ați făcut deja și să asociați această persoană cu persoana de contact selectată?"</string>
@@ -65,7 +67,7 @@
     <string name="menu_save" msgid="1727844363591825909">"Salvați"</string>
     <string name="titleJoinContactDataWith" msgid="6825255752748313944">"Asociați persoanele de contact"</string>
     <string name="blurbJoinContactDataWith" msgid="5864256698061641841">"Alegeți persoana de contact pe care doriți să o asociați cu <xliff:g id="NAME">%s</xliff:g>:"</string>
-    <string name="showAllContactsJoinItem" msgid="2189695051430392383">"Afişaţi toate persoanele din agendă"</string>
+    <string name="showAllContactsJoinItem" msgid="2189695051430392383">"Afișați toate persoanele din agendă"</string>
     <string name="separatorJoinAggregateSuggestions" msgid="2831414448851313345">"Persoane din agendă sugerate"</string>
     <string name="separatorJoinAggregateAll" msgid="7939932265026181043">"Toate persoanele din agendă"</string>
     <string name="contactsJoinedMessage" msgid="3343535986195643136">"Persoanele de contact au fost asociate"</string>
@@ -74,7 +76,7 @@
       <item quantity="other">Persoane de contact șterse</item>
       <item quantity="one">Persoană de contact ștearsă</item>
     </plurals>
-    <string name="menu_set_ring_tone" msgid="8728345772068064946">"Setaţi ton apel"</string>
+    <string name="menu_set_ring_tone" msgid="8728345772068064946">"Setați ton apel"</string>
     <string name="menu_redirect_calls_to_vm" msgid="4181789196416396656">"Toate apel. către mesag. voc."</string>
     <string name="readOnlyContactWarning" msgid="5526727661978307833">"Persoanele de contact din conturile numai în citire nu pot fi șterse, dar pot fi ascunse."</string>
     <string name="readOnlyContactWarning_positive_button" msgid="6541862607313811926">"Ascundeți"</string>
@@ -104,7 +106,7 @@
     <string name="attach_photo_dialog_title" msgid="5599827035558557169">"Fotografie persoană din agendă"</string>
     <string name="customLabelPickerTitle" msgid="1081475101983255212">"Numele etichetei personalizate"</string>
     <string name="send_to_voicemail_checkbox" msgid="9001686764070676353">"Trimiteți apelurile direct către mesageria vocală"</string>
-    <string name="removePhoto" msgid="4898105274130284565">"Eliminaţi fotografia"</string>
+    <string name="removePhoto" msgid="4898105274130284565">"Eliminați fotografia"</string>
     <string name="noContacts" msgid="4955659076981974652">"Nu există persoane în agendă"</string>
     <string name="noGroups" msgid="8614664663561385253">"Nu există grupuri."</string>
     <string name="noAccounts" msgid="7768267764545265909">"Pentru a crea grupuri aveți nevoie de un cont."</string>
@@ -139,22 +141,22 @@
     </plurals>
     <string name="all_contacts_tab_label" msgid="5948889261993124839">"Toate"</string>
     <string name="favorites_tab_label" msgid="1524869648904016414">"Preferate"</string>
-    <string name="callBack" msgid="5498224409038809224">"Apelaţi din nou"</string>
-    <string name="callAgain" msgid="3197312117049874778">"Apelaţi din nou"</string>
-    <string name="returnCall" msgid="8171961914203617813">"Apelaţi înapoi"</string>
+    <string name="callBack" msgid="5498224409038809224">"Apelați din nou"</string>
+    <string name="callAgain" msgid="3197312117049874778">"Apelați din nou"</string>
+    <string name="returnCall" msgid="8171961914203617813">"Apelați înapoi"</string>
     <string name="add_contact_dlg_message_fmt" msgid="7986472669444326576">"Adăugați „<xliff:g id="EMAIL">%s</xliff:g>” la persoanele din agendă?"</string>
     <string name="description_contact_photo" msgid="3387458082667894062">"fotografia persoanei din agendă"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
     <string name="exporting_contact_list_progress" msgid="560522409559101193">"<xliff:g id="CURRENT_NUMBER">%s</xliff:g> din <xliff:g id="TOTAL_NUMBER">%s</xliff:g> (de) persoane din agendă"</string>
     <string name="search_settings_description" msgid="2675223022992445813">"Numele persoanelor din agenda dvs."</string>
-    <string name="quickcontact_missing_app" msgid="358168575340921552">"Nu s-a găsit o aplicație care să gestioneze această acţiune."</string>
+    <string name="quickcontact_missing_app" msgid="358168575340921552">"Nu s-a găsit o aplicație care să gestioneze această acțiune."</string>
     <string name="quickcontact_transparent_view_description" msgid="987959416759562455">"Dați clic pentru a reveni la ecranul anterior"</string>
     <string name="quickcontact_add_phone_number" msgid="731665835910658965">"Adăugați un număr de telefon"</string>
     <string name="quickcontact_add_email" msgid="739298028384348482">"Adăugați o adresă de e-mail"</string>
     <string name="missing_app" msgid="1466111003546611387">"Nu s-a găsit o aplicație care să îndeplinească această acțiune."</string>
-    <string name="menu_share" msgid="943789700636542260">"Distribuiţi"</string>
+    <string name="menu_share" msgid="943789700636542260">"Distribuiți"</string>
     <string name="menu_add_contact" msgid="3198704337220892684">"Adăugați în Agendă"</string>
-    <string name="share_via" msgid="563121028023030093">"Distribuiţi persoana din agendă prin"</string>
+    <string name="share_via" msgid="563121028023030093">"Distribuiți persoana din agendă prin"</string>
     <string name="dialog_new_group_account" msgid="2318032089273496830">"Creați un grup în contul"</string>
     <string name="audio_chat" msgid="2535716629358298691">"Chat vocal"</string>
     <string name="video_chat" msgid="1872255818640336072">"Chat video"</string>
@@ -168,16 +170,16 @@
     <skip />
     <string name="contact_read_only" msgid="7421346527289472273">"Nu se poate edita din această aplicație"</string>
     <string name="group_read_only" msgid="1061762906115697637">"Nu poate fi editat pe acest dispozitiv."</string>
-    <string name="take_photo" msgid="7496128293167402354">"Fotografiaţi"</string>
+    <string name="take_photo" msgid="7496128293167402354">"Fotografiați"</string>
     <string name="take_new_photo" msgid="7341354729436576304">"Creați o fotografie nouă"</string>
     <string name="pick_photo" msgid="2129509985223564942">"Alegeți o fotografie"</string>
     <string name="pick_new_photo" msgid="9122450996263688237">"Selectați o fotografie nouă"</string>
     <string name="upgrade_in_progress" msgid="474511436863451061">"Se actualizează lista de persoane din agendă."</string>
     <string name="search_results_searching" msgid="3984833028938569930">"Se caută..."</string>
-    <string name="menu_display_selected" msgid="6470001164297969034">"Afişaţi elementele selectate"</string>
-    <string name="menu_display_all" msgid="8887488642609786198">"Afișați-i pe toţi"</string>
-    <string name="menu_select_all" msgid="621719255150713545">"Selectaţi-le pe toate"</string>
-    <string name="menu_select_none" msgid="7093222469852132345">"Deselectaţi-le pe toate"</string>
+    <string name="menu_display_selected" msgid="6470001164297969034">"Afișați elementele selectate"</string>
+    <string name="menu_display_all" msgid="8887488642609786198">"Afișați-i pe toți"</string>
+    <string name="menu_select_all" msgid="621719255150713545">"Selectați-le pe toate"</string>
+    <string name="menu_select_none" msgid="7093222469852132345">"Deselectați-le pe toate"</string>
     <string name="add_new_entry_for_section" msgid="5223080690667565044">"Adăugați intrare nouă"</string>
     <string name="add_organization" msgid="7311893231158291197">"Adăugați o organizație"</string>
     <string name="event_edit_field_hint_text" msgid="5794424930242630477">"Dată"</string>
@@ -187,7 +189,7 @@
     <string name="description_star" msgid="2605854427360036550">"preferate"</string>
     <string name="edit_contact" msgid="7529281274005689512">"Editați informațiile despre persoana din agendă"</string>
     <string name="aggregation_suggestion_join_dialog_message" msgid="6786192560870357912">"Asociați persoana de contact actuală cu persoana de contact selectată?"</string>
-    <string name="aggregation_suggestion_edit_dialog_message" msgid="6549585283910518095">"Comutaţi la funcția de editare a persoanei din agendă selectate? Informațiile introduse până acum vor fi copiate."</string>
+    <string name="aggregation_suggestion_edit_dialog_message" msgid="6549585283910518095">"Comutați la funcția de editare a persoanei din agendă selectate? Informațiile introduse până acum vor fi copiate."</string>
     <string name="menu_copyContact" msgid="1573960845106822639">"Copiați în Agendă"</string>
     <string name="add_to_my_contacts" msgid="1068274916793627723">"Adăugați în Agendă"</string>
     <string name="contact_directory_description" msgid="683398073603909119">"Director <xliff:g id="TYPE">%1$s</xliff:g>"</string>
@@ -195,19 +197,19 @@
     <string name="activity_title_settings" msgid="5464130076132770781">"Setări"</string>
     <string name="menu_settings" msgid="377929915873428211">"Setări"</string>
     <string name="menu_help" msgid="1680178646764069976">"Ajutor și feedback"</string>
-    <string name="preference_displayOptions" msgid="1341720270148252393">"Opţiuni de afişare"</string>
+    <string name="preference_displayOptions" msgid="1341720270148252393">"Opțiuni de afișare"</string>
     <string name="organization_company_and_title" msgid="6718207751363732025">"<xliff:g id="COMPANY_0">%2$s</xliff:g>, <xliff:g id="COMPANY_1">%1$s</xliff:g>"</string>
     <string name="non_phone_caption" msgid="1541655052330027380">"Număr de telefon"</string>
     <string name="non_phone_add_to_contacts" msgid="6590985286250471169">"Adăugați în Agendă"</string>
     <string name="activity_title_confirm_add_detail" msgid="4065089866210730616">"Adăug. la pers. din ag."</string>
-    <string name="non_phone_close" msgid="7608506439725515667">"Închideţi"</string>
+    <string name="non_phone_close" msgid="7608506439725515667">"Închideți"</string>
     <string name="widget_name_and_phonetic" msgid="8739586586600099979">"<xliff:g id="DISPLAY_NAME">%1$s</xliff:g> (<xliff:g id="PHONETIC_NAME">%2$s</xliff:g>)"</string>
     <string name="date_year_toggle" msgid="7122002148518724139">"Includeți un an"</string>
     <string name="social_widget_label" msgid="6378905543028924592">"Persoană din agendă"</string>
     <string name="social_widget_loading" msgid="5327336597364074608">"Se încarcă..."</string>
     <string name="contacts_unavailable_create_contact" msgid="7014525713871959208">"Creați o intrare nouă în Agendă"</string>
     <string name="contacts_unavailable_add_account" msgid="4347232421410561500">"Adăugați un cont"</string>
-    <string name="contacts_unavailable_import_contacts" msgid="4957393255392437529">"Importaţi Agenda"</string>
+    <string name="contacts_unavailable_import_contacts" msgid="4957393255392437529">"Importați Agenda"</string>
     <string name="create_group_dialog_title" msgid="6874527142828424475">"Creați un grup nou"</string>
     <string name="create_group_item_label" msgid="4411981763169654825">"Creați un grup nou"</string>
     <plurals name="num_groups_in_account" formatted="false" msgid="6189297639209663469">
@@ -215,7 +217,7 @@
       <item quantity="other"><xliff:g id="COUNT">%0$d</xliff:g> de grupuri</item>
       <item quantity="one">Un grup</item>
     </plurals>
-    <string name="delete_group_dialog_message" msgid="7586856514337560529">"Ștergeţi grupul „<xliff:g id="GROUP_LABEL">%1$s</xliff:g>”? (Agenda nu va fi ştearsă.)"</string>
+    <string name="delete_group_dialog_message" msgid="7586856514337560529">"Ștergeți grupul „<xliff:g id="GROUP_LABEL">%1$s</xliff:g>”? (Agenda nu va fi ștearsă.)"</string>
     <plurals name="num_contacts_in_group" formatted="false" msgid="5520734553286350341">
       <item quantity="few"><xliff:g id="COUNT_2">%1$d</xliff:g> persoane din <xliff:g id="ACCOUNT_TYPE_3">%2$s</xliff:g></item>
       <item quantity="other"><xliff:g id="COUNT_2">%1$d</xliff:g> de persoane din <xliff:g id="ACCOUNT_TYPE_3">%2$s</xliff:g></item>
@@ -228,30 +230,31 @@
     </plurals>
     <string name="toast_join_with_empty_contact" msgid="1215465657839085613">"Introduceți numele persoanei de contact înainte de a o asocia cu altă persoană."</string>
     <string name="copy_text" msgid="3257145021583508761">"Copiați în clipboard"</string>
-    <string name="set_default" msgid="4417505153468300351">"Setaţi ca prestabilit"</string>
-    <string name="clear_default" msgid="7193185801596678067">"Ștergeţi datele prestabilite"</string>
+    <string name="set_default" msgid="4417505153468300351">"Setați ca prestabilit"</string>
+    <string name="clear_default" msgid="7193185801596678067">"Ștergeți datele prestabilite"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text copiat"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Renunţaţi la modificări?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Închideți"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Renunțați la modificări și părăsiți editarea?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Renunțați"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Editați în continuare"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Configurați profilul"</string>
-    <string name="enter_contact_name" msgid="1738391320566349924">"Introduceţi numele persoanei"</string>
+    <string name="enter_contact_name" msgid="1738391320566349924">"Introduceți numele persoanei"</string>
     <string name="group_name_hint" msgid="238359485263401293">"Numele grupului"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Profilul meu local"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Profilul meu <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Se afișează toată agenda"</string>
     <string name="no_account_prompt" msgid="6424883302325061025">"Agenda funcționează mai bine cu un Cont Google.\n\n• O puteți accesa din orice browser web.\n• Creați în siguranță backup pentru persoanele de contact."</string>
-    <string name="generic_no_account_prompt" msgid="7218827704367325460">"Păstraţi agenda dvs. în condiții de siguranţă, chiar dacă pierdeți telefonul, prin sincronizarea acesteia cu un serviciu online."</string>
+    <string name="generic_no_account_prompt" msgid="7218827704367325460">"Păstrați agenda dvs. în condiții de siguranță, chiar dacă pierdeți telefonul, prin sincronizarea acesteia cu un serviciu online."</string>
     <string name="generic_no_account_prompt_title" msgid="753783911899054860">"Adăugați un cont"</string>
     <string name="contact_editor_prompt_zero_accounts" msgid="1785345895691886499">"Pentru noul contact nu se va crea o copie de rezervă. Adăugați un cont care creează online copii de rezervă pentru contacte?"</string>
     <string name="contact_editor_prompt_one_account" msgid="3087691056345099310">"Persoanele noi de contact vor fi salvate în <xliff:g id="ACCOUNT_NAME">%1$s</xliff:g>."</string>
     <string name="contact_editor_prompt_multiple_accounts" msgid="8565761674283473549">"Alegeți un cont prestabilit pentru persoanele de contact noi:"</string>
     <string name="contact_editor_title_new_contact" msgid="7192223018128934940">"Adăugați contact nou"</string>
     <string name="contact_editor_title_existing_contact" msgid="4898475703683187798">"Editați intrarea"</string>
-    <string name="keep_local" msgid="1258761699192993322">"Păstraţi local"</string>
+    <string name="keep_local" msgid="1258761699192993322">"Păstrați local"</string>
     <string name="add_account" msgid="8201790677994503186">"Adăugați un cont"</string>
     <string name="add_new_account" msgid="5748627740680940264">"Adăugați un cont nou"</string>
-    <string name="menu_export_database" msgid="2659719297530170820">"Exportaţi fişierele bazei de date"</string>
+    <string name="menu_export_database" msgid="2659719297530170820">"Exportați fișierele bazei de date"</string>
     <string name="action_menu_add_new_contact_button" msgid="3180222523336380017">"adăugați o persoană de contact nouă"</string>
     <string name="expanding_entry_card_view_see_more" msgid="3779194067124758079">"Mai multe detalii"</string>
     <string name="expanding_entry_card_view_see_less" msgid="5344160551629714168">"Mai puține detalii"</string>
@@ -274,7 +277,7 @@
     <string name="header_note_entry" msgid="4320190426480612344">"Notă"</string>
     <string name="header_website_entry" msgid="1411467850000824745">"Site web"</string>
     <string name="header_event_entry" msgid="6738250422744401460">"Eveniment"</string>
-    <string name="header_relation_entry" msgid="1520292958088146460">"Relaţie"</string>
+    <string name="header_relation_entry" msgid="1520292958088146460">"Relație"</string>
     <string name="header_account_entry" msgid="2684318506427891827">"Cont"</string>
     <string name="header_name_entry" msgid="1592791008096288306">"Nume"</string>
     <string name="header_email_entry" msgid="8666093061171624478">"E-mail"</string>
@@ -329,8 +332,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Toate fotografiile"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Alegeți o fotografie"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Din contul <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Ștergeți <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Ștergeți <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotografia din <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> nu e selectată"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotografia din <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> e selectată"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Fotografie neselectată dintr-un cont necunoscut"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Fotografie selectată dintr-un cont necunoscut"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Se actualizează lista de persoane din agendă pentru a reflecta modificarea limbii.\n\n Așteptați..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Numere blocate"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Apelurile și mesajele text de la aceste numere vor fi blocate."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adăugați un număr"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blocați numărul"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Adăugați număr/căutați contacte"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Apelurile și mesajele text de la acest număr vor fi blocate."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Deblocați <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"DEBLOCAȚI"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blocați <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCAȚI"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> a fost blocat"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> a fost deblocat"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> nu este valid."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blocarea apelurilor e dezactivată temporar"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Blocarea apelurilor a fost dezactivată, deoarece ați contactat serviciile de urgență de pe acest telefon în ultimele 48 de ore. Funcția va fi reactivată automat după ce perioada de 48 de ore va expira."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Anterior, ați marcat câteva persoane de contact pentru a fi redirecționate automat spre mesageria vocală. Importați acele numere aici pentru a bloca apelurile și mesajele text."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importați"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Vedeți numerele"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Adăugați un număr"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blocarea apelurilor este dezactivată pentru 48 de ore"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Dezactivată din cauza efectuării unui apel de urgență."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ANULAȚI"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> este deja blocat."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Deblocați numărul"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detalii de contact pentru <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importul nu a reușit"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importați numere"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Pentru a căuta în persoanele de contact, activați permisiunea Agendă."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Activați"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Numere blocate"</string>
 </resources>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 97a5a1f..16500dc 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Контакты"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Контакты"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Просмотреть контакт"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Изменить контакт"</string>
     <string name="contactsList" msgid="8661624236494819731">"Контакты"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Контакт"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Быстрый звонок"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Установить по умолчанию"</string>
     <string name="clear_default" msgid="7193185801596678067">"Удалить настройки по умолчанию"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Текст скопирован"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Удалить изменения?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Отменить"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Отменить изменения и завершить редактирование?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Отменить"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Продолжить редактирование"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> (<xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>)"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Настроить профиль"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Имя контакта"</string>
@@ -340,8 +343,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Все фото"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Выбор фото"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Из <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Удалить данные. <xliff:g id="DATA_TYPE">%s </xliff:g> <xliff:g id="DATA_KIND">%s</xliff:g>."</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Удалить <xliff:g id="DATA_KIND">%s</xliff:g>."</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Фото из аккаунта <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> не выбрано"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Фото из аккаунта <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> выбрано"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Выбор фото из неизвестного аккаунта отменен"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Выбрано фото из неизвестного аккаунта"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Выполняется обновление списка контактов, чтобы изменение языка вступило в силу.\n\nПодождите..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Заблокированные номера"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Вызовы и текстовые сообщения с этих номеров будут блокироваться."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Добавить номер"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Заблокировать номер"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Найдите контакт или введите номер"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Вызовы и текстовые сообщения с этого номера будут блокироваться."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Разблокировать <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"РАЗБЛОКИРОВАТЬ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Заблокировать <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БЛОКИРОВАТЬ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> заблокирован"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> разблокирован"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> недействителен."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Блокировка вызовов временно отключена"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Блокировка вызовов отключена, поскольку вы недавно набирали номер экстренной службы. Когда с момента звонка пройдет 48 часов, эта функция включится автоматически."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Вы настроили перенаправление вызовов от некоторых контактов в голосовую почту. Добавьте их номера сюда, чтобы полностью заблокировать звонки и текстовые сообщения от них."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Импортировать"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Просмотреть номера"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Добавить номер"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Блокировка вызовов отключена на 48 часов"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Блокировка звонков отключена из-за экстренного вызова"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ОТМЕНИТЬ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> уже заблокирован."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Разблокировать номер"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Сведения о контакте <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Ошибка импорта"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Импортировать номера"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Для поиска контактов включите разрешение \"Контакты\"."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Включить"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Заблокированные номера"</string>
 </resources>
diff --git a/res/values-si-rLK/strings.xml b/res/values-si-rLK/strings.xml
index 0045977..a648fde 100644
--- a/res/values-si-rLK/strings.xml
+++ b/res/values-si-rLK/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"සම්බන්ධතා"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"සම්බන්ධතා"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"සම්බන්ධතාව බැලීම"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"සම්බන්ධතාව සංස්කරණය කිරීම"</string>
     <string name="contactsList" msgid="8661624236494819731">"සම්බන්ධතා"</string>
     <string name="shortcutContact" msgid="749243779392912958">"සම්බන්ධතාවය"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ඍජු ඇමතීම"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"සුපුරුදු ලෙස සකසන්න"</string>
     <string name="clear_default" msgid="7193185801596678067">"සුපුරුදු හිස් කරන්න"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"පෙළ පිටපත් කරන ලදී"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ඔබගේ වෙනස්කම් ඉවතලන්නද?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"ඉවත ලන්න"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"ඔබේ වෙනස් කිරීම් ඉවත දමා සංස්කරණය කිරීමෙන් ඉවත් වන්නද?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"ඉවතලන්න"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"සංස්කරණය කරගෙන යන්න"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"මගේ පැතිකඩ සකසන්න"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"පුද්ගලයාගේ නම ටයිප් කරන්න"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> වෙතින්"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> මැකීම"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> මැකීම"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>වෙතින් ඡායාරූපය පරීක්ෂා කරන ලදී"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> වෙතින් ඡායාරූපය පරීක්ෂා කරන ලදී"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"නොදන්නා ගිණුම වෙතින් වන ඡායාරූපය ලකුණු නොකරන ලදී"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"නොදන්නා ගිණුම වෙතින් වන ඡායාරූපය ලකුණු කරන ලදී"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"භාෂා වෙනස්වීම පෙන්වීමට සම්බන්ධතා ලැයිස්තුව යාවත්කාලීන වෙමින් පවතී.\n\nකරුණාකර රැඳී සිටින්න..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"අවහිර කළ අංක"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"මෙම අංක වෙතින් වන ඇමතුම් හා පෙළ පණිවිඩ අවහිර කරනු ඇත."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"අංකයක් එක් කරන්න"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"අංකය අවහිර කරන්න"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"අංකය එක් කරන්න හෝ සම්බන්ධතා සොයන්න"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"මෙම අංකය වෙතින් වන ඇමතුම් හා පෙළ පණිවිඩ අවහිර කරනු ඇත."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> අවහිර නොකරන්නද?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"අවහිර නොකරන්න"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> අවහිර කරන්නද?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"අවහිරයි"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> අවහිරයි"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> අවහිර නැත"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> වලංගු නැත."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"ඇමතුම් අවහිර කිරීම තාවකාලිකව අක්‍රියයි"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ඔබ පසුගිය පැය 48 ඇතුළත මෙම දුරකථනයෙන් හදිසි අවස්ථා සේවා ඇමතූ බැව්න් ඇමතුම් අවහිර කිරීම අබල කර ඇත. පැය 48ක කාල සීමාව ඉකුත් වූ විට එය ස්වයංක්‍රියව යළි සබල කෙරේ."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ඔබ පෙරදී සමහර සම්බන්ධතා ස්වයංක්‍රියව හඬ තැපැල් යැවීමට ලකුණු කරන ලදී. ඇමතුම් සහ පෙළ පණිවිඩ යන දෙකම අවහිර කිරීමට එම අංක මෙතැනට ආයාත කරන්න."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"ආයාත කරන්න"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"අංක බලන්න"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"අංකයක් එක් කරන්න"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"පැය 48ක් සඳහා ඇමතුම් අවහිර කිරීම අබල කරන ලදී"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"හදිසි ඇමතුමක් සිදු කළ නිසා අබල කරන ලදී."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"අස් කරන්න"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> දැනටමත් අවහිර කර ඇත."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"අංකය අවහිර නොකරන්න"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> සඳහා ඇමතුම් විස්තර"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"අයාත කිරීම අසාර්ථක විය"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"අංක ආයාත කරන්න"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"ඔබේ සම්බන්ධතා සෙවීමට, සම්බන්ධතා අවසර ක්‍රියාත්මක කරන්න."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ක්‍රියාත්මක කරන්න"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"අවහිර කළ අංක"</string>
 </resources>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index 82f3a81..1d0ab59 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakty"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakty"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Zobraziť kontakt"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Upraviť kontakt"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakty"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Priame vytáčanie"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Nastaviť ako predvolené"</string>
     <string name="clear_default" msgid="7193185801596678067">"Vymazať predvolené nastavenia"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Text bol skopírovaný"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Chcete zmeny zahodiť?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Zahodiť"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Zahodiť zmeny a ukončiť upravovanie?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Zahodiť"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Pokračovať v úprave"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Nastaviť môj profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Zadajte meno osoby"</string>
@@ -340,8 +343,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Všetky fotky"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Výber fotky"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Z účtu <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Odstrániť položku <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Odstrániť položku <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotka účtu <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> nie je začiarknutá"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotka z účtu <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> je začiarknutá"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Fotka z neznámeho účtu nebola začiarknutá"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Fotka z neznámeho účtu bola začiarknutá"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"V súvislosti so zmenou jazyka prebieha aktualizácia zoznamu kontaktov.\n\nČakajte..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokované čísla"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Hovory aj textové správy z týchto čísel budú blokované."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Pridať číslo"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokovať číslo"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Pridajte číslo / vyhľadajte v kontaktoch"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Hovory a textové správy z tohto čísla budú blokované."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Odblokovať číslo <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ODBLOKOVAŤ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blokovať číslo <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKOVAŤ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> – blokované"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> – odblokované"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Číslo <xliff:g id="NUMBER">%1$s</xliff:g> je neplatné."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokovanie hovorov je dočasne vypnuté"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Pretože ste z tohto telefónu počas posledných 48 hodín volali na tiesňovú linku, blokovanie hovorov bolo vypnuté. Po uplynutí 48 hodín sa automaticky znova zapne."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"V minulosti ste niektoré kontakty označili, aby boli automaticky prepojené do hlasovej schránky. Importujte dané čísla na tomto mieste a zablokujte tak hovory aj textové správy z nich."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importovať"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Zobraziť čísla"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Pridať číslo"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blokovanie hovorov je deaktivované na 48 hodín"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Deaktivované, pretože ste uskutočnili tiesňové volanie"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"SPÄŤ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Číslo <xliff:g id="NUMBER">%1$s</xliff:g> je už blokované."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Zrušiť blokovanie čísla"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Podrobnosti kontaktu pre <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import zlyhal"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importovať čísla"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Ak chcete hľadať kontakty, zapnite povolenie Kontakty."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Zapnúť"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokované čísla"</string>
 </resources>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 10959d2..cee7907 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Stiki"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Stiki"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Ogled stika"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Urejanje stika"</string>
     <string name="contactsList" msgid="8661624236494819731">"Stiki"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Vizitka"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Bližnjice za klicanje"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Nastavi za privzeto"</string>
     <string name="clear_default" msgid="7193185801596678067">"Počisti privzeto"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Besedilo kopirano"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Ali želite zavreči spremembe?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Zavrzi"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Želite zavreči spremembe in prenehati urejati?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Zavrzi"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Nadaljevanje urejanja"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Nastavi moj profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Vnesite ime osebe"</string>
@@ -340,8 +343,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Vse fotografije"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Izbira fotografije"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Od: <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Izbriši <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Izbriši <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotografija iz <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> ni označena"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotografija iz <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> je označena"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Fotografija iz neznanega računa ni izbrana"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Fotografija iz neznanega računa je izbrana"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Seznam stikov se posodablja po spremembi jezika.\n\nPočakajte ..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blokirane številke"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Klici in SMS-ji s teh številk bodo blokirani."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj telefonsko številko"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blokiraj številko"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Dodajte št. ali iščite med st."</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Klici in SMS-ji s te številke bodo blokirani."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Želite odblokirati številko <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ODBLOKIRAJ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Želite blokirati številko <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKIRAJ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Številka <xliff:g id="NUMBER">%1$s</xliff:g> je blokirana"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Številka <xliff:g id="NUMBER">%1$s</xliff:g> je odblokirana"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Telefonska številka <xliff:g id="NUMBER">%1$s</xliff:g> je neveljavna."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blokiranje klicev je začasno izklopljeno"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Blokiranje klicev je onemogočeno, ker ste se v zadnjih 48 urah s tem telefonom obrnili na nujno pomoč. Ko 48-urno obdobje poteče, bo blokiranje klicev samodejno znova omogočeno."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Označili ste, naj bodo nekateri stiki samodejno preusmerjeni v odzivnik. Uvozite te številke zaradi blokiranja klicev in SMS-jev."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Uvozi"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Ogled številk"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Dodaj telefonsko številko"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Blokiranje klicev je onemogočeno za 48 ur"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Onemogočeno zaradi opravljenega klica v sili"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"RAZVELJAVI"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Telefonska številka <xliff:g id="NUMBER">%1$s</xliff:g> je že blokirana."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Odblokiranje telefonske številke"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Podrobnosti stika za <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Uvoz ni uspel"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Uvoz številk"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Če želite iskati po stikih, vklopite dovoljenje za stike."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Vklop"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blokirane številke"</string>
 </resources>
diff --git a/res/values-sq-rAL/strings.xml b/res/values-sq-rAL/strings.xml
index 59f9239..b1a0895 100644
--- a/res/values-sq-rAL/strings.xml
+++ b/res/values-sq-rAL/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktet"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktet"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Shiko kontaktin"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Modifiko kontaktin"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontaktet"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakti"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Telefonatë e drejtpërdrejtë"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Vendos të parazgjedhurën"</string>
     <string name="clear_default" msgid="7193185801596678067">"Pastro të paracaktuarin"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Teksti u kopjua"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Të hiqet dorë nga ndryshimet?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Hiq"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Hiqi ndryshimet dhe mbylle redaktimin?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Hiq"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Vazhdo redaktimin"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Konfiguro profilin tim"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Shkruaj emrin e personit"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Të gjitha fotografitë"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Zgjidh fotografinë"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Nga <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Fshi <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Fshi <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Nuk është shënuar fotografia nga <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Është shënuar fotografia nga <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Nuk është zgjedhur fotografi nga llogari e panjohur"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Është zgjedhur fotografi nga llogari e panjohur"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Lista e kontakteve po përditësohet për të pasqyruar ndryshimin e gjuhës.\n\nQëndro në pritje..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Numrat e bllokuar"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Telefonatat dhe mesazhet me tekst nga këta numra do të bllokohen."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Shto një numër"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blloko numrin"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Shto një numër ose kërko te kontaktet"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Telefonatat dhe mesazhet me tekst nga ky numër do të bllokohen."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Zhblloko <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ZHBLLOKO"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Blloko <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLLOKO"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> u bllokua"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> u zhbllokua"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> është i pavlefshëm."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Bllokimi i telefonatave është përkohësisht joaktiv"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Bllokimi i telefonatave është çaktivizuar sepse kontaktove me shërbimet e urgjencës nga ky telefon brenda 48 orëve të fundit. Ai do të riaktivizohet automatikisht pas skadimit të periudhës prej 48 orë."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Ke shënuar më parë disa kontakte që të dërgohen automatikisht te posta zanore. Importoji ata numra këtu për të bllokuar telefonatat si dhe mesazhet me tekst."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importo"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Shiko numrat"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Shto një numër"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Bllokimi i thirrjeve është çaktivizuar për 48 orë"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Është e çaktivizuar për shkak se është kryer një telefonatë urgjence."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ZHBËJ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> është i bllokuar tashmë."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Zhblloko numrin"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Detajet e kontaktit për <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Importimi dështoi"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importo numrat"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Për të kërkuar kontaktet, aktivizo lejet e Kontakteve"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktivizo"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Numrat e bllokuar"</string>
 </resources>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 2f5bf25..2fc68d6 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Контакти"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Контакти"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Прикажи контакт"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Измени контакт"</string>
     <string name="contactsList" msgid="8661624236494819731">"Контакти"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Контакт"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Директно бирање"</string>
@@ -231,8 +233,9 @@
     <string name="set_default" msgid="4417505153468300351">"Постави на подразумевано"</string>
     <string name="clear_default" msgid="7193185801596678067">"Обриши подразумевану вредност"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Текст је копиран"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Желите ли да одбаците промене?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Одбаци"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Желите ли да одбаците промене и прекинете са изменама?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Одбаци"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Настави изменe"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Подеси мој профил"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Унесите име особе"</string>
@@ -329,8 +332,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Све слике"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Изаберите слику"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Са <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Избриши <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Избриши <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Слика са <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> налога <xliff:g id="USER_NAME">%s </xliff:g> није означена"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Слика са <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> налога <xliff:g id="USER_NAME">%s </xliff:g> је означена"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Слика са непознатог налога није означена"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Слика са непознатог налога је означена"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Листа контаката се тренутно ажурира како би се применила промена језика.\n\nСачекајте..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Блокирани бројеви"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Позиви и SMS-ови са ових бројева ће бити блокирани."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Додај број"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Блокирај број"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Додајте број или претражите контакте"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Позиви и SMS-ови са овог броја ће бити блокирани."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Желите ли да деблокирате <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ДЕБЛОКИРАЈ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Желите ли да блокирате <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БЛОКИРАЈ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> је блокиран"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> је деблокиран"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> је неважећи."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Блокирање позива је привремено искључено"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Блокирање позива је онемогућено зато што сте контактирали службе за помоћ у хитним случајевима са овог телефона у последњих 48 сати. Аутоматски ће бити поново омогућено када истекне период од 48 сати."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Раније сте означили неке бројеве које аутоматски треба преусмерити на говорну пошту. Увезите те бројеве да бисте блокирали позиве и SMS-ове."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Увeзи"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Прикажи бројеве"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Додај број"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Блокирање позива је онемогућено на 48 сати"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Онемогућено је зато што је упућен хитан позив."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ОПОЗОВИ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> је већ блокиран."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Деблокирај број"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Детаљи о контакту за <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Увоз није успео"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Увези бројеве"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Да бисте претражили контакте, укључите дозволе за Контакте."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Укључи"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Блокирани бројеви"</string>
 </resources>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 124c5af..1163603 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontakter"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontakter"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Visa kontakt"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Redigera kontakt"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontakter"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direktval"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Ange standard"</string>
     <string name="clear_default" msgid="7193185801596678067">"Rensa standardinställningar"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Texten har kopierats"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Vill du ta bort ändringarna?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Ignorera"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Vill du tar bort ändringarna och sluta redigera?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Ignorera"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Fortsätt redigera"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Skapa min profil"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Ange personens namn"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Alla foton"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Välj foto"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Från <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Radera <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Radera <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotot från <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> har inte markerats"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotot från <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> har markerats"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Ett foto från ett okänt konto har inte markerats"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Ett foto från ett okänt konto har markerats"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kontaktlistan uppdateras så att språkändringen visas.\n\nVänta..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Blockerade nummer"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Samtal och sms från de här numren blockeras."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Lägg till telefonnummer"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Blockera nummer"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Ange nummer eller kontakt"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Samtal och sms från det här numret blockeras."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Vill du häva blockeringen av <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"HÄV BLOCKERINGEN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Vill du blockera <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOCKERA"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> har blockerats"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Blockeringen av <xliff:g id="NUMBER">%1$s</xliff:g> har hävts"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> är inte giltigt."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Blockeringen har inaktiverats tillfälligt"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Samtalsblockering har inaktiverats eftersom du ringde ett larmnummer från den här mobilen under de senaste 48 timmarna. Blockeringen aktiveras igen när 48 timmar har gått."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Du har tidigare angett att samtal från vissa kontakter ska skickas direkt till röstbrevlådan. Importera numren här om du vill blockera både samtal och sms."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Importera"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Visa telefonnummer"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Lägg till telefonnummer"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Samtalsblockeringen har inaktiverats i 48 timmar"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Inaktiverades därför att enheten har använts för ett nödsamtal."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ÅNGRA"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> är redan blockerat."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Häv blockeringen av numret"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Kontaktuppgifter för <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Det gick inte att importera"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Importera nummer"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Aktivera behörigheter för Kontakter om du vill söka bland kontakterna."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aktivera"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Blockerade nummer"</string>
 </resources>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index 5fb32b2..56febb5 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Anwani"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Anwani"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Angalia Anwani"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Badilisha Anwani"</string>
     <string name="contactsList" msgid="8661624236494819731">"Anwani"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Anwani"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Upigaji wa moja kwa moja"</string>
@@ -220,12 +222,13 @@
       <item quantity="one">Mtu <xliff:g id="COUNT_0">%1$d</xliff:g></item>
     </plurals>
     <string name="toast_join_with_empty_contact" msgid="1215465657839085613">"Andika jina ya anwani kabla ya kuiunganisha na nyingine."</string>
-    <string name="copy_text" msgid="3257145021583508761">"Nakili kwenye ubao wa klipu"</string>
+    <string name="copy_text" msgid="3257145021583508761">"Nakili kwenye ubao wa kunakili"</string>
     <string name="set_default" msgid="4417505153468300351">"Weka chaguo-msingi"</string>
     <string name="clear_default" msgid="7193185801596678067">"Ondoa chaguo-msingi"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Maandishi yamenakiliwa"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Tupa mabadiliko yako?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Tupa"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Je, ungependa kutupa mabadiliko yako na uache kubadilisha?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Tupa"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Endelea kubadilisha"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Unda wasifu wangu"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Charaza jina la mtu"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Picha zote"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Chagua picha"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Kutoka kwa <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Futa <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Futa <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Picha kutoka <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> haijateuliwa"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Picha kutoka <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> imeteuliwa"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Picha kutoka akaunti isiyojulikana haijateuliwa"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Picha kutoka akaunti isiyojulikana imeteuliwa"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Orodha ya anwani inasasishwa ili kuonesha mabadiliko ya lugha.\n\nTafadhali subiri..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Nambari zilizozuiwa"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Simu na ujumbe kutoka kwa nambari hizi zitazuiwa."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ongeza nambari"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Zuia nambari"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Ongeza nambari au utafute anwani"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Simu na ujumbe kutoka kwa nambari hii zitazuiwa."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Ungependa kuondoa kizuizi kwenye <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ONDOA KIZUIZI"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Ungependa kuzuia <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ZUIA"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> imezuiwa"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> imeondolewa kizuizi"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> si sahihi."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Kuzuia simu kumezimwa kwa muda"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Kipengele cha kuzuia simu kimezimwa kwa sababu uliwasiliana na huduma za dharura kwenye simu hii ndani ya saa 48 zilizopita. Kipengele hiki kitawashwa kiotomatiki baada ya kipindi cha saa 48 kumalizika."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Ulitia baadhi ya anwani alama awali ili zitumwe kwenye ujumbe wa sauti kiotomatiki. Hamisha nambari hizo hapa ili uzuie simu na ujumbe."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Leta"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Angalia Nambari"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Ongeza nambari"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Huduma ya kuzuia simu imezimwa kwa saa 48"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Imezimwa kwa sababu simu ya dharura imepigwa."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"TENDUA"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> tayari imezuiwa."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Ondolea nambari kizuizi"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Maelezo ya <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Imeshindwa kuingiza"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Leta nambari"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Ili utafute anwani zako, washa ruhusa za Anwani."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Washa"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Nambari zilizozuiwa"</string>
 </resources>
diff --git a/res/values-ta-rIN/strings.xml b/res/values-ta-rIN/strings.xml
index 4cd20e8..8678bd3 100644
--- a/res/values-ta-rIN/strings.xml
+++ b/res/values-ta-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"தொடர்புகள்"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"தொடர்புகள்"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"தொடர்பைக் காட்டு"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"தொடர்பைத் திருத்து"</string>
     <string name="contactsList" msgid="8661624236494819731">"தொடர்புகள்"</string>
     <string name="shortcutContact" msgid="749243779392912958">"தொடர்பு"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"நேரடி டயல்"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"இயல்புநிலையாக அமை"</string>
     <string name="clear_default" msgid="7193185801596678067">"இயல்பை அழி"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"உரை நகலெடுக்கப்பட்டது"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"மாற்றங்களை விலக்கவா?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"நிராகரி"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"மாற்றங்களை நிராகரித்து, திருத்துவதிலிருந்து வெளியேறவா?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"நிராகரி"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"தொடர்ந்து திருத்து"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"எனது சுயவிவரத்தை அமை"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"பெயரை உள்ளிடவும்"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> இலிருந்து"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>ஐ நீக்கு"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g>ஐ நீக்கு"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> வழங்கிய படம் தேர்ந்தெடுக்கப்படவில்லை"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> வழங்கிய படம் தேர்ந்தெடுக்கப்பட்டது"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"அறியப்படாத கணக்கிலிருந்து படம் தேர்ந்தெடுக்கப்படவில்லை"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"அறியப்படாத கணக்கிலிருந்து படம் தேர்ந்தெடுக்கப்பட்டது"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"மொழி மாற்றத்தைக் காட்ட, தொடர்புப் பட்டியல் புதுப்பிக்கப்படுகிறது.\n\nகாத்திருக்கவும்..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"எண்கள் தடுக்கப்பட்டன"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"இந்த எண்களின் அழைப்புகளும் உரைச்செய்திகளும் தடுக்கப்படும்."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"எண்ணைச் சேர்"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"எண்ணைத் தடு"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"எண்ணைச் சேர்க்கவும் அல்லது தொடர்புகளில் தேடவும்"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"இந்த எண்ணின் அழைப்புகளும் உரைச்செய்திகளும் தடுக்கப்படும்."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g>ஐ அனுமதிக்கவா?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"அனுமதி"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g>ஐத் தடுக்கவா?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"தடு"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> தடுக்கப்பட்டது"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> அனுமதிக்கப்பட்டது"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> தவறானது."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"அழைப்புத் தடுப்பு அம்சம் தற்காலிகமாக முடக்கப்பட்டுள்ளது"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"கடந்த 48 மணிநேரத்தில், இந்த ஃபோனிலிருந்து அவசர அழைப்பு எண்ணைத் தொடர்புகொண்டதால் அழைப்புத் தடுப்பு அம்சம் முடக்கப்பட்டுள்ளது. 48 மணிநேரம் கழித்து, இந்த அம்சம் தானாகவே மீண்டும் இயக்கப்படும்."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ஏற்கனவே சில தொடர்புகளை, குரலஞ்சலுக்குத் தானாக அனுப்பும்படி குறித்துள்ளீர்கள். அழைப்புகளையும் உரைச்செய்திகளையும் தடுக்க, அந்த எண்களை இங்கே இறக்கவும்."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"இறக்கு"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"எண்களைக் காட்டு"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"எண்ணைச் சேர்"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"அழைப்புத் தடுப்பு 48 மணிநேரத்திற்கு முடக்கப்பட்டுள்ளது"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"அவசர அழைப்பு செய்திருப்பதால், அழைப்புத் தடுப்பு முடக்கப்பட்டது."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"செயல்தவிர்"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ஏற்கனவே தடுக்கப்பட்டுள்ளது."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"எண்ணை அனுமதி"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> க்கான தொடர்பு விவரங்கள்"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"இறக்குவதில் தோல்வி"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"எண்களை இறக்கு"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"தொடர்புகளைத் தேட, தொடர்புகள் அனுமதிகளை இயக்கவும்."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"இயக்கு"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"தடுக்கப்பட்ட எண்கள்"</string>
 </resources>
diff --git a/res/values-te-rIN/strings.xml b/res/values-te-rIN/strings.xml
index e75fc78..dd10039 100644
--- a/res/values-te-rIN/strings.xml
+++ b/res/values-te-rIN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"పరిచయాలు"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"పరిచయాలు"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"పరిచయాన్ని వీక్షించండి"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"పరిచయాన్ని సవరించండి"</string>
     <string name="contactsList" msgid="8661624236494819731">"పరిచయాలు"</string>
     <string name="shortcutContact" msgid="749243779392912958">"పరిచయం"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"డైరెక్ట్ డయల్"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"డిఫాల్ట్‌గా సెట్ చేయి"</string>
     <string name="clear_default" msgid="7193185801596678067">"డిఫాల్ట్‌ను క్లియర్ చేయి"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"వచనం కాపీ చేయబడింది"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"మీ మార్పులను విస్మరించాలా?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"విస్మరించు"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"మీ మార్పులను విస్మరించి, సవరణ నుండి నిష్క్రమించాలా?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"విస్మరించు"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"సవరణను కొనసాగించు"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"నా ప్రొఫైల్‌ను సెటప్ చేయి"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"వ్యక్తి పేరు టైప్ చేయండి"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> నుండి"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>ని తొలగిస్తుంది"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g>ని తొలగిస్తుంది"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>లోని ఫోటో ఎంచుకోబడలేదు"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>లోని ఫోటో ఎంచుకోబడింది"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"తెలియని ఖాతా నుండి అందించబడిన ఫోటో ఎంచుకోబడలేదు"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"తెలియని ఖాతా నుండి అందించబడిన ఫోటో ఎంచుకోబడింది"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"భాష మార్పుని చూపడానికి పరిచయ జాబితా నవీకరించబడుతోంది.\n\nదయచేసి వేచి ఉండండి..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"బ్లాక్ చేయబడిన నంబర్‌లు"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ఈ నంబర్‌ల నుండి కాల్‌లు మరియు వచన సందేశాలు బ్లాక్ చేయబడతాయి."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"నంబర్‌ను జోడించు"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"నంబర్‌ను బ్లాక్ చేయి"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"నంబర్ జోడించండి లేదా పరిచయాల్లో శోధించండి"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ఈ నంబర్ నుండి కాల్‌లు మరియు వచన సందేశాలు బ్లాక్ చేయబడతాయి."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g>ని అన్‌బ్లాక్ చేయాలా?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"అన్‌బ్లాక్ చేయి"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g>ని బ్లాక్ చేయాలా?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"బ్లాక్ చేయి"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> బ్లాక్ చేయబడింది"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> అన్‌బ్లాక్ చేయబడింది"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> చెల్లదు."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"కాల్ బ్లాకింగ్ తాత్కాలికంగా ఆఫ్ అయ్యింది"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"మీరు గత 48 గంటల వ్యవధిలో ఈ ఫోన్ నుండి అత్యవసర సేవలను సంప్రదించినందున కాల్ బ్లాకింగ్ నిలిపివేయబడింది. 48 గంటల వ్యవధి ముగిసిన తర్వాత ఇది స్వయంచాలకంగా పునఃప్రారంభించబడుతుంది."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"మీరు ఇంతకుముందే కొన్ని పరిచయాలను స్వయంచాలకంగా వాయిస్‌మెయిల్‌కి పంపేందుకు గుర్తు పెట్టారు. కాల్‌లు మరియు వచన సందేశాలు రెండింటినీ బ్లాక్ చేయడానికి ఆ నంబర్‌లను ఇక్కడ దిగుమతి చేయండి."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"దిగుమతి చేయి"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"నంబర్‌లను వీక్షించండి"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"నంబర్‌ను జోడించు"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"48 గంటల పాటు కాల్ బ్లాకింగ్ నిలిపివేయబడింది"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"అత్యవసర కాల్ చేసినందున నిలిపివేయబడింది."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"రద్దు చేయి"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ఇప్పటికే బ్లాక్ చేయబడింది."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"నంబర్‌ను అన్‌బ్లాక్ చేయి"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> యొక్క సంప్రదింపు వివరాలు"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"దిగుమతి విఫలమైంది"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"నంబర్‌లను దిగుమతి చేయి"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"మీ పరిచయాలను శోధించడానికి, పరిచయాల అనుమతులను ఆన్ చేయండి."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"ఆన్ చేయి"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"బ్లాక్ చేయబడిన నంబర్‌లు"</string>
 </resources>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 54597bc..e93c812 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"รายชื่อติดต่อ"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"รายชื่อติดต่อ"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"ดูรายชื่อติดต่อ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"แก้ไขรายชื่อติดต่อ"</string>
     <string name="contactsList" msgid="8661624236494819731">"รายชื่อในสมุดโทรศัพท์"</string>
     <string name="shortcutContact" msgid="749243779392912958">"สมุดโทรศัพท์"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"โทรโดยตรง"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ตั้งเป็นค่าเริ่มต้น"</string>
     <string name="clear_default" msgid="7193185801596678067">"ล้างจากค่าเริ่มต้น"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"คัดลอกข้อความแล้ว"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"ยกเลิกการเปลี่ยนแปลงหรือไม่"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"ยกเลิก"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"ยกเลิกการเปลี่ยนแปลงและออกจากการแก้ไขใช่ไหม"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"ยกเลิก"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"แก้ไขต่อ"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"ตั้งค่าโปรไฟล์ของฉัน"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"พิมพ์ชื่อของบุคคล"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"รูปภาพทั้งหมด"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"เลือกรูปภาพ"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"จาก <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"ลบ<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"ลบ <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"ไม่ได้เลือกรูปภาพจาก <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"เลือกรูปภาพจาก <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"รูปภาพนี้ไม่ได้เลือกจากบัญชีที่ไม่รู้จัก"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"รูปภาพนี้เลือกจากบัญชีที่ไม่รู้จัก"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"กำลังอัปเดตรายการสมุดโทรศัพท์เพื่อแสดงการเปลี่ยนภาษา\n\nโปรดรอสักครู่..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"หมายเลขที่ถูกบล็อก"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ระบบจะบล็อกสายเรียกเข้าและข้อความจากหมายเลขเหล่านี้"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"เพิ่มหมายเลข"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"บล็อกหมายเลข"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"เพิ่มหมายเลขหรือค้นหาผู้ติดต่อ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"ระบบจะบล็อกสายเรียกเข้าและข้อความจากหมายเลขนี้"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"เลิกบล็อก <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"เลิกบล็อก"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"บล็อก <xliff:g id="NUMBER">%1$s</xliff:g> ไหม"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"บล็อก"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"บล็อก <xliff:g id="NUMBER">%1$s</xliff:g> แล้ว"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"เลิกบล็อก <xliff:g id="NUMBER">%1$s</xliff:g> แล้ว"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ไม่ถูกต้อง"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"การบล็อกสายเรียกเข้าปิดชั่วคราว"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"ระบบปิดใช้การบล็อกสายเรียกเข้าเนื่องจากคุณติดต่อบริการฉุกเฉินจากโทรศัพท์เครื่องนี้ภายใน 48 ชั่วโมงที่ผ่านมา ระบบจะเปิดใช้คุณลักษณะนี้อีกครั้งโดยอัตโนมัติเมื่อครบ 48 ชั่วโมง"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"ก่อนหน้านี้คุณได้ทำเครื่องหมายรายชื่อติดต่อบางรายการให้ส่งไปยังข้อความเสียงโดยอัตโนมัติ โปรดนำเข้าหมายเลขดังกล่าวที่นี่เพื่อบล็อกทั้งสายเรียกเข้าและข้อความ"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"นำเข้า"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"ดูหมายเลข"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"เพิ่มหมายเลข"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"ปิดการบล็อกสายเรียกเข้า 48 ชั่วโมง"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"ปิดใช้งานเนื่องจากมีการโทรเข้าหมายเลขฉุกเฉิน"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"เลิกทำ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> ถูกบล็อกอยู่แล้ว"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"เลิกบล็อกหมายเลข"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"รายละเอียดรายชื่อติดต่อสำหรับ <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"การนำเข้าล้มเหลว"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"นำเข้าหมายเลข"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"หากต้องการค้นหารายชื่อติดต่อ ให้เปิดสิทธิ์เข้าถึงรายชื่อติดต่อ"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"เปิด"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"หมายเลขที่ถูกบล็อก"</string>
 </resources>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index b5cb826..2dd5df0 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Mga Contact"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Mga Contact"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Tingnan ang Contact"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"I-edit ang Contact"</string>
     <string name="contactsList" msgid="8661624236494819731">"Mga Contact"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Contact"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direktang pag-dial"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Itakda ang default"</string>
     <string name="clear_default" msgid="7193185801596678067">"I-clear ang default"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Kinopya ang teksto"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"I-discard ang iyong mga pagbabago?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"I-discard"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Gusto mo bang i-discard ang iyong mga pagbabago at huminto sa pag-e-edit?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"I-discard"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Patuloy na mag-edit"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"I-set up ang profile"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"I-type ang pangalan ng tao"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"Mula kay <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"I-delete ang <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"I-delete ang <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Hindi napili ang larawan sa <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Napili na ang larawan mula sa <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Hindi nilagyan ng check ang larawan mula sa isang hindi kilalang account"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Nalagyan na ng check ang larawan mula sa isang hindi kilalang account"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Ina-update ang listahan ng contact upang ipakita ang pagbabago ng wika.\n\nPakihintay..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Mga naka-block na numero"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Iba-block ang mga tawag at text mula sa mga numerong ito."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Magdagdag ng numero"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"I-block ang numero"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Magdagdag ng numero, maghanap sa contact"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Iba-block ang mga tawag at text mula sa numerong ito."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Gusto mo bang alisin sa pagkaka-block ang <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ALISIN SA PAGKAKA-BLOCK"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Gusto mo bang i-block ang <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"I-BLOCK"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Na-block ang <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Naalis sa pagkaka-block ang <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Hindi wasto ang <xliff:g id="NUMBER">%1$s</xliff:g>."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Pansamantalang na-off ang call blocking"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Na-disable ang pagba-block ng tawag dahil nakipag-ugnayan ka sa mga pang-emergency na serbisyo mula sa teleponong ito sa nakalipas na 48 oras. Awtomatiko itong muling i-enable kapag nag-expire na ang 48 oras."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Minarkahan mo dati ang ilang contact na awtomatikong ipadala sa voicemail. I-import ang mga numerong iyon dito upang ma-block ang mga tawag at text mula sa mga iyon."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"I-import"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Tingnan ang Numero"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Magdagdag ng numero"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Na-disable ang pagba-block ng tawag sa loob ng 48 oras"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Na-disable dahil tumawag para sa emergency."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"I-UNDO"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Naka-block na ang <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Alisin sa pagkaka-block ang numero"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Mga detalye sa pakikipag-ugnayan para kay/sa <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Hindi nakapag-import"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"I-import ang mga numero"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Upang hanapin ang iyong mga contact, i-on ang mga pahintulot sa Mga Contact."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"I-on"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Mga naka-block na numero"</string>
 </resources>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index 1317567..56e9899 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kişiler"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kişiler"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Kişiyi Göster"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Kişiyi Düzenle"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kişiler"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kişi"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Doğrudan çevirme"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Varsayılan olarak ayarla"</string>
     <string name="clear_default" msgid="7193185801596678067">"Varsayılanları temizle"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Metin kopyalandı"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Değişiklikleriniz silinsin mi?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Sil"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Değişiklikleriniz yok sayılsın ve düzenlemeden çıkılsın mı?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Yok say"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Düzenlemeye devam et"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Profilimi ayarla"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Kişinin adını yazın"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Tüm fotoğraflar"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Fotoğraf seçin"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> adlı hesaptan"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Sil: <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Sil: <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Fotoğraf: <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> işaretlenmedi"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Fotoğraf: <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> işaretlendi"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Bilinmeyen hesaptan fotoğraf işaretlenmedi"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Bilinmeyen hesaptan fotoğraf işaretlendi"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Kişi listesi, dil değişikliğini yansıtmak üzere güncelleniyor.\n\nLütfen bekleyin..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Engellenen numaralar"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Bu numaralardan gelen çağrılar ve kısa mesajlar engellenecektir."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Numara ekle"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Numarayı engelle"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Numara ekleyin veya kişi arayın"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Bu numaradan gelen çağrılar ve kısa mesajlar engellenecektir."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> numaralı telefonun engellemesi kaldırılsın mı?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"ENGELLEMEYİ KALDIR"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> numaralı telefon engellensin mi?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"ENGELLE"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> numaralı telefon engellendi"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> numaralı telefonun engellemesi kaldırıldı"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> numaralı telefon geçersiz."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Çağrı engelleme geçici olarak kapalı"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Son 48 saat içinde bu telefondan acil servislerle iletişimde bulunduğunuz için çağrı engelleme modu devre dışı bırakıldı. 48 saatlik süre dolduktan sonra çağrı engelleme modu otomatik olarak tekrar etkinleştirilecektir."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Bazı kişileri otomatik olarak sesli mesaja gönderilecek şekilde işaretlediniz. Hem çağrıları hem de kısa mesajları engellemek için o numaraları buraya aktarın."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"İçe aktar"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Numaraları Görüntüle"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Numara ekle"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Çağrı engelleme 48 saat süreyle devre dışı bırakıldı"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Acil durum çağrısı yapıldığından devre dışı bırakıldı."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"GERİ AL"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> numaralı telefon zaten engellendi."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Numaranın engellemesini kaldır"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> için kişi ayrıntıları"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"İçe aktarma başarısız oldu"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Numaraları içe aktar"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kişilerinizde arama yapmak için Kişiler izinlerini açın."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Aç"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Engellenen numaralar"</string>
 </resources>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index cecc49f..512f097 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Контакти"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Контакти"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Переглянути контакт"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Редагувати контакт"</string>
     <string name="contactsList" msgid="8661624236494819731">"Контакти"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Контакт"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Прямий набір"</string>
@@ -238,8 +240,9 @@
     <string name="set_default" msgid="4417505153468300351">"Установити за умовчанням"</string>
     <string name="clear_default" msgid="7193185801596678067">"Очистити налаштування за умовчанням"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Текст скопійовано"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Відхилити зміни?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Відхилити"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Відхилити зміни та закінчити редагування?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Відхилити"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Продовжити редагування"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Налаштувати профіль"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Введіть ім’я особи"</string>
@@ -342,4 +345,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"З облікового запису <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"Видалити <xliff:g id="DATA_TYPE">%s </xliff:g> <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Видалити <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Фото з <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> не вибрано"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Фото з <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> вибрано"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Фото з невідомого облікового запису не вибрано"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Фото з невідомого облікового запису вибрано"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Список контактів оновлено для відображення зміни мови.\n\nЗачекайте..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Заблоковані номери"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Виклики та SMS із цих номерів блокуватимуться."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Додати номер"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Заблокувати номер"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Введіть або знайдіть номер"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Виклики та SMS із цього номера блокуватимуться."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Розблокувати номер <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"РОЗБЛОКУВАТИ"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Заблокувати номер <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"БЛОКУВАТИ"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> заблоковано"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> розблоковано"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> недісний."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Блокування дзвінків тимчасово вимкнено"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Блокування дзвінків вимкнено, оскільки ви зверталися з цього телефона в екстрені служби протягом останніх 48 годин. Ця функція автоматично ввімкнеться, коли мине 48 годин."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Ви позначили контактів, чиї виклики мають автоматично спрямовуватися на голосову пошту. Додайте цих контактів тут, щоб заблокувати їхні виклики та SMS."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Імпортувати"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Переглянути номери"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Додати номер"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Блокування викликів вимкнено на 48 годин"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Блокування вимкнено, оскільки ви зробили екстрений виклик."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"ВІДМІНИТИ"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"Номер <xliff:g id="NUMBER">%1$s</xliff:g> уже заблоковано."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Розблокувати номер"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Відомості про контакт <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Не вдалось імпортувати"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Імпортувати номери"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Щоб шукати контакти, увімкніть дозвіл \"Контакти\"."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Увімкнути"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Заблоковані номери"</string>
 </resources>
diff --git a/res/values-ur-rPK/strings.xml b/res/values-ur-rPK/strings.xml
index 37cbd49..658a419 100644
--- a/res/values-ur-rPK/strings.xml
+++ b/res/values-ur-rPK/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"رابطے"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"رابطے"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"رابطہ دیکھیں"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"رابطہ میں ترمیم کریں"</string>
     <string name="contactsList" msgid="8661624236494819731">"رابطے"</string>
     <string name="shortcutContact" msgid="749243779392912958">"رابطہ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ڈائریکٹ ڈائل"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"ڈیفالٹ طے کریں"</string>
     <string name="clear_default" msgid="7193185801596678067">"ڈیفالٹ کو صاف کریں"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"متن کاپی ہوگیا"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"اپنی تبدیلیاں رد کریں؟"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"رد کریں"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"اپنی تبدیلیاں مسترد کریں اور ترمیم کرنا چھوڑ دیں؟"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"رد کریں"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"ترمیم کرنا جاری رکھیں"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"میرا پروفائل ترتیب دیں"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"شخص کا نام ٹائپ کریں"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"سبھی تصاویر"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"تصویر چنیں"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> سے"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g> حذف کریں"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g> حذف کریں"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> کی تصویر چیک نہیں ہوئی"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> کی تصویر چیک ہو گئی"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"نامعلوم اکاؤنٹ سے تصویر نشان زد نہیں ہے"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"نامعلوم اکاؤنٹ سے تصویر نشان زد ہے"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"زبان کی تبدیلی کو منعکس کرنے کیلئے رابطہ فہرست اپ ڈیٹ ہو رہی ہے\n\nبراہ کرم انتظار کریں…"</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"مسدود کردہ نمبرز"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"ان نمبروں سے کالیں اور متنی پیغامات مسدود کر دیے جائیں گے۔"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"نمبر شامل کریں"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"نمبر مسدود کریں"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"نمبر شامل کریں یا رابطے تلاش کریں"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"اس نمبرے سے کالیں اور متنی پیغامات مسدود کر دیے جائیں گے۔"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> غیر مسدود کریں؟"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"غیر مسدود کریں"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> مسدود کریں؟"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"مسدود کریں"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> مسدود ہو گیا"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> غیر مسدود ہو گیا"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> غلط ہے۔"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"کال مسدود کرنا عارضی طور پر آف ہے"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"کال مسدود کرنا غیر فعال کر دیا گیا ہے کیونکہ آپ نے پچھلے 48 گھنٹوں میں اس فون سے ہنگامی سروسز کے ساتھ رابطہ کیا تھا۔ جب 48 گھنٹے کا دورانیہ ختم ہوگا تو یہ خودکار طور پر دوبارہ فعال ہو جائے گا۔"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"آپ نے پہلے کچھ نمبرز کو خودکار طور پر صوتی میل کو بھیجے جانے کیلئے نشان زد کیا تھا۔ کالیں اور متنی پیغامات دونوں کو مسدود کرنے کیلئے ان نمبرز کو یہاں درآمد کریں۔"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"درآمد کریں"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"نمبرز دیکھیں"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"نمبر شامل کریں"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"کال مسدود کرنا 48 گھنٹے کیلئے غیر فعال ہو گیا"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"غیر فعال ہو گیا کیونکہ ایک ہنگامی کال کی گئی تھی۔"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"کالعدم کریں"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> پہلے ہی مسدود ہے۔"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"نمبر غیر مسدود کریں"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> کیلئے رابطہ کی تفصیلات"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"درآمد کرنا ناکام ہوگیا"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"نمبرز درآمد کریں"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"اپنے رابطوں کو تلاش کرنے کیلئے رابطوں کی اجازتیں آن کریں۔"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"آن کریں"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"مسدود کردہ نمبرز"</string>
 </resources>
diff --git a/res/values-uz-rUZ/strings.xml b/res/values-uz-rUZ/strings.xml
index 3d455f5..70fe8d2 100644
--- a/res/values-uz-rUZ/strings.xml
+++ b/res/values-uz-rUZ/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Kontaktlar"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Kontaktlar"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Kontaktni ko‘rish"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Kontaktni tahrirlash"</string>
     <string name="contactsList" msgid="8661624236494819731">"Kontaktlar"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Kontakt"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Tez terish"</string>
@@ -172,7 +174,7 @@
     <string name="search_results_searching" msgid="3984833028938569930">"Qidirilmoqda…"</string>
     <string name="menu_display_selected" msgid="6470001164297969034">"Tanlanganni ko‘rsatish"</string>
     <string name="menu_display_all" msgid="8887488642609786198">"Barchasini ko‘rsatish"</string>
-    <string name="menu_select_all" msgid="621719255150713545">"Barchasini tanlash"</string>
+    <string name="menu_select_all" msgid="621719255150713545">"Hammasini belgilash"</string>
     <string name="menu_select_none" msgid="7093222469852132345">"Barcha tanlashlarni bekor qilish"</string>
     <string name="add_new_entry_for_section" msgid="5223080690667565044">"Yangisini qo‘shish"</string>
     <string name="add_organization" msgid="7311893231158291197">"Tashkilot qo‘shish"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Standart sifatida o‘rnatish"</string>
     <string name="clear_default" msgid="7193185801596678067">"Standartni tozalash"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Matndan nuxsa olindi"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"O‘zgarishlar bekor qilinsinmi?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Bekor qilish"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"O‘zgarishlar bekor qilinib, chiqib ketilsinmi?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Bekor qilish"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Tahrirlashda davom etish"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Profilni sozlash"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Kontaktning ismi"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Barcha rasmlar"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Rasm tanlash"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"<xliff:g id="ACCOUNT_NAME">%s</xliff:g> tomonidan"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>ni o‘chirish"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"<xliff:g id="DATA_KIND">%s</xliff:g>ni o‘chirish"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> hisobi rasmi belgilanmagan"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> hisobi rasmi belgilangan"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Noma’lum hisobdan rasm tanlash bekor qilindi"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Noma’lum hisobdan rasm tanlandi"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Til o‘zgarishlarini aks ettirish uchun kontakt ro‘yxati yangilanmoqda.\n\nIltimos, kuting…"</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Bloklangan raqamlar"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Bu raqamlardan keladigan qo‘ng‘iroqlar va SMS xabarlar bloklanadi."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Raqam qo‘shish"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Raqamni bloklash"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Raqam qo‘shish yoki kontaktlardan qidirish"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Bu raqamdan kelgan qo‘ng‘iroqlar va SMS xabarlar bloklanadi."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"<xliff:g id="NUMBER">%1$s</xliff:g> raqami blokdan chiqarilsinmi?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"BLOKDAN CHIQARISH"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"<xliff:g id="NUMBER">%1$s</xliff:g> raqami bloklanilsinmi?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"BLOKLASH"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> raqami bloklandi"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> raqami blokdan chiqarildi"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"Noto‘g‘ri raqam: <xliff:g id="NUMBER">%1$s</xliff:g>."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Qo‘ng‘iroqlarni bloklash o‘chirilgan"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Oxirgi 48 soat ichida ushbu telefon orqali favqulodda xizmatlar bilan bog‘lanilganligi uchun qo‘ng‘iroqlarni bloklash o‘chirib qo‘yildi. 48 soatlik muddat tugagandan so‘ng bu avtomatik qayta yoqiladi."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Siz ba’zi kontaktlardan keladigan qo‘ng‘iroqlarni avtomatik ravishda ovozli pochtaga yo‘llaydigan qilib belgilagansiz. Kiruvchi qo‘ng‘iroq va SMS xabarlarni bloklash uchun ularning raqamlarini bu yerga import qiling."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Import qilish"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Sonini ko‘rish"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Raqam qo‘shish"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Qo‘ng‘iroqlarni bloklash 48 soat muddatga o‘chirildi"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Favqulodda qo‘ng‘iroq amalga oshirilgani uchun o‘chirildi."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"QAYTARISH"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> raqami allaqachon bloklangan."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Raqamni blokdan chiqarish"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g> uchun kontakt ma’lumotlari"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Import qilib bo‘lmadi"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Raqamlarni import qilish"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Kontaktlarni qidirish uchun “Kontaktlar” ruxsatnomasini yoqing."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Yoqish"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Bloklangan raqamlar"</string>
 </resources>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index cd0a167..50b7f83 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Danh bạ"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Danh bạ"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Xem liên hệ"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Chỉnh sửa địa chỉ liên hệ"</string>
     <string name="contactsList" msgid="8661624236494819731">"Danh bạ"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Liên hệ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Quay số trực tiếp"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Đặt mặc định"</string>
     <string name="clear_default" msgid="7193185801596678067">"Xóa mặc định"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Đã sao chép văn bản"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Hủy các thay đổi của bạn?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Hủy"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Hủy các thay đổi của bạn và thoát chỉnh sửa?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Hủy"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Tiếp tục chỉnh sửa"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Thiết lập hồ sơ"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Nhập tên của người này"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Tất cả ảnh"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Chọn ảnh"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Từ <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Xóa <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Xóa <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Ảnh từ <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>không được chọn"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Ảnh từ <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>được chọn"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Chưa chọn ảnh từ tài khoản không xác định"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Đã chọn ảnh từ tài khoản không xác định"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Danh bạ đang được cập nhật để phản ánh thay đổi ngôn ngữ.\n\nVui lòng đợi..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Số bị chặn"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Các cuộc gọi và tin nhắn từ những số này sẽ bị chặn."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Thêm số"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Chặn số"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Thêm số hoặc tìm kiếm danh bạ"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Các cuộc gọi và tin nhắn từ số này sẽ bị chặn."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Bỏ chặn <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"BỎ CHẶN"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Chặn <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"CHẶN"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"Đã chặn <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"Đã bỏ chặn <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> không hợp lệ."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Tạm thời tắt chặn cuộc gọi"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Tính năng chặn cuộc gọi đã bị tắt vì bạn đã liên hệ với dịch vụ khẩn cấp từ điện thoại này trong vòng 48 giờ qua. Tính năng này sẽ được bật lại tự động sau khi khoảng thời gian 48 giờ kết thúc."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Trước đây bạn đã đánh dấu một số liên hệ sẽ được tự động gửi tới thư thoại. Hãy nhập các số đó vào đây để chặn cả cuộc gọi và tin nhắn."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Nhập"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Xem số"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Thêm số"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Đã tắt tính năng chặn cuộc gọi trong 48 giờ"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Bị tắt vì bạn đã thực hiện cuộc gọi khẩn cấp."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"HOÀN TÁC"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> đã bị chặn."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Bỏ chặn số"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Chi tiết liên lạc cho <xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Nhập không thành công"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Nhập số"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Để tìm kiếm liên hệ của bạn, hãy bật quyền đối với Danh bạ."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Bật"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Số bị chặn"</string>
 </resources>
diff --git a/res/values-zh-rCN/donottranslate_config.xml b/res/values-zh-rCN/donottranslate_config.xml
deleted file mode 100644
index c5d3aea..0000000
--- a/res/values-zh-rCN/donottranslate_config.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2010, 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>
-    <!-- If true, an option is shown in Display Options UI to choose a sort order -->
-    <bool name="config_sort_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_sort_order_primary">true</bool>
-
-    <!-- If true, an option is shown in Display Options UI to choose a name display order -->
-    <bool name="config_display_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_display_order_primary">true</bool>
-    
-    <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
-    <bool name="config_editor_field_order_primary">false</bool>
-</resources>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index f78c06e..9e58ce1 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"通讯录"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"通讯录"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"查看联系人"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"修改联系人"</string>
     <string name="contactsList" msgid="8661624236494819731">"联系人"</string>
     <string name="shortcutContact" msgid="749243779392912958">"联系人"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"直接拨打电话"</string>
@@ -106,7 +108,7 @@
     <string name="removePhoto" msgid="4898105274130284565">"删除照片"</string>
     <string name="noContacts" msgid="4955659076981974652">"没有联系人"</string>
     <string name="noGroups" msgid="8614664663561385253">"没有任何群组。"</string>
-    <string name="noAccounts" msgid="7768267764545265909">"您需要拥有一个帐户才能创建群组。"</string>
+    <string name="noAccounts" msgid="7768267764545265909">"您需要拥有一个帐号才能创建群组。"</string>
     <string name="emptyGroup" msgid="7502116218697177370">"此群组中没有联系人。"</string>
     <string name="addPeopleToGroup" msgid="7879585947222263516">"要添加联系人，请修改该群组。"</string>
     <string name="savingContact" msgid="4075751076741924939">"正在保存联系人…"</string>
@@ -151,7 +153,7 @@
     <string name="menu_share" msgid="943789700636542260">"分享"</string>
     <string name="menu_add_contact" msgid="3198704337220892684">"添加到通讯录"</string>
     <string name="share_via" msgid="563121028023030093">"联系人分享方式"</string>
-    <string name="dialog_new_group_account" msgid="2318032089273496830">"要在哪个帐户下创建群组？"</string>
+    <string name="dialog_new_group_account" msgid="2318032089273496830">"要在哪个帐号下创建群组？"</string>
     <string name="audio_chat" msgid="2535716629358298691">"语音聊天"</string>
     <string name="video_chat" msgid="1872255818640336072">"视频聊天"</string>
     <string name="connections" msgid="8098440723172028350">"社交网络"</string>
@@ -159,7 +161,7 @@
     <string name="recent" msgid="2659189233141493004">"最新"</string>
     <string name="recent_updates" msgid="4267258535615860710">"最新动态"</string>
     <string name="account_type_format" msgid="718948015590343010">"<xliff:g id="SOURCE">%1$s</xliff:g> 联系人"</string>
-    <string name="google_account_type_format" msgid="5283997303922067997">"<xliff:g id="SOURCE">%1$s</xliff:g>帐户"</string>
+    <string name="google_account_type_format" msgid="5283997303922067997">"<xliff:g id="SOURCE">%1$s</xliff:g>帐号"</string>
     <!-- no translation found for from_account_format (4469138575127580203) -->
     <skip />
     <string name="contact_read_only" msgid="7421346527289472273">"无法通过此应用修改。"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"设置默认值"</string>
     <string name="clear_default" msgid="7193185801596678067">"清除默认值"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"文本已复制"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"要舍弃您所做的更改吗？"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"舍弃"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"要舍弃您所做的更改并停止修改吗？"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"舍弃"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"继续修改"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"设置我的个人资料"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"键入联系人的姓名"</string>
@@ -233,18 +236,17 @@
     <string name="local_profile_title" msgid="2021416826991393684">"我的本地个人资料"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"我的<xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>个人资料"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"显示所有联系人"</string>
-    <string name="no_account_prompt" msgid="6424883302325061025">"登录Google帐户可获得更棒的通讯录使用体验。\n\n• 可通过任意浏览器访问。\n• 安全妥善地备份您的联系人数据。"</string>
+    <string name="no_account_prompt" msgid="6424883302325061025">"登录Google帐号可获得更棒的通讯录使用体验。\n\n• 可通过任意浏览器访问。\n• 安全妥善地备份您的联系人数据。"</string>
     <string name="generic_no_account_prompt" msgid="7218827704367325460">"即使手机丢了，也能确保您的联系人信息的安全性：与在线服务同步。"</string>
-    <string name="generic_no_account_prompt_title" msgid="753783911899054860">"添加帐户"</string>
-    <string name="contact_editor_prompt_zero_accounts" msgid="1785345895691886499">"系统不会备份您的新联系人。要添加用于在线备份联系人的帐户吗？"</string>
-    <!-- no translation found for contact_editor_prompt_one_account (3087691056345099310) -->
-    <skip />
+    <string name="generic_no_account_prompt_title" msgid="753783911899054860">"添加帐号"</string>
+    <string name="contact_editor_prompt_zero_accounts" msgid="1785345895691886499">"系统不会备份您的新联系人。要添加用于在线备份联系人的帐号吗？"</string>
+    <string name="contact_editor_prompt_one_account" msgid="3087691056345099310">"新建的联系人将保存到 <xliff:g id="ACCOUNT_NAME">%1$s</xliff:g>。"</string>
     <string name="contact_editor_prompt_multiple_accounts" msgid="8565761674283473549">"选择用来保存新建联系人的默认帐号："</string>
     <string name="contact_editor_title_new_contact" msgid="7192223018128934940">"新增联系人"</string>
     <string name="contact_editor_title_existing_contact" msgid="4898475703683187798">"修改联系人"</string>
     <string name="keep_local" msgid="1258761699192993322">"本地保存"</string>
-    <string name="add_account" msgid="8201790677994503186">"添加帐户"</string>
-    <string name="add_new_account" msgid="5748627740680940264">"添加新帐户"</string>
+    <string name="add_account" msgid="8201790677994503186">"添加帐号"</string>
+    <string name="add_new_account" msgid="5748627740680940264">"添加新帐号"</string>
     <string name="menu_export_database" msgid="2659719297530170820">"导出数据库文件"</string>
     <string name="action_menu_add_new_contact_button" msgid="3180222523336380017">"添加新联系人"</string>
     <string name="expanding_entry_card_view_see_more" msgid="3779194067124758079">"查看更多"</string>
@@ -269,7 +271,7 @@
     <string name="header_website_entry" msgid="1411467850000824745">"网站"</string>
     <string name="header_event_entry" msgid="6738250422744401460">"活动"</string>
     <string name="header_relation_entry" msgid="1520292958088146460">"关系"</string>
-    <string name="header_account_entry" msgid="2684318506427891827">"帐户"</string>
+    <string name="header_account_entry" msgid="2684318506427891827">"帐号"</string>
     <string name="header_name_entry" msgid="1592791008096288306">"姓名"</string>
     <string name="header_email_entry" msgid="8666093061171624478">"电子邮件地址"</string>
     <string name="header_phone_entry" msgid="8450980572274173570">"电话号码"</string>
@@ -283,7 +285,7 @@
     <string name="content_description_recent_call_type_missed" msgid="7371810920196048204">"未接电话"</string>
     <string name="content_description_recent_call" msgid="5183800406316723676">"近期通话：<xliff:g id="CALL_TYPE">%s</xliff:g>，<xliff:g id="PHONE_NUMBER">%s</xliff:g>，<xliff:g id="DATE">%s</xliff:g>。点按可回拨。"</string>
     <string name="message_from_you_prefix" msgid="7180706529908434482">"您：<xliff:g id="SMS_BODY">%s</xliff:g>"</string>
-    <string name="contact_editor_hangouts_im_alert" msgid="114855385615225735">"请将联系人的环聊帐户信息输入到电子邮件地址字段或电话号码字段，以便获得更佳的环聊使用体验。"</string>
+    <string name="contact_editor_hangouts_im_alert" msgid="114855385615225735">"请将联系人的环聊帐号信息输入到电子邮件地址字段或电话号码字段，以便获得更佳的环聊使用体验。"</string>
     <string name="compact_editor_more_fields" msgid="5987638193568699600">"更多字段"</string>
     <string name="compact_editor_change_photo_content_description" msgid="5495487714301211540">"更换照片"</string>
     <string name="compact_editor_failed_to_load" msgid="4557094426388044958">"无法开启编辑器。"</string>
@@ -319,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"所有照片"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"选择照片"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"来源：<xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"删除<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"删除<xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"未选中来自 <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> 的照片"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"已选中来自 <xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g> 的照片"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"未选中来自未知帐号的照片"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"已选中来自未知帐号的照片"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"正在更新联系人列表，以反映语言的变更。\n\n请稍候..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"已屏蔽的号码"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"系统将屏蔽这些号码的来电和短信。"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"添加号码"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"屏蔽号码"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"添加号码或搜索联系人"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"系统将屏蔽该号码的来电和短信。"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"要取消屏蔽 <xliff:g id="NUMBER">%1$s</xliff:g> 吗？"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"取消屏蔽"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"要屏蔽 <xliff:g id="NUMBER">%1$s</xliff:g> 吗？"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"屏蔽"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"已屏蔽 <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"已取消屏蔽 <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> 无效。"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"来电拦截功能已暂时关闭"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"来电拦截功能已停用，因为您在过去 48 小时内使用该手机拨打了紧急服务电话。系统会在 48 小时的期限结束后自动重新启用该功能。"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"您之前曾将某些联系人设为自动转到语音信箱。您可以在此处导入这些号码，以便屏蔽这些号码的来电和短信。"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"导入"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"查看号码"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"添加号码"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"来电拦截功能将停用 48 小时"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"此功能已停用，因为您拨打了紧急呼救电话。"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"撤消"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> 已被屏蔽。"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"取消屏蔽号码"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>的详细联系信息"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"导入失败"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"导入号码"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"要搜索您的联系人，请开启“通讯录”权限。"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"开启"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"已屏蔽的号码"</string>
 </resources>
diff --git a/res/values-zh-rHK/strings.xml b/res/values-zh-rHK/strings.xml
index 8e91d6b..d606b43 100644
--- a/res/values-zh-rHK/strings.xml
+++ b/res/values-zh-rHK/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"通訊錄"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"通訊錄"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"查看聯絡人"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"編輯聯絡人"</string>
     <string name="contactsList" msgid="8661624236494819731">"通訊錄"</string>
     <string name="shortcutContact" msgid="749243779392912958">"聯絡人"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"直接撥號"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"設為預設"</string>
     <string name="clear_default" msgid="7193185801596678067">"清除預設值"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"文字已複製"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"要丟棄更改嗎？"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"捨棄"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"要捨棄變更並停止編輯嗎？"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"捨棄"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"繼續編輯"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"設定我的個人資料"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"輸入聯絡人名字"</string>
@@ -320,4 +323,39 @@
     <string name="contact_from_account_name" msgid="2078526819634079406">"來自 <xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
     <string name="editor_delete_view_description" msgid="8583095381562991959">"刪除<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
     <string name="editor_delete_view_description_short" msgid="7335518371270844912">"刪除<xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"未選擇 <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> 的相片"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"已選擇 <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> 的相片"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"未勾選不明帳戶中的相片"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"已勾選不明帳戶中的相片"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"正在更新聯絡人清單以反映語言變更。\n\n請稍候…"</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"已封鎖的號碼"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"系統會封鎖這些號碼的來電和短訊。"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"新增電話號碼"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"封鎖號碼"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"新增號碼或搜尋聯絡人"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"系統會封鎖這個號碼的來電和短訊。"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"要解除封鎖 <xliff:g id="NUMBER">%1$s</xliff:g> 嗎？"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"解除封鎖"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"要封鎖 <xliff:g id="NUMBER">%1$s</xliff:g> 嗎？"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"封鎖"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"已封鎖 <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"已解除封鎖 <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> 無效。"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"暫時關閉來電封鎖功能"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"您在過去 48 小時內曾經使用此手機聯絡緊急服務，因此來電封鎖功能已停用。系統會在 48 小時期限結束後自動重新啟用功能。"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"您之前曾將某些聯絡人設定為自動轉駁至留言信箱。在此匯入這些號碼，即可封鎖對方的來電和短訊。"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"匯入"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"查看電話號碼"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"新增電話號碼"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"已停用來電封鎖 (48 小時)"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"已撥打緊急電話，已停用來電封鎖功能。"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"復原"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"已封鎖 <xliff:g id="NUMBER">%1$s</xliff:g>。"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"解除封鎖號碼"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"「<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>」的聯絡人詳細資料"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"匯入失敗"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"匯入號碼"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"如要搜尋聯絡人，請開啟「通訊錄」權限。"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"開放權限"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"已封鎖的號碼"</string>
 </resources>
diff --git a/res/values-zh-rTW/donottranslate_config.xml b/res/values-zh-rTW/donottranslate_config.xml
deleted file mode 100644
index c5d3aea..0000000
--- a/res/values-zh-rTW/donottranslate_config.xml
+++ /dev/null
@@ -1,35 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!--
-/*
-** Copyright 2010, 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>
-    <!-- If true, an option is shown in Display Options UI to choose a sort order -->
-    <bool name="config_sort_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_sort_order_primary">true</bool>
-
-    <!-- If true, an option is shown in Display Options UI to choose a name display order -->
-    <bool name="config_display_order_user_changeable">false</bool>
-
-    <!-- If true, the default sort order is primary (i.e. by given name) -->
-    <bool name="config_default_display_order_primary">true</bool>
-    
-    <!-- If true, the order of name fields in the editor is primary (i.e. given name first) -->
-    <bool name="config_editor_field_order_primary">false</bool>
-</resources>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index b743705..1c25c3e 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"通訊錄"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"通訊錄"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"查看聯絡人"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"編輯聯絡人"</string>
     <string name="contactsList" msgid="8661624236494819731">"聯絡人"</string>
     <string name="shortcutContact" msgid="749243779392912958">"聯絡人"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"直接撥號"</string>
@@ -31,7 +33,7 @@
     <string name="starredList" msgid="4817256136413959463">"已加星號"</string>
     <string name="frequentList" msgid="7154768136473953056">"經常聯絡"</string>
     <string name="strequentList" msgid="5640192862059373511">"我的收藏"</string>
-    <string name="viewContactTitle" msgid="7989394521836644384">"聯絡人詳細資料"</string>
+    <string name="viewContactTitle" msgid="7989394521836644384">"聯絡資訊"</string>
     <string name="editContactDescription" msgid="2947202828256214947">"編輯聯絡人"</string>
     <string name="insertContactDescription" msgid="4709878105452681987">"建立聯絡人"</string>
     <string name="editGroupDescription" msgid="6321161304201540561">"編輯群組"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"設為預設值"</string>
     <string name="clear_default" msgid="7193185801596678067">"清除預設值"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"文字已複製"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"確定要捨棄變更？"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"捨棄"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"確定要捨棄變更並結束編輯嗎？"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"捨棄"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"繼續編輯"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"設定我的個人資料"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"輸入聯絡人的名稱"</string>
@@ -287,7 +290,7 @@
     <string name="compact_editor_change_photo_content_description" msgid="5495487714301211540">"更換相片"</string>
     <string name="compact_editor_failed_to_load" msgid="4557094426388044958">"無法開啟編輯器。"</string>
     <string name="compact_editor_account_selector_title" msgid="5119592614151786601">"儲存到"</string>
-    <string name="compact_editor_account_selector_description" msgid="2127184829759350507">"正在儲存到 <xliff:g id="ACCOUNT_NAME">%s</xliff:g>。輕按兩下即可選擇其他帳戶。"</string>
+    <string name="compact_editor_account_selector_description" msgid="2127184829759350507">"正在儲存到 <xliff:g id="ACCOUNT_NAME">%s</xliff:g>。輕觸兩下即可選擇其他帳戶。"</string>
     <plurals name="compact_editor_linked_contacts_selector_title" formatted="false" msgid="9156207930915878316">
       <item quantity="other">已連結的聯絡人 (<xliff:g id="COUNT">%d</xliff:g> 位)</item>
       <item quantity="one">已連結的聯絡人</item>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"所有相片"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"選擇相片"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"來自<xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"刪除<xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"刪除<xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"未勾選 <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> 的相片"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"已勾選 <xliff:g id="ACCOUNT_TYPE">%s </xliff:g> <xliff:g id="USER_NAME">%s </xliff:g> 的相片"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"未勾選不明帳戶中的相片"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"已勾選不明帳戶中的相片"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"正在更新聯絡人清單以反映語言變更。\n\n請稍候…"</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"已封鎖的號碼"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"系統會封鎖這些號碼的來電和簡訊。"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"新增號碼"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"封鎖號碼"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"新增號碼或搜尋聯絡人"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"系統會封鎖這組號碼的來電和簡訊。"</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"要解除封鎖 <xliff:g id="NUMBER">%1$s</xliff:g> 嗎？"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"解除封鎖"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"要封鎖 <xliff:g id="NUMBER">%1$s</xliff:g> 嗎？"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"封鎖"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"已封鎖 <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"已解除封鎖 <xliff:g id="NUMBER">%1$s</xliff:g>"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> 無效。"</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"來電封鎖功能已暫時關閉"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"由於您曾在過去 48 小時內使用這支手機撥打緊急服務電話，因此來電封鎖功能已停用。此功能停用達 48 小時後，將由系統自動重新啟用。"</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"您之前曾透過標示指定將某些聯絡人自動轉到語音信箱。您可以匯入這些聯絡人的號碼，即可封鎖對方的來電和簡訊。"</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"匯入"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"查看號碼"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"新增號碼"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"來電封鎖功能會停用 48 小時"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"由於您曾撥打緊急電話，因此本功能已停用。"</string>
+    <string name="block_number_undo" msgid="591338370336724156">"復原"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> 已在封鎖清單中。"</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"解除封鎖號碼"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"「<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>」的聯絡詳細資料"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"匯入失敗"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"匯入電話號碼"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"如要搜尋您的聯絡人，請開啟「聯絡人」存取權限。"</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"開啟"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"已封鎖的號碼"</string>
 </resources>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index a69d6f7..3868379 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -18,6 +18,8 @@
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="applicationLabel" msgid="3906689777043645443">"Oxhumana nabo"</string>
     <string name="launcherActivityLabel" msgid="6497230399032392417">"Oxhumana nabo"</string>
+    <string name="quickContactActivityLabel" msgid="7985456650689347268">"Buka oxhumana naye"</string>
+    <string name="editContactActivityLabel" msgid="1129944572070802839">"Hlela Othintana Naye"</string>
     <string name="contactsList" msgid="8661624236494819731">"Othi tana nabo"</string>
     <string name="shortcutContact" msgid="749243779392912958">"Othintana naye"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Ukudayela okuqondile"</string>
@@ -224,8 +226,9 @@
     <string name="set_default" msgid="4417505153468300351">"Hlela okuzenzakalelayo"</string>
     <string name="clear_default" msgid="7193185801596678067">"Sula okuzenzakalelayo"</string>
     <string name="toast_text_copied" msgid="5143776250008541719">"Umbhalo okopishiwe"</string>
-    <string name="cancel_confirmation_dialog_message" msgid="5885724679874403115">"Lahla izinguquko ozenzile?"</string>
-    <string name="cancel_confirmation_dialog_message_positive_button" msgid="5867089312833413172">"Lahla"</string>
+    <string name="cancel_confirmation_dialog_message" msgid="5058226498605989285">"Lahla izinguquko zakho bese uyeke ukuhlela?"</string>
+    <string name="cancel_confirmation_dialog_cancel_editing_button" msgid="3057023972074640671">"Lahla"</string>
+    <string name="cancel_confirmation_dialog_keep_editing_button" msgid="7737724111972855348">"Qhubeka uhlela"</string>
     <string name="call_type_and_date" msgid="747163730039311423">"<xliff:g id="CALL_TYPE">%1$s</xliff:g> <xliff:g id="CALL_SHORT_DATE">%2$s</xliff:g>"</string>
     <string name="profile_display_name" msgid="4127389543625918771">"Misa iphrofayli yami"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Thayipha igama lomuntu"</string>
@@ -318,8 +321,41 @@
     <string name="all_photos_button" msgid="1943122929420111351">"Zonke izithombe"</string>
     <string name="photo_picker_title" msgid="5272832995550042801">"Khetha isithombe"</string>
     <string name="contact_from_account_name" msgid="2078526819634079406">"Kusuka ku-<xliff:g id="ACCOUNT_NAME">%s</xliff:g>"</string>
-    <!-- no translation found for editor_delete_view_description (8583095381562991959) -->
-    <skip />
-    <!-- no translation found for editor_delete_view_description_short (7335518371270844912) -->
-    <skip />
+    <string name="editor_delete_view_description" msgid="8583095381562991959">"Susa <xliff:g id="DATA_TYPE">%s </xliff:g><xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="editor_delete_view_description_short" msgid="7335518371270844912">"Susa <xliff:g id="DATA_KIND">%s</xliff:g>"</string>
+    <string name="photo_view_description_not_checked" msgid="8876314195990885177">"Isithombe kusuka ku-<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>asimakiwe"</string>
+    <string name="photo_view_description_checked" msgid="3906597168607472795">"Isithombe kusuka ku-<xliff:g id="ACCOUNT_TYPE">%s </xliff:g><xliff:g id="USER_NAME">%s </xliff:g>simakiwe"</string>
+    <string name="photo_view_description_not_checked_no_info" msgid="2749154927006406981">"Isithombe esivela ku-akhawunti engaziwa asithikhiwe"</string>
+    <string name="photo_view_description_checked_no_info" msgid="4974335987092590591">"Isithombe esivela ku-akhawunti engaziwa sithikhiwe"</string>
+    <string name="locale_change_in_progress" msgid="1124266507671178413">"Uhlu lothintana naye luyabuyekezwa ukubonisa ushintsho lolimi.\n\nSicela ulinde..."</string>
+    <string name="blocked_numbers_title" msgid="6350716762304498682">"Izinombolo ezivinjiwe"</string>
+    <string name="blocked_number_header_message" msgid="7296377056254430077">"Amakholi kusuka kulezi zinombolo azovinjelwa."</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Engeza inombolo"</string>
+    <string name="search_shortcut_block_number" msgid="4787156645163436072">"Vimba inombolo"</string>
+    <string name="block_number_search_hint" msgid="5409571607043872758">"Engeza inombolo noma useshe oxhumana nabo"</string>
+    <string name="block_number_confirmation_message" msgid="4425497283298329703">"Amakholi nemibhalo kusuka kule nombolo kuzovinjelwa."</string>
+    <string name="unblock_number_confirmation_title" msgid="252824779504084354">"Vulela i-<xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="unblock_number_ok" msgid="6449899182699684786">"VULELA"</string>
+    <string name="block_number_confirmation_title" msgid="6862219558186931304">"Vimba <xliff:g id="NUMBER">%1$s</xliff:g>?"</string>
+    <string name="block_number_ok" msgid="770551992296781873">"VIMBA"</string>
+    <string name="snackbar_number_blocked" msgid="939830142765936021">"<xliff:g id="NUMBER">%1$s</xliff:g> ivinjiwe"</string>
+    <string name="snackbar_number_unblocked" msgid="4854738171099045912">"<xliff:g id="NUMBER">%1$s</xliff:g> vulela"</string>
+    <string name="invalidNumber" msgid="619058581062192851">"<xliff:g id="NUMBER">%1$s</xliff:g> ayivumelekile."</string>
+    <string name="blocked_numbers_disabled_emergency_header_label" msgid="7870947220238070418">"Ukuvimbela ikholi kuvalwe isikhashana"</string>
+    <string name="blocked_numbers_disabled_emergency_desc" msgid="7755803249073401381">"Ukuvimbela ikholi kukhutshaziwe ngoba uxhumane nabosizo oluphuthumayo kusukela kule foni phakathi kwamahora angu-48 wokugcina. Kuzophinda kunikwe amandla ngokuzenzakalela uma sokuphele isikhathi samahora angu-48."</string>
+    <string name="blocked_call_settings_import_description" msgid="9026101454390679399">"Ngaphambilini umake abanye oxhumana nabo ukuthi bathunyelwe ngokuzenzakalela kuvoyisimeyili. Ngenisa lezo zinombolo lapha ukuze uvimbele kokubili amakholi nemibhalo."</string>
+    <string name="blocked_call_settings_import_button" msgid="178821255125295473">"Ngenisa"</string>
+    <string name="blocked_call_settings_view_numbers_button" msgid="6698986720875955935">"Buka izinombolo"</string>
+    <string name="addBlockedNumber" msgid="6064812257482886526">"Engeza inombolo"</string>
+    <string name="call_blocking_disabled_notification_title" msgid="8185193413377920194">"Ukuvimbela ikholi kukhutshaziwe amahora angu-48"</string>
+    <string name="call_blocking_disabled_notification_text" msgid="5330772013626378526">"Kukhutshaziwe ngoba ikholi ephuthumayo yenziwe."</string>
+    <string name="block_number_undo" msgid="591338370336724156">"HLEHLISA"</string>
+    <string name="alreadyBlocked" msgid="282340105563646876">"<xliff:g id="NUMBER">%1$s</xliff:g> isivinjiwe kakade."</string>
+    <string name="description_blocked_number_list_delete" msgid="3240093199107796792">"Vulela inombolo"</string>
+    <string name="description_contact_details" msgid="51229793651342809">"Imininingwane yokuxhumana ka-<xliff:g id="NAMEORNUMBER">%1$s</xliff:g>"</string>
+    <string name="send_to_voicemail_import_failed" msgid="5547202002133560069">"Ukulanda akuphumelelanga"</string>
+    <string name="import_send_to_voicemail_numbers_label" msgid="1606601823746799926">"Ngenisa izinombolo"</string>
+    <string name="permission_no_search" msgid="84152933267902056">"Ukuze useshe oxhumana nabo, vula izimvume zoxhumana nabo."</string>
+    <string name="permission_single_turn_on" msgid="1543391076065465464">"Vula"</string>
+    <string name="menu_blocked_numbers" msgid="5272951629083025995">"Izinombolo ezivinjiwe"</string>
 </resources>
diff --git a/res/values/attrs.xml b/res/values/attrs.xml
index 6da3b94..86c46fc 100644
--- a/res/values/attrs.xml
+++ b/res/values/attrs.xml
@@ -20,8 +20,6 @@
         <attr name="mimeType" format="string"/>
         <!-- RemoteViews XML that should be used to format this data -->
         <attr name="remoteViews" format="reference"/>
-        <!-- Icon that should be used to represent this data -->
-        <attr name="icon" format="reference"/>
         <!-- Column in data table to summarize this data -->
         <attr name="summaryColumn" format="string"/>
         <!-- Column in data table to show details of this data -->
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 0025a41..088c6ff 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -76,4 +76,18 @@
 
     <!-- Color of background of disabled link contacts button, 15% black. -->
     <color name="disabled_button_background">#26000000</color>
+
+    <!-- Color used in blocked numbers -->
+    <color name="blocked_number_background">#FFFFFF</color>
+    <color name="add_blocked_number_icon_color">#bdbdbd</color>
+    <color name="blocked_number_secondary_text_color">#636363</color>
+    <color name="blocked_number_header_color">@color/primary_color</color>
+    <color name="blocked_number_divider_line_color">#D8D8D8</color>
+    <color name="blocked_number_primary_text_color">#333333</color>
+    <color name="empty_list_text_color">#b2b2b2</color>
+    <color name="background_contacts_results">#f9f9f9</color>
+    <color name="blocked_number_block_color">#F44336</color>
+    <color name="contacts_snackbar_action_text_color">@color/primary_color</color>
+    <color name="blocked_number_disabled_emergency_background_color">#E0E0E0</color>
+    <color name="blocked_number_icon_tint">#616161</color>
 </resources>
diff --git a/res/values/dimens.xml b/res/values/dimens.xml
index 607c86b..cab8ac2 100644
--- a/res/values/dimens.xml
+++ b/res/values/dimens.xml
@@ -264,6 +264,8 @@
          We have to be more careful in landscape. -->
     <dimen name="people_activity_landscape_tabs_text_size">8dp</dimen>
 
+    <dimen name="update_contact_list_top_margin">120dp</dimen>
+
     <dimen name="expanding_entry_card_item_icon_height">24dp</dimen>
     <dimen name="expanding_entry_card_item_icon_width">24dp</dimen>
 
@@ -285,4 +287,21 @@
     <!-- Top margin for "Saving to" account header text field. -->
     <dimen name="compact_editor_account_header_top_margin">3dp</dimen>
 
+    <!-- Dimensions used in blocked numbers -->
+    <dimen name="blocked_number_settings_description_text_size">14sp</dimen>
+    <dimen name="blocked_number_container_padding">16dp</dimen>
+    <dimen name="blocked_number_top_margin">16dp</dimen>
+    <dimen name="blocked_number_bottom_margin">16dp</dimen>
+    <dimen name="blocked_number_add_top_margin">8dp</dimen>
+    <dimen name="blocked_number_add_bottom_margin">8dp</dimen>
+    <dimen name="blocked_number_horizontal_margin">16dp</dimen>
+    <dimen name="blocked_number_primary_text_size">16sp</dimen>
+    <dimen name="blocked_number_add_number_icon_size">40dp</dimen>
+    <dimen name="blocked_number_delete_icon_size">32dp</dimen>
+    <dimen name="empty_list_message_text_size">16sp</dimen>
+    <dimen name="call_log_action_height">48dp</dimen>
+    <dimen name="call_log_action_horizontal_padding">24dp</dimen>
+    <dimen name="search_list_padding_top">16dp</dimen>
+    <dimen name="blocked_number_search_text_size">14sp</dimen>
+    <dimen name="button_horizontal_padding">16dp</dimen>
 </resources>
diff --git a/res/values/ids.xml b/res/values/ids.xml
index 7f6a51f..7a2ea0d 100644
--- a/res/values/ids.xml
+++ b/res/values/ids.xml
@@ -43,4 +43,7 @@
 
     <!-- An ID to be used for contents of a custom dialog so that its state be preserved -->
     <item type="id" name="custom_dialog_content" />
+
+    <!-- For blocked numbers -->
+    <item type="id" name="block_id" />
 </resources>
diff --git a/res/values/integers.xml b/res/values/integers.xml
index a823a30..86a8e26 100644
--- a/res/values/integers.xml
+++ b/res/values/integers.xml
@@ -27,7 +27,4 @@
     <!-- Max suggestions limit showing in quick contact suggestion card [CHAR LIMIT=30]-->
     <integer name="quickcontact_suggestions_limit">10</integer>
 
-    <!-- The delay (in milliseconds) until the overflow options menu is shown automatically -->
-    <integer name="open_overflow_menu_delay_millis">250</integer>
-
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index bacf641..07bfdc0 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -23,6 +23,12 @@
          used in the Launcher icon. -->
     <string name="launcherActivityLabel">Contacts</string>
 
+    <!-- Title for Quick Contact activity. -->
+    <string name="quickContactActivityLabel">View Contact</string>
+
+    <!-- Title for Edit Contact activity. -->
+    <string name="editContactActivityLabel">Edit Contact</string>
+
     <!-- Directory partition name -->
     <string name="contactsList">Contacts</string>
 
@@ -635,10 +641,17 @@
     <string name="toast_text_copied">Text copied</string>
 
     <!-- Contents of the alert dialog when the user hits the Cancel button in the editor [CHAR LIMIT=128] -->
-    <string name="cancel_confirmation_dialog_message">Discard your changes?</string>
+    <string name="cancel_confirmation_dialog_message">Discard your changes and quit editing?</string>
 
-    <!-- Positive button text of the alert dialog when the user hits the Cancel button in the editor [CHAR LIMIT=40] -->
-    <string name="cancel_confirmation_dialog_message_positive_button">Discard</string>
+    <!-- Positive button text for the cancel editing confirmation dialog.
+      Pushing this button indicates that the user wishes to discard the changes they have already
+      made and close the editor. [CHAR LIMIT=20] -->
+    <string name="cancel_confirmation_dialog_cancel_editing_button">Discard</string>
+
+    <!-- Negative button text for the cancel editing confirmation dialog.
+      Pushing this button indicates that the user wishes to continue editing
+      and return to the editor [CHAR LIMIT=30] -->
+    <string name="cancel_confirmation_dialog_keep_editing_button">Keep editing</string>
 
     <!-- Description of a call log entry, made of a call type and a date -->
     <string name="call_type_and_date">
@@ -890,4 +903,152 @@
     type. For example: Delete Website, Delete SIP, etc [CHAR LIMIT=30]-->
     <string name="editor_delete_view_description_short">Delete <xliff:g id="data_kind">%s</xliff:g></string>
 
+    <!-- Content description of photo in photo picker indicating a photo from a specific account is *not* selected.
+         For example: Photo from Google abc@gmail.com not checked. [CHAR LIMIT=60]-->
+    <string name="photo_view_description_not_checked">Photo from <xliff:g id="account_type">%s </xliff:g><xliff:g id="user_name">%s </xliff:g>not checked</string>
+
+    <!-- Content description of photo in photo picker indicating a photo from a specific account is selected.
+         For example: Photo from Google abc@gmail.com checked. [CHAR LIMIT=60]-->
+    <string name="photo_view_description_checked">Photo from <xliff:g id="account_type">%s </xliff:g><xliff:g id="user_name">%s </xliff:g>checked</string>
+
+    <!-- Content description of photo in photo picker indicating a photo from unknown account is *not* selected.-->
+    <string name="photo_view_description_not_checked_no_info">Photo from unknown account not checked</string>
+
+    <!-- Content description of photo in photo picker indicating a photo from unknown account is selected. -->
+    <string name="photo_view_description_checked_no_info">Photo from unknown account checked</string>
+
+    <!-- Text shown in the contacts app while the background process updates contacts after a locale change [CHAR LIMIT=150]-->
+    <string name="locale_change_in_progress">Contact list is being updated to reflect the change of language.\n\nPlease wait...</string>
+
+    <!-- The blocked numbers activity title [CHAR LIMIT=50]-->
+    <string name="blocked_numbers_title">Blocked numbers</string>
+
+    <!-- Header message of blocked number activity [CHAR LIMIT=NONE] -->
+    <string name="blocked_number_header_message">
+        Calls and texts from these numbers will be blocked.
+    </string>
+
+    <!-- Button to bring up UI to add a number to the blocked call list. [CHAR LIMIT=40] -->
+    <string name="addBlockedNumber">Add number</string>
+
+    <!-- Shortcut item used to block a number directly from search. [CHAR LIMIT=25] -->
+    <string name="search_shortcut_block_number">Block number</string>
+
+    <!-- Hint displayed in add blocked number search box when there is no query typed.
+     [CHAR LIMIT=45] -->
+    <string name="block_number_search_hint">Add number or search contacts</string>
+
+    <!-- Confirmation dialog message for blocking a number. [CHAR LIMIT=NONE] -->
+    <string name="block_number_confirmation_message">
+        Calls and texts from this number will be blocked.
+    </string>
+
+    <!-- Confirmation dialog for unblocking a number. [CHAR LIMIT=NONE] -->
+    <string name="unblock_number_confirmation_title">Unblock
+        <xliff:g id="number" example="(555) 555-5555">%1$s</xliff:g>?</string>
+
+    <!-- Unblock number alert dialog button [CHAR LIMIT=32] -->
+    <string name="unblock_number_ok">UNBLOCK</string>
+
+    <!-- Confirmation dialog title for blocking a number. [CHAR LIMIT=NONE] -->
+    <string name="block_number_confirmation_title">Block
+        <xliff:g id="number" example="(555) 555-5555">%1$s</xliff:g>?</string>
+
+    <!-- Block number alert dialog button [CHAR LIMIT=32] -->
+    <string name="block_number_ok">BLOCK</string>
+
+    <!-- Text for snackbar to undo blocking a number. [CHAR LIMIT=64] -->
+    <string name="snackbar_number_blocked">
+        <xliff:g id="number" example="(555) 555-5555">%1$s</xliff:g> blocked</string>
+
+    <!-- Text for snackbar to undo unblocking a number. [CHAR LIMIT=64] -->
+    <string name="snackbar_number_unblocked">
+        <xliff:g id="number" example="(555) 555-5555">%1$s</xliff:g>
+        unblocked</string>
+
+    <!-- Error message shown when user tries to add invalid number to the block list.
+        [CHAR LIMIT=64] -->
+    <string name="invalidNumber"><xliff:g id="number" example="(555) 555-5555">%1$s</xliff:g>
+        is invalid.</string>
+
+    <!-- Label for a section describing that call blocking is temporarily disabled because an
+     emergency call was made. [CHAR LIMIT=50] -->
+    <string name="blocked_numbers_disabled_emergency_header_label">
+        Call blocking temporarily off
+    </string>
+
+    <!-- Description that call blocking is temporarily disabled because the user called an
+     emergency number, and explains that call blocking will be re-enabled after a buffer
+     period has passed. [CHAR LIMIT=NONE] -->
+    <string name="blocked_numbers_disabled_emergency_desc">
+        Call blocking has been disabled because you contacted emergency services from this phone
+        within the last 48 hours. It will be automatically reenabled once the 48 hour period
+        expires.
+    </string>
+
+    <!-- Text informing the user they have previously marked contacts to be sent to voicemail.
+     This will be followed by two buttons, 1) to view who is marked to be sent to voicemail
+     and 2) importing these settings to block list. [CHAR LIMIT=NONE] -->
+    <string name="blocked_call_settings_import_description">
+        You previously marked some contacts to be automatically sent to voicemail. Import those numbers here to block both calls and texts.
+    </string>
+
+    <!-- Label for button to import settings for sending contacts to voicemail into block list. [CHAR_LIMIT=20] -->
+    <string name="blocked_call_settings_import_button">Import</string>
+
+    <!-- Label for button to view numbers of contacts previous marked to be sent to voicemail.
+     [CHAR_LIMIT=20] -->
+    <string name="blocked_call_settings_view_numbers_button">View Numbers</string>
+
+    <!-- Button to bring up UI to add a number to the blocked call list. [CHAR LIMIT=40] -->
+    <string name="addBlockedNumber">Add number</string>
+
+    <!-- Title of notification telling the user that call blocking has been temporarily disabled.
+         [CHAR LIMIT=56] -->
+    <string name="call_blocking_disabled_notification_title">
+        Call blocking disabled for 48 hours
+    </string>
+
+    <!-- Text for notification which provides the reason that call blocking has been temporarily
+         disabled. Namely, we disable call blocking after an emergency call in case of return
+         phone calls made by emergency services. [CHAR LIMIT=64] -->
+    <string name="call_blocking_disabled_notification_text">
+        Disabled because an emergency call was made.
+    </string>
+
+    <!-- Text for undo button in snackbar for blocking/unblocking number. [CHAR LIMIT=10] -->
+    <string name="block_number_undo">UNDO</string>
+
+    <!-- Error message shown when user tries to add a number to the block list that was already
+    blocked. [CHAR LIMIT=64] -->
+    <string name="alreadyBlocked"><xliff:g id="number" example="(555) 555-5555">%1$s</xliff:g>
+        is already blocked.</string>
+
+    <!-- String describing the delete icon on a blocked number list item.
+        When tapped, it will show a dialog confirming the unblocking of the number.
+        [CHAR LIMIT=NONE]-->
+    <string name="description_blocked_number_list_delete">Unblock number</string>
+
+    <!-- String describing the button to access the contact details for a name or number.
+
+    Note: AccessibilityServices use this attribute to announce what the view represents.
+          This is especially valuable for views without textual representation like ImageView.
+-->
+    <string name="description_contact_details">Contact details for <xliff:g id="nameOrNumber">%1$s</xliff:g></string>
+
+    <!-- Error toast message for when send to voicemail import fails. [CHAR LIMIT=40] -->
+    <string name="send_to_voicemail_import_failed">Import failed</string>
+
+    <!-- Label for fragment to import numbers from contacts marked as send to voicemail.
+     [CHAR_LIMIT=30] -->
+    <string name="import_send_to_voicemail_numbers_label">Import numbers</string>
+
+    <!-- Shown as a prompt to turn on contacts permissions to allow contact search [CHAR LIMIT=NONE]-->
+    <string name="permission_no_search">To search your contacts, turn on the Contacts permissions.</string>
+
+    <!-- The label of the button used to turn on a single permission [CHAR LIMIT=30]-->
+    <string name="permission_single_turn_on">Turn on</string>
+
+    <!-- The menu item to open blocked numbers activity [CHAR LIMIT=60]-->
+    <string name="menu_blocked_numbers">Blocked numbers</string>
 </resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index a8dbe0c..7f49820 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -108,6 +108,83 @@
         <item name="favorites_padding_bottom">0dip</item>
     </style>
 
+    <style name="PeopleActivityTheme" parent="@style/PeopleThemeAppCompat">
+        <item name="windowActionBar">false</item>
+        <item name="windowNoTitle">true</item>
+        <item name="android:listSelector">?android:attr/listChoiceBackgroundIndicator</item>
+    </style>
+
+    <style name="ContactsUnavailableButtonStyle" parent="@style/Widget.AppCompat.Button.Colored">
+    </style>
+
+    <style name="PeopleThemeAppCompat" parent="Theme.AppCompat.Light">
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+        <item name="android:actionBarStyle">@style/ContactsActionBarStyleAppCompat</item>
+        <item name="actionBarStyle">@style/ContactsActionBarStyleAppCompat</item>
+        <!-- Style for the tab bar (for the divider between tabs) -->
+        <item name="android:actionBarTabBarStyle">@style/ContactsActionBarTabBarStyle</item>
+        <item name="actionBarTabBarStyle">@style/ContactsActionBarTabBarStyle</item>
+        <!-- Style for the tab bar text (for text on tabs) -->
+        <item name="android:actionBarTabTextStyle">@style/ContactsActionBarTabTextStyle</item>
+        <item name="actionBarTabTextStyle">@style/ContactsActionBarTabTextStyle</item>
+        <!--  Drawable for the back button -->
+        <item name="android:homeAsUpIndicator">@drawable/ic_back_arrow</item>
+        <item name="homeAsUpIndicator">@drawable/ic_back_arrow</item>
+        <!-- Style for the overflow button in the actionbar. -->
+        <item name="android:actionOverflowButtonStyle">@style/ContactsActionBarOverflowQP</item>
+        <item name="actionOverflowButtonStyle">@style/ContactsActionBarOverflowQP</item>
+        <item name="android:actionModeCloseDrawable">@drawable/ic_close_lt</item>
+        <item name="android:fastScrollThumbDrawable">@drawable/fastscroll_thumb</item>
+        <item name="android:fastScrollTrackDrawable">@null</item>
+        <item name="android:textColorPrimary">@color/primary_text_color</item>
+        <item name="android:textColorSecondary">@color/secondary_text_color</item>
+        <item name="android:icon">@android:color/transparent</item>
+        <item name="android:listViewStyle">@style/ListViewStyle</item>
+        <item name="android:windowBackground">@color/background_primary</item>
+        <item name="android:colorPrimaryDark">@color/primary_color_dark</item>
+        <item name="colorPrimaryDark">@color/primary_color_dark</item>
+        <item name="android:colorPrimary">@color/primary_color</item>
+        <item name="colorPrimary">@color/primary_color</item>
+        <item name="android:colorAccent">@color/primary_color</item>
+        <item name="colorAccent">@color/primary_color</item>
+        <item name="android:alertDialogTheme">@style/ContactsAlertDialogTheme</item>
+        <item name="alertDialogTheme">@style/ContactsAlertDialogTheme</item>
+        <item name="list_item_height">?android:attr/listPreferredItemHeight</item>
+        <item name="activated_background">@drawable/list_item_activated_background</item>
+        <item name="section_header_background">@drawable/list_title_holo</item>
+        <item name="list_section_header_height">24dip</item>
+        <item name="list_item_padding_top">
+            @dimen/contact_browser_list_item_padding_top_or_bottom
+        </item>
+        <item name="list_item_padding_right">32dp</item>
+        <item name="list_item_padding_bottom">
+            @dimen/contact_browser_list_item_padding_top_or_bottom
+        </item>
+        <item name="list_item_padding_left">16dip</item>
+        <item name="list_item_gap_between_image_and_text">
+            @dimen/contact_browser_list_item_gap_between_image_and_text
+        </item>
+        <item name="list_item_gap_between_label_and_data">5dip</item>
+        <item name="list_item_presence_icon_margin">4dip</item>
+        <item name="list_item_presence_icon_size">16dip</item>
+        <item name="list_item_photo_size">@dimen/contact_browser_list_item_photo_size</item>
+        <item name="list_item_profile_photo_size">70dip</item>
+        <item name="list_item_prefix_highlight_color">@color/people_app_theme_color</item>
+        <item name="list_item_background_color">@color/list_item_pinned_header_color</item>
+        <item name="list_item_header_text_color">@color/people_app_theme_color</item>
+        <item name="list_item_header_text_size">14sp</item>
+        <item name="list_item_header_height">30dip</item>
+        <item name="list_item_data_width_weight">5</item>
+        <item name="list_item_label_width_weight">3</item>
+        <item name="list_item_header_text_indent">8dip</item>
+        <item name="contact_browser_list_padding_left">0dip</item>
+        <item name="contact_browser_list_padding_right">0dip</item>
+        <item name="contact_browser_background">@color/background_primary</item>
+        <item name="list_item_text_indent">@dimen/contact_browser_list_item_text_indent</item>
+        <!-- Favorites -->
+        <item name="favorites_padding_bottom">0dip</item>
+    </style>
+
     <style name="ContactsActionBarOverflow" parent="@android:style/Widget.Holo.ActionButton.Overflow">
         <item name="android:src">@drawable/ic_overflow_menu</item>
     </style>
@@ -122,26 +199,45 @@
         <item name="android:icon">@android:color/transparent</item>
     </style>
 
+    <style name="ContactsActionBarStyleAppCompat"
+           parent="@style/Widget.AppCompat.Light.ActionBar.Solid.Inverse">
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+        <item name="android:background">@color/actionbar_background_color</item>
+        <item name="background">@color/actionbar_background_color</item>
+        <item name="android:titleTextStyle">@style/ContactsActionBarTitleTextAppCompat</item>
+        <item name="titleTextStyle">@style/ContactsActionBarTitleTextAppCompat</item>
+        <item name="android:backgroundStacked">@color/actionbar_background_color</item>
+        <item name="backgroundStacked">@color/actionbar_background_color</item>
+        <!-- Empty icon -->
+        <item name="android:icon">@android:color/transparent</item>
+        <item name="icon">@android:color/transparent</item>
+    </style>
+
     <style name="EditorActionBarStyle" parent="@style/ContactsActionBarStyle">
         <item name="android:contentInsetStart">72dp</item>
     </style>
 
     <!-- When this style was added, android:toolbarStyle was private. Therefore, this style
          must be directly applied to every toolbar -->
-    <style name="ContactsToolbarStyle" parent="@android:style/Widget.Toolbar">
-        <item name="android:titleTextAppearance">@style/ContactsActionBarTitleText</item>
+    <style name="ContactsToolbarStyle" parent="@style/Widget.AppCompat.Toolbar">
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+        <item name="android:titleTextAppearance">@style/ContactsActionBarTitleTextAppCompat</item>
+        <item name="titleTextAppearance">@style/ContactsActionBarTitleTextAppCompat</item>
     </style>
 
-    <style name="ContactsPickerActionBarStyle" parent="@style/ContactsActionBarStyle">
+    <style name="ContactsPickerActionBarStyle" parent="@style/ContactsActionBarStyleAppCompat">
         <!-- when first loading, don't show title or up button -->
         <item name="android:displayOptions"></item>
     </style>
 
-    <style name="ContactPickerSearchTheme" parent="@style/PeopleTheme">
+    <style name="ContactPickerSearchTheme" parent="@style/PeopleThemeAppCompat">
         <item name="android:textColorPrimary">@android:color/white</item>
         <item name="android:textColorHint">?android:textColorHintInverse</item>
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
         <item name="android:colorControlActivated">?android:textColorHintInverse</item>
+        <item name="colorControlActivated">?android:textColorHintInverse</item>
         <item name="android:colorControlNormal">@android:color/white</item>
+        <item name="colorControlNormal">@android:color/white</item>
     </style>
 
     <!-- Text in the action bar at the top of the screen -->
@@ -150,6 +246,10 @@
         <item name="android:textColor">@color/actionbar_text_color</item>
     </style>
 
+    <style name="ContactsActionBarTitleTextAppCompat" parent="TextAppearance.Widget.AppCompat.Toolbar.Title">
+        <item name="android:textColor">@color/actionbar_text_color</item>
+    </style>
+
     <!-- Styling for the tab bar; handles styling of the divider line. -->
     <style name="ContactsActionBarTabBarStyle"
            parent="@android:style/Widget.Material.ActionBar.TabBar">
@@ -168,7 +268,7 @@
 
     <!-- Action bar overflow menu icon. -->
     <style name="ContactsActionBarOverflowQP"
-           parent="@android:style/Widget.Material.Light.ActionButton.Overflow">
+           parent="Widget.AppCompat.Light.ActionButton.Overflow">
         <item name="android:src">@drawable/ic_menu_overflow_lt</item>
     </style>
 
@@ -187,8 +287,11 @@
         <item name="android:listSelector">?android:attr/listChoiceBackgroundIndicator</item>
     </style>
 
-    <style name="ContactPickerTheme" parent="@style/PeopleTheme" >
+    <style name="ContactPickerTheme" parent="@style/PeopleThemeAppCompat">
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
         <item name="android:actionBarStyle">@style/ContactsPickerActionBarStyle</item>
+        <item name="actionBarStyle">@style/ContactsPickerActionBarStyle</item>
+        <item name="android:listSelector">?android:attr/listChoiceBackgroundIndicator</item>
     </style>
 
     <style name="ContactPickerLayout" parent="ContactPickerTheme">
@@ -196,12 +299,15 @@
         <item name="android:layout_height">match_parent</item>
     </style>
 
-    <style name="ContactsPreferencesTheme" parent="@style/PeopleTheme">
-        <item name="android:listViewStyle">@style/ListViewStyle</item>
+    <style name="ContactsPreferencesTheme" parent="@style/PeopleThemeAppCompat">
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+        <item name="android:alertDialogTheme">@style/ContactsAlertDialogThemeAppCompat</item>
+        <item name="alertDialogTheme">@style/ContactsAlertDialogThemeAppCompat</item>
     </style>
 
-    <style name="ContactListFilterTheme" parent="@style/PeopleTheme">
-        <item name="android:listViewStyle">@style/ListViewStyle</item>
+    <style name="ContactListFilterTheme" parent="@style/PeopleThemeAppCompat">
+        <!-- Make the shadow when pressing a list item transparent rather than yellow. -->
+        <item name="android:listSelector">?android:attr/listChoiceBackgroundIndicator</item>
     </style>
 
     <style name="NonPhoneActivityTheme" parent="@android:Theme.Translucent.NoTitleBar">
@@ -210,16 +316,17 @@
     <style name="NonPhoneDialogTheme" parent="@android:Theme.Material.Light.Dialog">
     </style>
 
-    <style name="ConfirmAddDetailDialogTheme" parent="@android:style/Theme.Material.Light.Dialog.MinWidth">
+    <style name="ConfirmAddDetailDialogTheme" parent="Theme.AppCompat.Light.Dialog">
         <item name="android:windowCloseOnTouchOutside">true</item>
     </style>
 
-    <style name="ContactEditorAccountsChangedActivityTheme" parent="@android:style/Theme.Material.Light.Dialog.NoActionBar.MinWidth">
+    <style name="ContactEditorAccountsChangedActivityTheme" parent="Theme.AppCompat.Light.Dialog">
         <item name="android:windowCloseOnTouchOutside">true</item>
         <item name="android:textColorPrimary">@color/primary_text_color</item>
         <item name="android:textColorSecondary">@color/secondary_text_color</item>
         <item name="android:listViewStyle">@style/ListViewStyle</item>
         <item name="android:colorAccent">@color/primary_color</item>
+        <item name="colorAccent">@color/primary_color</item>
     </style>
 
     <style name="SectionDivider">
@@ -315,6 +422,11 @@
         <item name="android:colorAccent">@color/primary_color</item>
     </style>
 
+    <style name="ContactsAlertDialogThemeAppCompat" parent="Theme.AppCompat.Light.Dialog">
+        <item name="android:colorAccent">@color/primary_color</item>
+        <item name="colorAccent">@color/primary_color</item>
+    </style>
+
     <style name="EditKindIconStyle">
         <item name="android:layout_width">24dp</item>
         <item name="android:layout_height">24dp</item>
@@ -348,4 +460,51 @@
         <item name="android:textColor">#363636</item>
         <item name="android:fontFamily">sans-serif</item>
     </style>
+
+    <style name="TextActionStyle">
+        <item name="android:layout_width">wrap_content</item>
+        <item name="android:layout_height">@dimen/call_log_action_height</item>
+        <item name="android:gravity">end|center_vertical</item>
+        <item name="android:paddingStart">@dimen/call_log_action_horizontal_padding</item>
+        <item name="android:paddingEnd">@dimen/call_log_action_horizontal_padding</item>
+        <item name="android:textColor">@color/primary_color</item>
+        <item name="android:fontFamily">"sans-serif-medium"</item>
+        <item name="android:focusable">true</item>
+        <item name="android:singleLine">true</item>
+        <item name="android:textAllCaps">true</item>
+    </style>
+
+    <style name="BlockedNumbersDescriptionTextStyle">
+        <item name="android:lineSpacingMultiplier">1.43</item>
+        <item name="android:paddingTop">8dp</item>
+        <item name="android:paddingBottom">8dp</item>
+        <item name="android:textSize">@dimen/blocked_number_settings_description_text_size</item>
+    </style>
+
+    <style name="ContactsFlatButtonStyle" parent="@style/Widget.AppCompat.Button.Colored">
+        <item name="android:background">?android:attr/selectableItemBackground</item>
+        <item name="android:paddingEnd">@dimen/button_horizontal_padding</item>
+        <item name="android:paddingStart">@dimen/button_horizontal_padding</item>
+        <item name="android:textColor">@color/primary_color</item>
+        <item name="background">?android:attr/selectableItemBackground</item>
+        <item name="paddingEnd">@dimen/button_horizontal_padding</item>
+        <item name="paddingStart">@dimen/button_horizontal_padding</item>
+    </style>
+
+    <style name="BlockedNumbersStyle" parent="@style/PeopleThemeAppCompat">
+        <item name="android:actionBarStyle">@style/BlockedNumbersStyleActionBarStyle</item>
+        <item name="actionBarStyle">@style/BlockedNumbersStyleActionBarStyle</item>
+    </style>
+
+    <style name="BlockedNumbersStyleActionBarStyle"
+           parent="@style/ContactsActionBarStyleAppCompat">
+        <!-- Styles that require AppCompat compatibility, remember to update both sets -->
+        <item name="android:displayOptions"></item>
+        <item name="displayOptions"></item>
+        <!-- Override ActionBar title offset to keep search box aligned left -->
+        <item name="android:contentInsetStart">0dp</item>
+        <item name="contentInsetStart">0dp</item>
+        <item name="android:contentInsetEnd">0dp</item>
+        <item name="contentInsetEnd">0dp</item>
+    </style>
 </resources>
diff --git a/src-N/com/android/contacts/activities/BlockedNumbersActivity.java b/src-N/com/android/contacts/activities/BlockedNumbersActivity.java
new file mode 100644
index 0000000..daaeb20
--- /dev/null
+++ b/src-N/com/android/contacts/activities/BlockedNumbersActivity.java
@@ -0,0 +1,148 @@
+/*
+ * Copyright (C) 2016 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.contacts.activities;
+
+import android.os.Bundle;
+import android.support.v7.app.ActionBar;
+import android.view.MenuItem;
+
+import com.android.contacts.AppCompatContactsActivity;
+import com.android.contacts.R;
+import com.android.contacts.callblocking.BlockedNumbersFragment;
+import com.android.contacts.callblocking.SearchFragment;
+import com.android.contacts.callblocking.ViewNumbersToImportFragment;
+
+public class BlockedNumbersActivity extends AppCompatContactsActivity
+        implements SearchFragment.HostInterface {
+    private static final String TAG_BLOCKED_MANAGEMENT_FRAGMENT = "blocked_management";
+    private static final String TAG_BLOCKED_SEARCH_FRAGMENT = "blocked_search";
+    private static final String TAG_VIEW_NUMBERS_TO_IMPORT_FRAGMENT = "view_numbers_to_import";
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.blocked_numbers_activity);
+
+        final ActionBar actionBar = getSupportActionBar();
+
+        actionBar.setDisplayShowHomeEnabled(true);
+        actionBar.setDisplayHomeAsUpEnabled(true);
+
+        // If savedInstanceState != null, the activity will automatically restore the last fragment.
+        if (savedInstanceState == null) {
+            showManagementUi();
+        }
+    }
+
+    /**
+     * Shows fragment with the list of currently blocked numbers and settings related to blocking.
+     */
+    public void showManagementUi() {
+        BlockedNumbersFragment fragment = (BlockedNumbersFragment) getFragmentManager()
+                .findFragmentByTag(TAG_BLOCKED_MANAGEMENT_FRAGMENT);
+        if (fragment == null) {
+            fragment = new BlockedNumbersFragment();
+        }
+
+        getFragmentManager().beginTransaction()
+                .replace(R.id.blocked_numbers_activity_container, fragment,
+                        TAG_BLOCKED_MANAGEMENT_FRAGMENT)
+                .commit();
+    }
+
+    /**
+     * Shows fragment with search UI for browsing/finding numbers to block.
+     */
+    public void showSearchUi() {
+        SearchFragment fragment = (SearchFragment) getFragmentManager()
+                .findFragmentByTag(TAG_BLOCKED_SEARCH_FRAGMENT);
+        if (fragment == null) {
+            fragment = new SearchFragment();
+            fragment.setHasOptionsMenu(false);
+            fragment.setShowEmptyListForNullQuery(true);
+            fragment.setDirectorySearchEnabled(false);
+        }
+
+        getFragmentManager().beginTransaction()
+                .replace(R.id.blocked_numbers_activity_container, fragment,
+                        TAG_BLOCKED_SEARCH_FRAGMENT)
+                .addToBackStack(null)
+                .commit();
+    }
+
+    /**
+     * Shows fragment with UI to preview the numbers of contacts currently marked as
+     * send-to-voicemail in Contacts. These numbers can be imported into blocked number list.
+     */
+    public void showNumbersToImportPreviewUi() {
+        ViewNumbersToImportFragment fragment = (ViewNumbersToImportFragment) getFragmentManager()
+                .findFragmentByTag(TAG_VIEW_NUMBERS_TO_IMPORT_FRAGMENT);
+        if (fragment == null) {
+            fragment = new ViewNumbersToImportFragment();
+        }
+
+        getFragmentManager().beginTransaction()
+                .replace(R.id.blocked_numbers_activity_container, fragment,
+                        TAG_VIEW_NUMBERS_TO_IMPORT_FRAGMENT)
+                .addToBackStack(null)
+                .commit();
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(MenuItem item) {
+        if (item.getItemId() == android.R.id.home) {
+            onBackPressed();
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onBackPressed() {
+        // TODO: Achieve back navigation without overriding onBackPressed.
+        if (getFragmentManager().getBackStackEntryCount() > 0) {
+            getFragmentManager().popBackStack();
+        } else {
+            super.onBackPressed();
+        }
+    }
+
+    @Override
+    public boolean isActionBarShowing() {
+        return true;
+    }
+
+    @Override
+    public boolean isDialpadShown() {
+        return false;
+    }
+
+    @Override
+    public int getDialpadHeight() {
+        return 0;
+    }
+
+    @Override
+    public int getActionBarHideOffset() {
+        return 0;
+    }
+
+    @Override
+    public int getActionBarHeight() {
+        return 0;
+    }
+}
\ No newline at end of file
diff --git a/src-N/com/android/contacts/callblocking/BlockNumberDialogFragment.java b/src-N/com/android/contacts/callblocking/BlockNumberDialogFragment.java
new file mode 100644
index 0000000..c9b5314
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/BlockNumberDialogFragment.java
@@ -0,0 +1,298 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
+import android.app.FragmentManager;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.net.Uri;
+import android.os.Bundle;
+import android.support.design.widget.Snackbar;
+import android.text.TextUtils;
+import android.view.View;
+import android.widget.Toast;
+
+import com.android.contacts.R;
+import com.android.contacts.callblocking.FilteredNumberAsyncQueryHandler.OnBlockNumberListener;
+import com.android.contacts.callblocking.FilteredNumberAsyncQueryHandler.OnUnblockNumberListener;
+import com.android.contacts.common.util.ContactDisplayUtils;
+
+/**
+ * Fragment for confirming and enacting blocking/unblocking a number. Also invokes snackbar
+ * providing undo functionality but not checks whether visual voicemail is enabled.
+ */
+public class BlockNumberDialogFragment extends DialogFragment {
+
+    /**
+     * Use a callback interface to update UI after success/undo. Favor this approach over other
+     * more standard paradigms because of the variety of scenarios in which the DialogFragment
+     * can be invoked (by an Activity, by a fragment, by an adapter, by an adapter list item).
+     * Because of this, we do NOT support retaining state on rotation, and will dismiss the dialog
+     * upon rotation instead.
+     */
+    public interface Callback {
+        /**
+         * Called when a number is successfully added to the set of filtered numbers
+         */
+        void onFilterNumberSuccess();
+
+        /**
+         * Called when a number is successfully removed from the set of filtered numbers
+         */
+        void onUnfilterNumberSuccess();
+
+        /**
+         * Called when the action of filtering or unfiltering a number is undone
+         */
+        void onChangeFilteredNumberUndo();
+    }
+
+    private static final String BLOCK_DIALOG_FRAGMENT = "BlockNumberDialog";
+
+    private static final String ARG_BLOCK_ID = "argBlockId";
+    private static final String ARG_NUMBER = "argNumber";
+    private static final String ARG_COUNTRY_ISO = "argCountryIso";
+    private static final String ARG_DISPLAY_NUMBER = "argDisplayNumber";
+    private static final String ARG_PARENT_VIEW_ID = "parentViewId";
+
+    private String mNumber;
+    private String mDisplayNumber;
+    private String mCountryIso;
+
+    private FilteredNumberAsyncQueryHandler mHandler;
+    private View mParentView;
+    private Callback mCallback;
+
+    public static void show(
+            Long blockId,
+            String number,
+            String countryIso,
+            String displayNumber,
+            Integer parentViewId,
+            FragmentManager fragmentManager,
+            Callback callback) {
+        final BlockNumberDialogFragment newFragment = BlockNumberDialogFragment.newInstance(
+                blockId, number, countryIso, displayNumber, parentViewId);
+
+        newFragment.setCallback(callback);
+        newFragment.show(fragmentManager, BlockNumberDialogFragment.BLOCK_DIALOG_FRAGMENT);
+    }
+
+    private static BlockNumberDialogFragment newInstance(
+            Long blockId,
+            String number,
+            String countryIso,
+            String displayNumber,
+            Integer parentViewId) {
+        final BlockNumberDialogFragment fragment = new BlockNumberDialogFragment();
+        final Bundle args = new Bundle();
+        if (blockId != null) {
+            args.putInt(ARG_BLOCK_ID, blockId.intValue());
+        }
+        if (parentViewId != null) {
+            args.putInt(ARG_PARENT_VIEW_ID, parentViewId.intValue());
+        }
+        args.putString(ARG_NUMBER, number);
+        args.putString(ARG_COUNTRY_ISO, countryIso);
+        args.putString(ARG_DISPLAY_NUMBER, displayNumber);
+        fragment.setArguments(args);
+        return fragment;
+    }
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
+
+    @Override
+    public Dialog onCreateDialog(Bundle savedInstanceState) {
+        super.onCreateDialog(savedInstanceState);
+        final boolean isBlocked = getArguments().containsKey(ARG_BLOCK_ID);
+
+        mNumber = getArguments().getString(ARG_NUMBER);
+        mDisplayNumber = getArguments().getString(ARG_DISPLAY_NUMBER);
+        mCountryIso = getArguments().getString(ARG_COUNTRY_ISO);
+
+        if (TextUtils.isEmpty(mDisplayNumber)) {
+            mDisplayNumber = mNumber;
+        }
+
+        mHandler = new FilteredNumberAsyncQueryHandler(getContext().getContentResolver());
+        /**
+         * Choose not to update VoicemailEnabledChecker, as checks should already been done in
+         * all current use cases.
+         */
+        mParentView = getActivity().findViewById(getArguments().getInt(ARG_PARENT_VIEW_ID));
+
+        String okText;
+        CharSequence message;
+        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        if (isBlocked) {
+            okText = getString(R.string.unblock_number_ok);
+            message = ContactDisplayUtils.getTtsSpannedPhoneNumber(getResources(),
+                    R.string.unblock_number_confirmation_title,
+                    mDisplayNumber);
+        } else {
+            builder.setTitle(ContactDisplayUtils.getTtsSpannedPhoneNumber(getResources(),
+                    R.string.block_number_confirmation_title,
+                    mDisplayNumber));
+            okText = getString(R.string.block_number_ok);
+            message = getString(R.string.block_number_confirmation_message);
+        }
+
+        builder.setMessage(message).setNegativeButton(android.R.string.cancel, null);
+        builder.setPositiveButton(okText, new DialogInterface.OnClickListener() {
+            public void onClick(DialogInterface dialog, int id) {
+                if (isBlocked) {
+                    unblockNumber();
+                } else {
+                    blockNumber();
+                        }
+                    }
+                });
+        return builder.create();
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        if (!FilteredNumbersUtil.canBlockNumber(getActivity(), mNumber, mCountryIso)) {
+            dismiss();
+            Toast.makeText(getContext(),
+                    ContactDisplayUtils.getTtsSpannedPhoneNumber(
+                            getResources(), R.string.invalidNumber, mDisplayNumber),
+                    Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    @Override
+    public void onPause() {
+        // TODO: avoid dismissing the dialog fragment
+        // Dismiss on rotation.
+        dismiss();
+        mCallback = null;
+
+        super.onPause();
+    }
+
+    public void setCallback(Callback callback) {
+        mCallback = callback;
+    }
+
+    private CharSequence getBlockedMessage() {
+        return ContactDisplayUtils.getTtsSpannedPhoneNumber(getResources(),
+                R.string.snackbar_number_blocked, mDisplayNumber);
+    }
+
+    private CharSequence getUnblockedMessage() {
+        return ContactDisplayUtils.getTtsSpannedPhoneNumber(getResources(),
+                R.string.snackbar_number_unblocked, mDisplayNumber);
+    }
+
+    private int getActionTextColor() {
+        return getContext().getResources().getColor(R.color.contacts_snackbar_action_text_color);
+    }
+
+    private void blockNumber() {
+        final CharSequence message = getBlockedMessage();
+        final CharSequence undoMessage = getUnblockedMessage();
+        final Callback callback = mCallback;
+        final int actionTextColor = getActionTextColor();
+
+        final OnUnblockNumberListener onUndoListener = new OnUnblockNumberListener() {
+            @Override
+            public void onUnblockComplete(int rows, ContentValues values) {
+                Snackbar.make(mParentView, undoMessage, Snackbar.LENGTH_LONG).show();
+                if (callback != null) {
+                    callback.onChangeFilteredNumberUndo();
+                }
+            }
+        };
+
+        final OnBlockNumberListener onBlockNumberListener = new OnBlockNumberListener() {
+            @Override
+            public void onBlockComplete(final Uri uri) {
+                final View.OnClickListener undoListener = new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        // Delete the newly created row on 'undo'.
+                        mHandler.unblock(onUndoListener, uri);
+                    }
+                };
+
+                Snackbar.make(mParentView, message, Snackbar.LENGTH_LONG)
+                        .setAction(R.string.block_number_undo, undoListener)
+                        .setActionTextColor(actionTextColor)
+                        .show();
+
+                if (callback != null) {
+                    callback.onFilterNumberSuccess();
+                }
+
+                // Since Dialer shows notification, Contacts will not do that again.
+            }
+        };
+
+        mHandler.blockNumber(
+                onBlockNumberListener,
+                mNumber,
+                mCountryIso);
+    }
+
+    private void unblockNumber() {
+        final CharSequence message = getUnblockedMessage();
+        final CharSequence undoMessage = getBlockedMessage();
+        final Callback callback = mCallback;
+        final int actionTextColor = getActionTextColor();
+
+        final OnBlockNumberListener onUndoListener = new OnBlockNumberListener() {
+            @Override
+            public void onBlockComplete(final Uri uri) {
+                Snackbar.make(mParentView, undoMessage, Snackbar.LENGTH_LONG).show();
+                if (callback != null) {
+                    callback.onChangeFilteredNumberUndo();
+                }
+            }
+        };
+
+        mHandler.unblock(new OnUnblockNumberListener() {
+            @Override
+            public void onUnblockComplete(int rows, final ContentValues values) {
+                final View.OnClickListener undoListener = new View.OnClickListener() {
+                    @Override
+                    public void onClick(View view) {
+                        // Re-insert the row on 'undo', with a new ID.
+                        mHandler.blockNumber(onUndoListener, values);
+                    }
+                };
+
+                Snackbar.make(mParentView, message, Snackbar.LENGTH_LONG)
+                        .setAction(R.string.block_number_undo, undoListener)
+                        .setActionTextColor(actionTextColor)
+                        .show();
+
+                if (callback != null) {
+                    callback.onUnfilterNumberSuccess();
+                }
+            }
+        }, getArguments().getInt(ARG_BLOCK_ID));
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/BlockedNumbersAdapter.java b/src-N/com/android/contacts/callblocking/BlockedNumbersAdapter.java
new file mode 100644
index 0000000..db76737
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/BlockedNumbersAdapter.java
@@ -0,0 +1,88 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.app.FragmentManager;
+import android.content.Context;
+import android.database.Cursor;
+import android.provider.BlockedNumberContract.BlockedNumbers;
+import android.telephony.PhoneNumberUtils;
+import android.view.View;
+
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.R;
+
+public class BlockedNumbersAdapter extends NumbersAdapter {
+    private BlockedNumbersAdapter(
+            Context context,
+            FragmentManager fragmentManager,
+            ContactInfoHelper contactInfoHelper,
+            ContactPhotoManager contactPhotoManager) {
+        super(context, fragmentManager, contactInfoHelper, contactPhotoManager);
+    }
+
+    public static BlockedNumbersAdapter newBlockedNumbersAdapter(
+            Context context, FragmentManager fragmentManager) {
+        return new BlockedNumbersAdapter(
+                context,
+                fragmentManager,
+                new ContactInfoHelper(context, GeoUtil.getCurrentCountryIso(context)),
+                ContactPhotoManager.getInstance(context));
+    }
+
+    @Override
+    public void bindView(View view, final Context context, Cursor cursor) {
+        super.bindView(view, context, cursor);
+        final Long id = cursor.getLong(cursor.getColumnIndex(BlockedNumbers.COLUMN_ID));
+        final String countryIso = GeoUtil.getCurrentCountryIso(context);
+        final String number = cursor.getString(
+                cursor.getColumnIndex(BlockedNumbers.COLUMN_ORIGINAL_NUMBER));
+
+        final View deleteButton = view.findViewById(R.id.delete_button);
+        deleteButton.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View view) {
+                BlockNumberDialogFragment.show(
+                        id,
+                        number,
+                        countryIso,
+                        PhoneNumberUtils.formatNumber(number, countryIso),
+                        R.id.blocked_numbers_activity_container,
+                        getFragmentManager(),
+                        new BlockNumberDialogFragment.Callback() {
+                            @Override
+                            public void onFilterNumberSuccess() {}
+
+                            @Override
+                            public void onUnfilterNumberSuccess() {}
+
+                            @Override
+                            public void onChangeFilteredNumberUndo() {}
+                        });
+            }
+        });
+
+        updateView(view, number, countryIso);
+    }
+
+    @Override
+    public boolean isEmpty() {
+        // Always return false, so that the header with blocking-related options always shows.
+        return false;
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/BlockedNumbersFragment.java b/src-N/com/android/contacts/callblocking/BlockedNumbersFragment.java
new file mode 100644
index 0000000..6680cca
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/BlockedNumbersFragment.java
@@ -0,0 +1,195 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.app.ListFragment;
+import android.app.LoaderManager;
+import android.content.Context;
+import android.content.CursorLoader;
+import android.content.Loader;
+import android.database.Cursor;
+import android.graphics.drawable.ColorDrawable;
+import android.os.Bundle;
+import android.provider.BlockedNumberContract.BlockedNumbers;
+import android.support.v4.app.ActivityCompat;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.AppCompatActivity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.ImageView;
+
+import com.android.contacts.R;
+import com.android.contacts.activities.BlockedNumbersActivity;
+import com.android.contacts.callblocking.FilteredNumbersUtil.CheckForSendToVoicemailContactListener;
+import com.android.contacts.callblocking.FilteredNumbersUtil.ImportSendToVoicemailContactsListener;
+import com.android.contacts.common.lettertiles.LetterTileDrawable;
+
+/**
+ * This class is copied from Dialer, but we don't check whether visual voicemail is enabled here.
+  */
+public class BlockedNumbersFragment extends ListFragment
+        implements LoaderManager.LoaderCallbacks<Cursor>, View.OnClickListener {
+
+    private static final char ADD_BLOCKED_NUMBER_ICON_LETTER = '+';
+
+    private BlockedNumbersAdapter mAdapter;
+
+    private View mImportSettings;
+    private View mBlockedNumbersDisabledForEmergency;
+    private View mBlockedNumberListDivider;
+    private View mHeaderTextView;
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        LayoutInflater inflater =
+                (LayoutInflater) getActivity().getSystemService(Context.LAYOUT_INFLATER_SERVICE);
+        getListView().addHeaderView(inflater.inflate(R.layout.blocked_number_header, null));
+        //replace the icon for add number with LetterTileDrawable(), so it will have identical style
+        ImageView addNumberIcon = (ImageView) getActivity().findViewById(R.id.add_number_icon);
+        LetterTileDrawable drawable = new LetterTileDrawable(getResources());
+        drawable.setLetter(ADD_BLOCKED_NUMBER_ICON_LETTER);
+        drawable.setColor(ActivityCompat.getColor(getActivity(),
+                R.color.add_blocked_number_icon_color));
+        drawable.setIsCircular(true);
+        addNumberIcon.setImageDrawable(drawable);
+
+        if (mAdapter == null) {
+            mAdapter = BlockedNumbersAdapter.newBlockedNumbersAdapter(
+                    getContext(), getActivity().getFragmentManager());
+        }
+        setListAdapter(mAdapter);
+
+        mHeaderTextView = getListView().findViewById(R.id.header_textview);
+        mImportSettings = getListView().findViewById(R.id.import_settings);
+        mBlockedNumbersDisabledForEmergency =
+                getListView().findViewById(R.id.blocked_numbers_disabled_for_emergency);
+        mBlockedNumberListDivider = getActivity().findViewById(R.id.blocked_number_list_divider);
+        getListView().findViewById(R.id.import_button).setOnClickListener(this);
+        getListView().findViewById(R.id.view_numbers_button).setOnClickListener(this);
+        getListView().findViewById(R.id.add_number_linear_layout).setOnClickListener(this);
+    }
+
+    @Override
+    public void onDestroy() {
+        setListAdapter(null);
+        super.onDestroy();
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        getLoaderManager().initLoader(0, null, this);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        ActionBar actionBar = ((AppCompatActivity) getActivity()).getSupportActionBar();
+        ColorDrawable backgroundDrawable = new ColorDrawable(
+                ActivityCompat.getColor(getActivity(), R.color.primary_color));
+        actionBar.setBackgroundDrawable(backgroundDrawable);
+        actionBar.setDisplayShowCustomEnabled(false);
+        actionBar.setDisplayHomeAsUpEnabled(true);
+        actionBar.setDisplayShowHomeEnabled(true);
+        actionBar.setDisplayShowTitleEnabled(true);
+        actionBar.setTitle(R.string.blocked_numbers_title);
+
+        FilteredNumbersUtil.checkForSendToVoicemailContact(
+            getActivity(), new CheckForSendToVoicemailContactListener() {
+                @Override
+                public void onComplete(boolean hasSendToVoicemailContact) {
+                    mImportSettings.setVisibility(
+                            hasSendToVoicemailContact ? View.VISIBLE : View.GONE);
+                    mHeaderTextView.setVisibility(
+                            mImportSettings.getVisibility() == View.GONE ?
+                                    View.VISIBLE : View.GONE);
+                }
+            });
+
+        // Visibility of mBlockedNumbersDisabledForEmergency will always be GONE for now, until
+        // we could check recent emergency call from framework.
+    }
+
+    @Override
+    public View onCreateView(
+            LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.blocked_number_fragment, container, false);
+    }
+
+    @Override
+    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
+        final String[] projection = {
+            BlockedNumbers.COLUMN_ID,
+            BlockedNumbers.COLUMN_ORIGINAL_NUMBER,
+            BlockedNumbers.COLUMN_E164_NUMBER
+        };
+        final CursorLoader cursorLoader = new CursorLoader(
+                getContext(), BlockedNumbers.CONTENT_URI, projection, null, null, null);
+        return cursorLoader;
+    }
+
+    @Override
+    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
+        mAdapter.swapCursor(data);
+        if (data.getCount() == 0) {
+            mBlockedNumberListDivider.setVisibility(View.INVISIBLE);
+        } else {
+            mBlockedNumberListDivider.setVisibility(View.VISIBLE);
+        }
+    }
+
+    @Override
+    public void onLoaderReset(Loader<Cursor> loader) {
+        mAdapter.swapCursor(null);
+    }
+
+    @Override
+    public void onClick(View view) {
+        BlockedNumbersActivity activity = (BlockedNumbersActivity) getActivity();
+        if (activity == null) {
+            return;
+        }
+
+        switch (view.getId()) {
+            case R.id.add_number_linear_layout:
+                activity.showSearchUi();
+                break;
+            case R.id.view_numbers_button:
+                activity.showNumbersToImportPreviewUi();
+                break;
+            case R.id.import_button:
+                FilteredNumbersUtil.importSendToVoicemailContacts(activity,
+                        new ImportSendToVoicemailContactsListener() {
+                            @Override
+                            public void onImportComplete() {
+                                mImportSettings.setVisibility(View.GONE);
+                                mHeaderTextView.setVisibility(View.VISIBLE);
+                            }
+                        });
+                break;
+        }
+    }
+}
\ No newline at end of file
diff --git a/src-N/com/android/contacts/callblocking/ContactInfo.java b/src-N/com/android/contacts/callblocking/ContactInfo.java
new file mode 100644
index 0000000..a96cfb7
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/ContactInfo.java
@@ -0,0 +1,97 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.net.Uri;
+import android.text.TextUtils;
+import android.util.Log;
+
+import com.android.contacts.common.ContactsUtils.UserType;
+import com.android.contacts.common.util.UriUtils;
+
+import com.google.common.base.Objects;
+
+/**
+ * Information for a contact as needed by blocked numbers.
+ */
+final public class ContactInfo {
+    public Uri lookupUri;
+
+    /**
+     * Contact lookup key.  Note this may be a lookup key for a corp contact, in which case
+     * "lookup by lookup key" doesn't work on the personal profile.
+     */
+    public String lookupKey;
+    public String name;
+    public String nameAlternative;
+    public int type;
+    public String label;
+    public String number;
+    public String formattedNumber;
+    public String normalizedNumber;
+    /** The photo for the contact, if available. */
+    public long photoId;
+    /** The high-res photo for the contact, if available. */
+    public Uri photoUri;
+    public boolean isBadData;
+    public String objectId;
+    public @UserType long userType;
+
+    public static ContactInfo EMPTY = new ContactInfo();
+
+    public int sourceType = 0;
+
+    @Override
+    public int hashCode() {
+        // Uses only name and contactUri to determine hashcode.
+        // This should be sufficient to have a reasonable distribution of hash codes.
+        // Moreover, there should be no two people with the same lookupUri.
+        return Objects.hashCode(lookupUri, name);
+    }
+
+    @Override
+    public boolean equals(Object obj) {
+        if (Objects.equal(this, obj)) return true;
+        if (obj == null) return false;
+        if (obj instanceof ContactInfo) {
+            ContactInfo other = (ContactInfo) obj;
+            return Objects.equal(lookupUri, other.lookupUri)
+                    && TextUtils.equals(name, other.name)
+                    && TextUtils.equals(nameAlternative, other.nameAlternative)
+                    && Objects.equal(type, other.type)
+                    && TextUtils.equals(label, other.label)
+                    && TextUtils.equals(number, other.number)
+                    && TextUtils.equals(formattedNumber, other.formattedNumber)
+                    && TextUtils.equals(normalizedNumber, other.normalizedNumber)
+                    && Objects.equal(photoId, other.photoId)
+                    && Objects.equal(photoUri, other.photoUri)
+                    && TextUtils.equals(objectId, other.objectId)
+                    && Objects.equal(userType, other.userType);
+        }
+        return false;
+    }
+
+    @Override
+    public String toString() {
+        return Objects.toStringHelper(this).add("lookupUri", lookupUri).add("name", name)
+                .add("nameAlternative", nameAlternative)
+                .add("type", type).add("label", label)
+                .add("number", number).add("formattedNumber",formattedNumber)
+                .add("normalizedNumber", normalizedNumber).add("photoId", photoId)
+                .add("photoUri", photoUri).add("objectId", objectId).toString();
+    }
+}
\ No newline at end of file
diff --git a/src-N/com/android/contacts/callblocking/ContactInfoHelper.java b/src-N/com/android/contacts/callblocking/ContactInfoHelper.java
new file mode 100644
index 0000000..de31e37
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/ContactInfoHelper.java
@@ -0,0 +1,338 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.net.Uri;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Contacts;
+import android.provider.ContactsContract.DisplayNameSources;
+import android.provider.ContactsContract.PhoneLookup;
+import android.support.annotation.Nullable;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+
+import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.util.Constants;
+import com.android.contacts.common.util.PermissionsUtil;
+import com.android.contacts.common.util.PhoneNumberHelper;
+import com.android.contacts.common.util.UriUtils;
+
+import org.json.JSONException;
+import org.json.JSONObject;
+
+/**
+ * Utility class to look up the contact information for a given number.
+ */
+public class ContactInfoHelper {
+    private final Context mContext;
+    private final String mCurrentCountryIso;
+
+    /**
+     * The queries to look up the {@link ContactInfo} for a given number in the Call Log.
+     */
+    private static final class PhoneQuery {
+
+        /**
+         * Projection to look up the ContactInfo. Does not include DISPLAY_NAME_ALTERNATIVE as that
+         * column isn't available in ContactsCommon.PhoneLookup
+         */
+        public static final String[] PHONE_LOOKUP_PROJECTION = new String[] {
+                PhoneLookup._ID,
+                PhoneLookup.DISPLAY_NAME,
+                PhoneLookup.TYPE,
+                PhoneLookup.LABEL,
+                PhoneLookup.NUMBER,
+                PhoneLookup.NORMALIZED_NUMBER,
+                PhoneLookup.PHOTO_ID,
+                PhoneLookup.LOOKUP_KEY,
+                PhoneLookup.PHOTO_URI};
+
+        public static final int PERSON_ID = 0;
+        public static final int NAME = 1;
+        public static final int PHONE_TYPE = 2;
+        public static final int LABEL = 3;
+        public static final int MATCHED_NUMBER = 4;
+        public static final int NORMALIZED_NUMBER = 5;
+        public static final int PHOTO_ID = 6;
+        public static final int LOOKUP_KEY = 7;
+        public static final int PHOTO_URI = 8;
+    }
+
+    private static final class NameAlternativeQuery {
+        /**
+         * Projection to look up a contact's DISPLAY_NAME_ALTERNATIVE
+         */
+        public static final String[] DISPLAY_NAME_PROJECTION = new String[] {
+                Contacts.DISPLAY_NAME_ALTERNATIVE,
+        };
+
+        public static final int NAME = 0;
+    }
+
+    public ContactInfoHelper(Context context, String currentCountryIso) {
+        mContext = context;
+        mCurrentCountryIso = currentCountryIso;
+    }
+
+    /**
+     * Returns the contact information for the given number.
+     * <p>
+     * If the number does not match any contact, returns a contact info containing only the number
+     * and the formatted number.
+     * <p>
+     * If an error occurs during the lookup, it returns null.
+     *
+     * @param number the number to look up
+     * @param countryIso the country associated with this number
+     */
+    @Nullable
+    public ContactInfo lookupNumber(String number, String countryIso) {
+        if (TextUtils.isEmpty(number)) {
+            return null;
+        }
+
+        ContactInfo info;
+
+        if (PhoneNumberHelper.isUriNumber(number)) {
+            // The number is a SIP address..
+            info = lookupContactFromUri(getContactInfoLookupUri(number));
+            if (info == null || info == ContactInfo.EMPTY) {
+                // If lookup failed, check if the "username" of the SIP address is a phone number.
+                String username = PhoneNumberHelper.getUsernameFromUriNumber(number);
+                if (PhoneNumberUtils.isGlobalPhoneNumber(username)) {
+                    info = queryContactInfoForPhoneNumber(username, countryIso);
+                }
+            }
+        } else {
+            // Look for a contact that has the given phone number.
+            info = queryContactInfoForPhoneNumber(number, countryIso);
+        }
+
+        final ContactInfo updatedInfo;
+        if (info == null) {
+            // The lookup failed.
+            updatedInfo = null;
+        } else {
+            // If we did not find a matching contact, generate an empty contact info for the number.
+            if (info == ContactInfo.EMPTY) {
+                // Did not find a matching contact.
+                updatedInfo = new ContactInfo();
+                updatedInfo.number = number;
+                updatedInfo.formattedNumber = formatPhoneNumber(number, null, countryIso);
+                updatedInfo.normalizedNumber = PhoneNumberUtils.formatNumberToE164(
+                        number, countryIso);
+                updatedInfo.lookupUri = createTemporaryContactUri(updatedInfo.formattedNumber);
+            } else {
+                updatedInfo = info;
+            }
+        }
+        return updatedInfo;
+    }
+
+    /**
+     * Creates a JSON-encoded lookup uri for a unknown number without an associated contact
+     *
+     * @param number - Unknown phone number
+     * @return JSON-encoded URI that can be used to perform a lookup when clicking on the quick
+     *         contact card.
+     */
+    private static Uri createTemporaryContactUri(String number) {
+        try {
+            final JSONObject contactRows = new JSONObject().put(Phone.CONTENT_ITEM_TYPE,
+                    new JSONObject().put(Phone.NUMBER, number).put(Phone.TYPE, Phone.TYPE_CUSTOM));
+
+            final String jsonString = new JSONObject().put(Contacts.DISPLAY_NAME, number)
+                    .put(Contacts.DISPLAY_NAME_SOURCE, DisplayNameSources.PHONE)
+                    .put(Contacts.CONTENT_ITEM_TYPE, contactRows).toString();
+
+            return Contacts.CONTENT_LOOKUP_URI
+                    .buildUpon()
+                    .appendPath(Constants.LOOKUP_URI_ENCODED)
+                    .appendQueryParameter(ContactsContract.DIRECTORY_PARAM_KEY,
+                            String.valueOf(Long.MAX_VALUE))
+                    .encodedFragment(jsonString)
+                    .build();
+        } catch (JSONException e) {
+            return null;
+        }
+    }
+
+    /**
+     * Looks up a contact using the given URI.
+     * <p>
+     * It returns null if an error occurs, {@link ContactInfo#EMPTY} if no matching contact is
+     * found, or the {@link ContactInfo} for the given contact.
+     * <p>
+     * The {@link ContactInfo#formattedNumber} field is always set to {@code null} in the returned
+     * value.
+     */
+    public ContactInfo lookupContactFromUri(Uri uri) {
+        if (uri == null) {
+            return null;
+        }
+        if (!PermissionsUtil.hasContactsPermissions(mContext)) {
+            return ContactInfo.EMPTY;
+        }
+
+        Cursor phoneLookupCursor = null;
+        try {
+            phoneLookupCursor = mContext.getContentResolver().query(uri,
+                    PhoneQuery.PHONE_LOOKUP_PROJECTION, null, null, null);
+        } catch (NullPointerException e) {
+            // Trap NPE from pre-N CP2
+            return null;
+        }
+        if (phoneLookupCursor == null) {
+            return null;
+        }
+
+        try {
+            if (!phoneLookupCursor.moveToFirst()) {
+                return ContactInfo.EMPTY;
+            }
+            String lookupKey = phoneLookupCursor.getString(PhoneQuery.LOOKUP_KEY);
+            ContactInfo contactInfo = createPhoneLookupContactInfo(phoneLookupCursor, lookupKey);
+            contactInfo.nameAlternative = lookUpDisplayNameAlternative(mContext, lookupKey);
+            return contactInfo;
+        } finally {
+            phoneLookupCursor.close();
+        }
+    }
+
+    private ContactInfo createPhoneLookupContactInfo(Cursor phoneLookupCursor, String lookupKey) {
+        ContactInfo info = new ContactInfo();
+        info.lookupKey = lookupKey;
+        info.lookupUri = Contacts.getLookupUri(phoneLookupCursor.getLong(PhoneQuery.PERSON_ID),
+                lookupKey);
+        info.name = phoneLookupCursor.getString(PhoneQuery.NAME);
+        info.type = phoneLookupCursor.getInt(PhoneQuery.PHONE_TYPE);
+        info.label = phoneLookupCursor.getString(PhoneQuery.LABEL);
+        info.number = phoneLookupCursor.getString(PhoneQuery.MATCHED_NUMBER);
+        info.normalizedNumber = phoneLookupCursor.getString(PhoneQuery.NORMALIZED_NUMBER);
+        info.photoId = phoneLookupCursor.getLong(PhoneQuery.PHOTO_ID);
+        info.photoUri = UriUtils.parseUriOrNull(phoneLookupCursor.getString(PhoneQuery.PHOTO_URI));
+        info.formattedNumber = null;
+        // TODO: pass in directory ID rather than null, and make sure it works with work profiles.
+        info.userType = ContactsUtils.determineUserType(null,
+                phoneLookupCursor.getLong(PhoneQuery.PERSON_ID));
+        return info;
+    }
+
+    public static String lookUpDisplayNameAlternative(Context context, String lookupKey) {
+        if (lookupKey == null) {
+            return null;
+        }
+
+        final Uri uri = Uri.withAppendedPath(Contacts.CONTENT_LOOKUP_URI, lookupKey);
+
+        Cursor cursor = null;
+        try {
+            cursor = context.getContentResolver().query(uri,
+                    NameAlternativeQuery.DISPLAY_NAME_PROJECTION, null, null, null);
+
+            if (cursor != null && cursor.moveToFirst()) {
+                return cursor.getString(NameAlternativeQuery.NAME);
+            }
+        } catch (IllegalArgumentException e) {
+            // Thrown for work profile queries. For those, we don't support
+            // alternative display names.
+        } finally {
+            if (cursor != null) {
+                cursor.close();
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * Determines the contact information for the given phone number.
+     * <p>
+     * It returns the contact info if found.
+     * <p>
+     * If no contact corresponds to the given phone number, returns {@link ContactInfo#EMPTY}.
+     * <p>
+     * If the lookup fails for some other reason, it returns null.
+     */
+    private ContactInfo queryContactInfoForPhoneNumber(String number, String countryIso) {
+        if (TextUtils.isEmpty(number)) {
+            return null;
+        }
+
+        ContactInfo info = lookupContactFromUri(getContactInfoLookupUri(number));
+        if (info != null && info != ContactInfo.EMPTY) {
+            info.formattedNumber = formatPhoneNumber(number, null, countryIso);
+        }
+        return info;
+    }
+
+    /**
+     * Format the given phone number
+     *
+     * @param number the number to be formatted.
+     * @param normalizedNumber the normalized number of the given number.
+     * @param countryIso the ISO 3166-1 two letters country code, the country's convention will be
+     *        used to format the number if the normalized phone is null.
+     *
+     * @return the formatted number, or the given number if it was formatted.
+     */
+    private String formatPhoneNumber(String number, String normalizedNumber, String countryIso) {
+        if (TextUtils.isEmpty(number)) {
+            return "";
+        }
+        // If "number" is really a SIP address, don't try to do any formatting at all.
+        if (com.android.contacts.common.util.PhoneNumberHelper.isUriNumber(number)) {
+            return number;
+        }
+        if (TextUtils.isEmpty(countryIso)) {
+            countryIso = mCurrentCountryIso;
+        }
+        return PhoneNumberUtils.formatNumber(number, normalizedNumber, countryIso);
+    }
+
+
+    public static Uri getContactInfoLookupUri(String number) {
+        return getContactInfoLookupUri(number, -1);
+    }
+
+    public static Uri getContactInfoLookupUri(String number, long directoryId) {
+        // Get URI for the number in the PhoneLookup table, with a parameter to indicate whether
+        // the number is a SIP number.
+        Uri uri = PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI;
+        if (!ContactsUtils.FLAG_N_FEATURE) {
+            if (directoryId != -1) {
+                // ENTERPRISE_CONTENT_FILTER_URI in M doesn't support directory lookup
+                uri = PhoneLookup.CONTENT_FILTER_URI;
+            } else {
+                // b/25900607 in M. PhoneLookup.ENTERPRISE_CONTENT_FILTER_URI, encodes twice.
+                number = Uri.encode(number);
+            }
+        }
+        Uri.Builder builder = uri.buildUpon()
+                .appendPath(number)
+                .appendQueryParameter(PhoneLookup.QUERY_PARAMETER_SIP_ADDRESS,
+                        String.valueOf(PhoneNumberHelper.isUriNumber(number)));
+        if (directoryId != -1) {
+            builder.appendQueryParameter(ContactsContract.DIRECTORY_PARAM_KEY,
+                    String.valueOf(directoryId));
+        }
+        return builder.build();
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/ContentChangedFilter.java b/src-N/com/android/contacts/callblocking/ContentChangedFilter.java
new file mode 100644
index 0000000..2172c5e
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/ContentChangedFilter.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.view.View;
+import android.view.View.AccessibilityDelegate;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+
+/**
+ * AccessibilityDelegate that will filter out TYPE_WINDOW_CONTENT_CHANGED
+ * Used to suppress "Showing items x of y" from firing of ListView whenever it's content changes.
+ * AccessibilityEvent can only be rejected at a view's parent once it is generated,
+ * use addToParent() to add this delegate to the parent.
+ */
+public class ContentChangedFilter extends AccessibilityDelegate {
+    //the view we don't want TYPE_WINDOW_CONTENT_CHANGED to fire.
+    private View mView;
+
+    /**
+     * Add this delegate to the parent of @param view to filter out TYPE_WINDOW_CONTENT_CHANGED
+     */
+    public static void addToParent(View view){
+        View parent = (View) view.getParent();
+        parent.setAccessibilityDelegate(new ContentChangedFilter(view));
+    }
+
+    private ContentChangedFilter(View view){
+        super();
+        mView = view;
+    }
+
+    @Override
+    public boolean onRequestSendAccessibilityEvent (ViewGroup host, View child, AccessibilityEvent event){
+        if(child == mView){
+            if(event.getEventType() == AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED){
+                return false;
+            }
+        }
+        return super.onRequestSendAccessibilityEvent(host,child,event);
+    }
+
+}
diff --git a/src-N/com/android/contacts/callblocking/FilteredNumberAsyncQueryHandler.java b/src-N/com/android/contacts/callblocking/FilteredNumberAsyncQueryHandler.java
new file mode 100644
index 0000000..f7f67eb
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/FilteredNumberAsyncQueryHandler.java
@@ -0,0 +1,221 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.content.AsyncQueryHandler;
+import android.content.ContentResolver;
+import android.content.ContentUris;
+import android.content.ContentValues;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabaseCorruptException;
+import android.net.Uri;
+import android.provider.BlockedNumberContract.BlockedNumbers;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+
+public class FilteredNumberAsyncQueryHandler extends AsyncQueryHandler {
+    private static final int NO_TOKEN = 0;
+
+    public FilteredNumberAsyncQueryHandler(ContentResolver cr) {
+        super(cr);
+    }
+
+    /**
+     * Methods for FilteredNumberAsyncQueryHandler result returns.
+     */
+    private static abstract class Listener {
+        protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+        }
+        protected void onInsertComplete(int token, Object cookie, Uri uri) {
+        }
+        protected void onUpdateComplete(int token, Object cookie, int result) {
+        }
+        protected void onDeleteComplete(int token, Object cookie, int result) {
+        }
+    }
+
+    public interface OnCheckBlockedListener {
+        /**
+         * Invoked after querying if a number is blocked.
+         * @param id The ID of the row if blocked, null otherwise.
+         */
+        void onCheckComplete(Long id);
+    }
+
+    public interface OnBlockNumberListener {
+        /**
+         * Invoked after inserting a blocked number.
+         * @param uri The uri of the newly created row.
+         */
+        void onBlockComplete(Uri uri);
+    }
+
+    public interface OnUnblockNumberListener {
+        /**
+         * Invoked after removing a blocked number
+         * @param rows The number of rows affected (expected value 1).
+         * @param values The deleted data (used for restoration).
+         */
+        void onUnblockComplete(int rows, ContentValues values);
+    }
+
+    @Override
+    protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+        if (cookie != null) {
+            ((Listener) cookie).onQueryComplete(token, cookie, cursor);
+        }
+    }
+
+    @Override
+    protected void onInsertComplete(int token, Object cookie, Uri uri) {
+        if (cookie != null) {
+            ((Listener) cookie).onInsertComplete(token, cookie, uri);
+        }
+    }
+
+    @Override
+    protected void onUpdateComplete(int token, Object cookie, int result) {
+        if (cookie != null) {
+            ((Listener) cookie).onUpdateComplete(token, cookie, result);
+        }
+    }
+
+    @Override
+    protected void onDeleteComplete(int token, Object cookie, int result) {
+        if (cookie != null) {
+            ((Listener) cookie).onDeleteComplete(token, cookie, result);
+        }
+    }
+
+    /**
+     * Check if this number has been blocked.
+     *
+     * @return {@code false} if the number was invalid and couldn't be checked,
+     *     {@code true} otherwise,
+     */
+    public final boolean isBlockedNumber(
+            final OnCheckBlockedListener listener, String number, String countryIso) {
+        final String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);
+        if (TextUtils.isEmpty(normalizedNumber)) {
+            return false;
+        }
+
+        startQuery(NO_TOKEN,
+                new Listener() {
+                    @Override
+                    protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
+                        if (cursor == null || cursor.getCount() != 1) {
+                            listener.onCheckComplete(null);
+                            return;
+                        }
+                        cursor.moveToFirst();
+                        listener.onCheckComplete(cursor.getLong(
+                                        cursor.getColumnIndex(BlockedNumbers.COLUMN_ID)));
+                    }
+                },
+                BlockedNumbers.CONTENT_URI,
+                new String[]{ BlockedNumbers.COLUMN_ID},
+                BlockedNumbers.COLUMN_E164_NUMBER + " = ?",
+                new String[]{ normalizedNumber },
+                null);
+
+        return true;
+    }
+
+    public final void blockNumber(
+            final OnBlockNumberListener listener, String number, String countryIso) {
+        blockNumber(listener, null, number, countryIso);
+    }
+
+    /**
+     * Add a number manually blocked by the user.
+     */
+    public final void blockNumber(
+            final OnBlockNumberListener listener,
+            String normalizedNumber,
+            String number,
+            String countryIso) {
+        if (normalizedNumber == null) {
+            normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);
+        }
+        ContentValues v = new ContentValues();
+        v.put(BlockedNumbers.COLUMN_ORIGINAL_NUMBER, number);
+        v.put(BlockedNumbers.COLUMN_E164_NUMBER, normalizedNumber);
+        blockNumber(listener, v);
+    }
+
+    /**
+     * Block a number with specified ContentValues. Can be manually added or a restored row
+     * from performing the 'undo' action after unblocking.
+     */
+    public final void blockNumber(final OnBlockNumberListener listener, ContentValues values) {
+        startInsert(NO_TOKEN,
+                new Listener() {
+                    @Override
+                    public void onInsertComplete(int token, Object cookie, Uri uri) {
+                        if (listener != null ) {
+                            listener.onBlockComplete(uri);
+                        }
+                    }
+                }, BlockedNumbers.CONTENT_URI, values);
+    }
+
+    /**
+     * Removes row from database.
+     * Caller should call {@link FilteredNumberAsyncQueryHandler#startBlockedQuery} first.
+     * @param id The ID of row to remove, from {@link FilteredNumberAsyncQueryHandler#startBlockedQuery}.
+     */
+    public final void unblock(final OnUnblockNumberListener listener, Integer id) {
+        if (id == null) {
+            throw new IllegalArgumentException("Null id passed into unblock");
+        }
+        unblock(listener, ContentUris.withAppendedId(BlockedNumbers.CONTENT_URI, id));
+    }
+
+    /**
+     * Removes row from database.
+     * @param uri The uri of row to remove, from
+     *         {@link FilteredNumberAsyncQueryHandler#blockNumber}.
+     */
+    public final void unblock(final OnUnblockNumberListener listener, final Uri uri) {
+        startQuery(NO_TOKEN, new Listener() {
+            @Override
+            public void onQueryComplete(int token, Object cookie, Cursor cursor) {
+                int rowsReturned = cursor == null ? 0 : cursor.getCount();
+                if (rowsReturned != 1) {
+                    throw new SQLiteDatabaseCorruptException
+                            ("Returned " + rowsReturned + " rows for uri "
+                                    + uri + "where 1 expected.");
+                }
+                cursor.moveToFirst();
+                final ContentValues values = new ContentValues();
+                DatabaseUtils.cursorRowToContentValues(cursor, values);
+                values.remove(BlockedNumbers.COLUMN_ID);
+
+                startDelete(NO_TOKEN, new Listener() {
+                    @Override
+                    public void onDeleteComplete(int token, Object cookie, int result) {
+                        if (listener != null) {
+                            listener.onUnblockComplete(result, values);
+                        }
+                    }
+                }, uri, null, null);
+            }
+        }, uri, null, null, null, null);
+    }
+}
\ No newline at end of file
diff --git a/src-N/com/android/contacts/callblocking/FilteredNumbersUtil.java b/src-N/com/android/contacts/callblocking/FilteredNumbersUtil.java
new file mode 100644
index 0000000..4f2dcf0
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/FilteredNumbersUtil.java
@@ -0,0 +1,233 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.content.ContentValues;
+import android.content.Context;
+import android.database.Cursor;
+import android.os.AsyncTask;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.provider.ContactsContract.Contacts;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import android.util.Log;
+import android.widget.Toast;
+
+import com.android.contacts.R;
+import com.android.contacts.common.util.TelephonyManagerUtils;
+
+import com.google.i18n.phonenumbers.NumberParseException;
+import com.google.i18n.phonenumbers.Phonenumber;
+import com.google.i18n.phonenumbers.geocoding.PhoneNumberOfflineGeocoder;
+
+import java.util.Locale;
+
+/**
+ * Utility to help with tasks related to filtered numbers.
+ */
+final public class FilteredNumbersUtil {
+
+    private static final String TAG = "FilteredNumbersUtil";
+
+    public interface CheckForSendToVoicemailContactListener {
+        void onComplete(boolean hasSendToVoicemailContact);
+    }
+
+    public interface ImportSendToVoicemailContactsListener {
+        void onImportComplete();
+    }
+
+    private static class ContactsQuery {
+        static final String[] PROJECTION = {
+            Contacts._ID
+        };
+
+        // TODO: as user can set "send to voicemail" for a contact that doesn't have a phone number,
+        // if those are the only contacts that are marked as "send to voicemail", then when you view
+        // numbers it'll be blank. We should also
+        static final String SELECT_SEND_TO_VOICEMAIL_TRUE = Contacts.SEND_TO_VOICEMAIL + "=1";
+
+        static final int ID_COLUMN_INDEX = 0;
+    }
+
+    public static class PhoneQuery {
+        static final String[] PROJECTION = {
+            Contacts._ID,
+            Phone.NORMALIZED_NUMBER,
+            Phone.NUMBER
+        };
+
+        static final int ID_COLUMN_INDEX = 0;
+        static final int NORMALIZED_NUMBER_COLUMN_INDEX = 1;
+        static final int NUMBER_COLUMN_INDEX = 2;
+
+        static final String SELECT_SEND_TO_VOICEMAIL_TRUE = Contacts.SEND_TO_VOICEMAIL + "=1";
+    }
+
+    /**
+     * Checks if there exists a contact with {@code Contacts.SEND_TO_VOICEMAIL} set to true.
+     */
+    public static void checkForSendToVoicemailContact(
+            final Context context, final CheckForSendToVoicemailContactListener listener) {
+        final AsyncTask task = new AsyncTask<Object, Void, Boolean>() {
+            @Override
+            public Boolean doInBackground(Object[]  params) {
+                if (context == null) {
+                    return false;
+                }
+
+                final Cursor cursor = context.getContentResolver().query(
+                        Contacts.CONTENT_URI,
+                        ContactsQuery.PROJECTION,
+                        ContactsQuery.SELECT_SEND_TO_VOICEMAIL_TRUE,
+                        null,
+                        null);
+
+                boolean hasSendToVoicemailContacts = false;
+                if (cursor != null) {
+                    try {
+                        hasSendToVoicemailContacts = cursor.getCount() > 0;
+                    } finally {
+                        cursor.close();
+                    }
+                }
+
+                return hasSendToVoicemailContacts;
+            }
+
+            @Override
+            public void onPostExecute(Boolean hasSendToVoicemailContact) {
+                if (listener != null) {
+                    listener.onComplete(hasSendToVoicemailContact);
+                }
+            }
+        };
+        task.execute();
+    }
+
+    /**
+     * Blocks all the phone numbers of any contacts marked as SEND_TO_VOICEMAIL, then clears the
+     * SEND_TO_VOICEMAIL flag on those contacts.
+     */
+    public static void importSendToVoicemailContacts(
+            final Context context, final ImportSendToVoicemailContactsListener listener) {
+        final FilteredNumberAsyncQueryHandler mFilteredNumberAsyncQueryHandler =
+                new FilteredNumberAsyncQueryHandler(context.getContentResolver());
+
+        final AsyncTask<Object, Void, Boolean> task = new AsyncTask<Object, Void, Boolean>() {
+            @Override
+            public Boolean doInBackground(Object[] params) {
+                if (context == null) {
+                    return false;
+                }
+
+                // Get the phone number of contacts marked as SEND_TO_VOICEMAIL.
+                final Cursor phoneCursor = context.getContentResolver().query(
+                        Phone.CONTENT_URI,
+                        PhoneQuery.PROJECTION,
+                        PhoneQuery.SELECT_SEND_TO_VOICEMAIL_TRUE,
+                        null,
+                        null);
+
+                if (phoneCursor == null) {
+                    return false;
+                }
+
+                try {
+                    while (phoneCursor.moveToNext()) {
+                        final String normalizedNumber = phoneCursor.getString(
+                                PhoneQuery.NORMALIZED_NUMBER_COLUMN_INDEX);
+                        final String number = phoneCursor.getString(
+                                PhoneQuery.NUMBER_COLUMN_INDEX);
+                        if (normalizedNumber != null) {
+                            // Block the phone number of the contact.
+                            mFilteredNumberAsyncQueryHandler.blockNumber(
+                                    null, normalizedNumber, number, null);
+                        }
+                    }
+                } finally {
+                    phoneCursor.close();
+                }
+
+                // Clear SEND_TO_VOICEMAIL on all contacts. The setting has been imported to Dialer.
+                ContentValues newValues = new ContentValues();
+                newValues.put(Contacts.SEND_TO_VOICEMAIL, 0);
+                context.getContentResolver().update(
+                        Contacts.CONTENT_URI,
+                        newValues,
+                        ContactsQuery.SELECT_SEND_TO_VOICEMAIL_TRUE,
+                        null);
+
+                return true;
+            }
+
+            @Override
+            public void onPostExecute(Boolean success) {
+                if (success) {
+                    if (listener != null) {
+                        listener.onImportComplete();
+                    }
+                } else if (context != null) {
+                    String toastStr = context.getString(R.string.send_to_voicemail_import_failed);
+                    Toast.makeText(context, toastStr, Toast.LENGTH_SHORT).show();
+                }
+            }
+        };
+        task.execute();
+    }
+
+    public static boolean canBlockNumber(Context context, String number, String countryIso) {
+        final String normalizedNumber = PhoneNumberUtils.formatNumberToE164(number, countryIso);
+        return !TextUtils.isEmpty(normalizedNumber)
+                && !PhoneNumberUtils.isEmergencyNumber(normalizedNumber);
+    }
+
+    /**
+     * @return a geographical description string for the specified number.
+     * @see com.android.i18n.phonenumbers.PhoneNumberOfflineGeocoder
+     *
+     * Copied from com.android.dialer.util.PhoneNumberUtil.getGeoDescription(mContext, info.number);
+     */
+    public static String getGeoDescription(Context context, String number) {
+        if (TextUtils.isEmpty(number)) {
+            return null;
+        }
+
+        com.google.i18n.phonenumbers.PhoneNumberUtil util =
+                com.google.i18n.phonenumbers.PhoneNumberUtil.getInstance();
+        PhoneNumberOfflineGeocoder geocoder = PhoneNumberOfflineGeocoder.getInstance();
+
+        Locale locale = context.getResources().getConfiguration().locale;
+        String countryIso = TelephonyManagerUtils.getCurrentCountryIso(context, locale);
+        Phonenumber.PhoneNumber pn = null;
+        try {
+            pn = util.parse(number, countryIso);
+        } catch (NumberParseException e) {
+            if (Log.isLoggable(TAG, Log.VERBOSE)) {
+                Log.v(TAG, "getGeoDescription: NumberParseException for incoming number '" +
+                        number + "'");
+            }
+        }
+
+        if (pn != null) {
+            String description = geocoder.getDescriptionForNumber(pn, locale);
+            return description;
+        }
+
+        return null;
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/NumbersAdapter.java b/src-N/com/android/contacts/callblocking/NumbersAdapter.java
new file mode 100644
index 0000000..0622390
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/NumbersAdapter.java
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.app.FragmentManager;
+import android.content.Context;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.text.BidiFormatter;
+import android.text.TextDirectionHeuristics;
+import android.text.TextUtils;
+import android.view.View;
+import android.widget.QuickContactBadge;
+import android.widget.SimpleCursorAdapter;
+import android.widget.TextView;
+
+import com.android.contacts.R;
+import com.android.contacts.callblocking.ContactInfo;
+import com.android.contacts.callblocking.ContactInfoHelper;
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.contacts.common.ContactPhotoManager.DefaultImageRequest;
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.util.UriUtils;
+
+import java.util.Locale;
+
+public class NumbersAdapter extends SimpleCursorAdapter {
+
+    private Context mContext;
+    private FragmentManager mFragmentManager;
+    private ContactInfoHelper mContactInfoHelper;
+    private BidiFormatter mBidiFormatter = BidiFormatter.getInstance();
+    private ContactPhotoManager mContactPhotoManager;
+
+    public NumbersAdapter(
+            Context context,
+            FragmentManager fragmentManager,
+            ContactInfoHelper contactInfoHelper,
+            ContactPhotoManager contactPhotoManager) {
+        super(context, R.layout.blocked_number_item, null, new String[]{}, new int[]{}, 0);
+        mContext = context;
+        mFragmentManager = fragmentManager;
+        mContactInfoHelper = contactInfoHelper;
+        mContactPhotoManager = contactPhotoManager;
+    }
+
+    public void updateView(View view, String number, String countryIso) {
+        // TODO: add touch feedback on list item.
+        final TextView callerName = (TextView) view.findViewById(R.id.caller_name);
+        final TextView callerNumber = (TextView) view.findViewById(R.id.caller_number);
+        final QuickContactBadge quickContactBadge =
+                (QuickContactBadge) view.findViewById(R.id.quick_contact_photo);
+        quickContactBadge.setOverlay(null);
+        if (CompatUtils.hasPrioritizedMimeType()) {
+            quickContactBadge.setPrioritizedMimeType(Phone.CONTENT_ITEM_TYPE);
+        }
+
+        ContactInfo info = mContactInfoHelper.lookupNumber(number, countryIso);
+        if (info == null) {
+            info = new ContactInfo();
+            info.number = number;
+        }
+        final CharSequence locationOrType = getNumberTypeOrLocation(info);
+        final String displayNumber = getDisplayNumber(info);
+        final String displayNumberStr = mBidiFormatter.unicodeWrap(displayNumber,
+                TextDirectionHeuristics.LTR);
+
+        String nameForDefaultImage;
+        if (!TextUtils.isEmpty(info.name)) {
+            nameForDefaultImage = info.name;
+            callerName.setText(info.name);
+            callerNumber.setText(locationOrType + " " + displayNumberStr);
+        } else {
+            nameForDefaultImage = displayNumber;
+            callerName.setText(displayNumberStr);
+            if (!TextUtils.isEmpty(locationOrType)) {
+                callerNumber.setText(locationOrType);
+                callerNumber.setVisibility(View.VISIBLE);
+            } else {
+                callerNumber.setVisibility(View.GONE);
+            }
+        }
+        loadContactPhoto(info, nameForDefaultImage, quickContactBadge);
+    }
+
+    private void loadContactPhoto(ContactInfo info, String displayName, QuickContactBadge badge) {
+        final String lookupKey = info.lookupUri == null
+                ? null : UriUtils.getLookupKeyFromUri(info.lookupUri);
+        final DefaultImageRequest request = new DefaultImageRequest(displayName, lookupKey,
+                ContactPhotoManager.TYPE_DEFAULT, /* isCircular */ true);
+        badge.assignContactUri(info.lookupUri);
+        badge.setContentDescription(
+                mContext.getResources().getString(R.string.description_contact_details, displayName));
+        mContactPhotoManager.loadDirectoryPhoto(badge, info.photoUri,
+                /* darkTheme */ false, /* isCircular */ true, request);
+    }
+
+    private String getDisplayNumber(ContactInfo info) {
+        if (!TextUtils.isEmpty(info.formattedNumber)) {
+            return info.formattedNumber;
+        } else if (!TextUtils.isEmpty(info.number)) {
+            return info.number;
+        } else {
+            return "";
+        }
+    }
+
+    private CharSequence getNumberTypeOrLocation(ContactInfo info) {
+        if (!TextUtils.isEmpty(info.name)) {
+            return Phone.getTypeLabel(
+                    mContext.getResources(), info.type, info.label);
+        } else {
+            return FilteredNumbersUtil.getGeoDescription(mContext, info.number);
+        }
+    }
+
+    protected Context getContext() {
+        return mContext;
+    }
+
+    protected FragmentManager getFragmentManager() {
+        return mFragmentManager;
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/SearchAdapter.java b/src-N/com/android/contacts/callblocking/SearchAdapter.java
new file mode 100644
index 0000000..27ca89a
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/SearchAdapter.java
@@ -0,0 +1,270 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.content.Context;
+import android.content.res.Resources;
+import android.database.Cursor;
+import android.telephony.PhoneNumberUtils;
+import android.text.TextUtils;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.android.contacts.common.CallUtil;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.list.ContactListItemView;
+import com.android.contacts.common.list.PhoneNumberListAdapter;
+import com.android.contacts.common.util.PhoneNumberHelper;
+
+import com.android.contacts.R;
+
+public class SearchAdapter extends PhoneNumberListAdapter {
+
+    private String mFormattedQueryString;
+    private String mCountryIso;
+
+    public final static int SHORTCUT_INVALID = -1;
+    public final static int SHORTCUT_CREATE_NEW_CONTACT = 1;
+    public final static int SHORTCUT_ADD_TO_EXISTING_CONTACT = 2;
+    public final static int SHORTCUT_BLOCK_NUMBER = 5;
+
+    public final static int SHORTCUT_COUNT = 6;
+
+    private final boolean[] mShortcutEnabled = new boolean[SHORTCUT_COUNT];
+
+    private boolean mVideoCallingEnabled = false;
+
+    protected boolean mIsQuerySipAddress;
+
+    private Resources mResources;
+    private FilteredNumberAsyncQueryHandler mFilteredNumberAsyncQueryHandler;
+
+    public SearchAdapter(Context context) {
+        super(context);
+        // below is from ContactsPhoneNumberListAdapter
+        mCountryIso = GeoUtil.getCurrentCountryIso(context);
+        mVideoCallingEnabled = CallUtil.isVideoEnabled(context);
+        // below is from RegularSearchListAdapter
+        setShortcutEnabled(SHORTCUT_CREATE_NEW_CONTACT, false);
+        setShortcutEnabled(SHORTCUT_ADD_TO_EXISTING_CONTACT, false);
+        // below is from BlockedListSearchAdapter
+        mResources = context.getResources();
+        disableAllShortcuts();
+        setShortcutEnabled(SHORTCUT_BLOCK_NUMBER, true);
+        mFilteredNumberAsyncQueryHandler =
+                new FilteredNumberAsyncQueryHandler(context.getContentResolver());
+    }
+
+    @Override
+    public int getCount() {
+        return super.getCount() + getShortcutCount();
+    }
+
+    /**
+     * @return The number of enabled shortcuts. Ranges from 0 to a maximum of SHORTCUT_COUNT
+     */
+    public int getShortcutCount() {
+        int count = 0;
+        for (int i = 0; i < mShortcutEnabled.length; i++) {
+            if (mShortcutEnabled[i]) count++;
+        }
+        return count;
+    }
+
+    public void disableAllShortcuts() {
+        for (int i = 0; i < mShortcutEnabled.length; i++) {
+            mShortcutEnabled[i] = false;
+        }
+    }
+
+    @Override
+    public int getItemViewType(int position) {
+        final int shortcut = getShortcutTypeFromPosition(position);
+        if (shortcut >= 0) {
+            // shortcutPos should always range from 1 to SHORTCUT_COUNT
+            return super.getViewTypeCount() + shortcut;
+        } else {
+            return super.getItemViewType(position);
+        }
+    }
+
+    @Override
+    public int getViewTypeCount() {
+        // Number of item view types in the super implementation + 2 for the 2 new shortcuts
+        return super.getViewTypeCount() + SHORTCUT_COUNT;
+    }
+
+    @Override
+    public View getView(int position, View convertView, ViewGroup parent) {
+        if (getShortcutTypeFromPosition(position) >= 0) {
+            if (convertView != null) {
+                assignShortcutToView((ContactListItemView) convertView);
+                return convertView;
+            } else {
+                final ContactListItemView v = new ContactListItemView(getContext(), null,
+                        mVideoCallingEnabled);
+                assignShortcutToView(v);
+                return v;
+            }
+        } else {
+            return super.getView(position, convertView, parent);
+        }
+    }
+
+    @Override
+    protected ContactListItemView newView(
+            Context context, int partition, Cursor cursor, int position, ViewGroup parent) {
+        final ContactListItemView view = super.newView(context, partition, cursor, position,
+                parent);
+
+        view.setSupportVideoCallIcon(mVideoCallingEnabled);
+        return view;
+    }
+
+    /**
+     * @param position The position of the item
+     * @return The enabled shortcut type matching the given position if the item is a
+     * shortcut, -1 otherwise
+     */
+    public int getShortcutTypeFromPosition(int position) {
+        int shortcutCount = position - super.getCount();
+        if (shortcutCount >= 0) {
+            // Iterate through the array of shortcuts, looking only for shortcuts where
+            // mShortcutEnabled[i] is true
+            for (int i = 0; shortcutCount >= 0 && i < mShortcutEnabled.length; i++) {
+                if (mShortcutEnabled[i]) {
+                    shortcutCount--;
+                    if (shortcutCount < 0) return i;
+                }
+            }
+            throw new IllegalArgumentException("Invalid position - greater than cursor count "
+                    + " but not a shortcut.");
+        }
+        return SHORTCUT_INVALID;
+    }
+
+    @Override
+    public boolean isEmpty() {
+        return getShortcutCount() == 0 && super.isEmpty();
+    }
+
+    @Override
+    public boolean isEnabled(int position) {
+        final int shortcutType = getShortcutTypeFromPosition(position);
+        if (shortcutType >= 0) {
+            return true;
+        } else {
+            return super.isEnabled(position);
+        }
+    }
+
+    private void assignShortcutToView(ContactListItemView v) {
+        v.setDrawableResource(R.drawable.ic_not_interested_googblue_24dp);
+        v.setDisplayName(
+                getContext().getResources().getString(R.string.search_shortcut_block_number));
+        v.setPhotoPosition(super.getPhotoPosition());
+        v.setAdjustSelectionBoundsEnabled(false);
+    }
+
+    /**
+     * @return True if the shortcut state (disabled vs enabled) was changed by this operation
+     */
+    public boolean setShortcutEnabled(int shortcutType, boolean visible) {
+        final boolean changed = mShortcutEnabled[shortcutType] != visible;
+        mShortcutEnabled[shortcutType] = visible;
+        return changed;
+    }
+
+    public String getFormattedQueryString() {
+        if (mIsQuerySipAddress) {
+            // Return unnormalized SIP address
+            return getQueryString();
+        }
+        return mFormattedQueryString;
+    }
+
+    @Override
+    public void setQueryString(String queryString) {
+        // Don't show actions if the query string contains a letter.
+        final boolean showNumberShortcuts = !TextUtils.isEmpty(getFormattedQueryString())
+                && hasDigitsInQueryString();
+        mIsQuerySipAddress = PhoneNumberHelper.isUriNumber(queryString);
+
+        if (isChanged(showNumberShortcuts)) {
+            notifyDataSetChanged();
+        }
+        mFormattedQueryString = PhoneNumberUtils.formatNumber(
+                PhoneNumberUtils.normalizeNumber(queryString), mCountryIso);
+        super.setQueryString(queryString);
+    }
+
+    protected boolean isChanged(boolean showNumberShortcuts) {
+        return setShortcutEnabled(SHORTCUT_BLOCK_NUMBER, showNumberShortcuts || mIsQuerySipAddress);
+    }
+
+    /**
+     * Whether there is at least one digit in the query string.
+     */
+    private boolean hasDigitsInQueryString() {
+        String queryString = getQueryString();
+        int length = queryString.length();
+        for (int i = 0; i < length; i++) {
+            if (Character.isDigit(queryString.charAt(i))) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public void setViewBlocked(ContactListItemView view, Long id) {
+        view.setTag(R.id.block_id, id);
+        final int textColor = mResources.getColor(R.color.blocked_number_block_color);
+        view.getDataView().setTextColor(textColor);
+        view.getLabelView().setTextColor(textColor);
+        //TODO: Add icon
+    }
+
+    public void setViewUnblocked(ContactListItemView view) {
+        view.setTag(R.id.block_id, null);
+        final int textColor = mResources.getColor(R.color.blocked_number_secondary_text_color);
+        view.getDataView().setTextColor(textColor);
+        view.getLabelView().setTextColor(textColor);
+        //TODO: Remove icon
+    }
+
+    @Override
+    protected void bindView(View itemView, int partition, Cursor cursor, int position) {
+        super.bindView(itemView, partition, cursor, position);
+
+        final ContactListItemView view = (ContactListItemView) itemView;
+        // Reset view state to unblocked.
+        setViewUnblocked(view);
+
+        final String number = getPhoneNumber(position);
+        final String countryIso = GeoUtil.getCurrentCountryIso(mContext);
+        final FilteredNumberAsyncQueryHandler.OnCheckBlockedListener onCheckListener =
+                new FilteredNumberAsyncQueryHandler.OnCheckBlockedListener() {
+                    @Override
+                    public void onCheckComplete(Long id) {
+                        if (id != null) {
+                            setViewBlocked(view, id);
+                        }
+                    }
+                };
+        mFilteredNumberAsyncQueryHandler.isBlockedNumber(onCheckListener, number, countryIso);
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/SearchFragment.java b/src-N/com/android/contacts/callblocking/SearchFragment.java
new file mode 100644
index 0000000..d50ccf5
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/SearchFragment.java
@@ -0,0 +1,498 @@
+package com.android.contacts.callblocking;
+
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.content.res.Resources;
+import android.os.Bundle;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v13.app.FragmentCompat;
+import android.telephony.PhoneNumberUtils;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.Log;
+import android.util.TypedValue;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.AbsListView;
+import android.widget.AbsListView.OnScrollListener;
+import android.widget.AdapterView;
+import android.widget.EditText;
+import android.widget.LinearLayout;
+import android.widget.ListView;
+import android.widget.Space;
+import android.widget.Toast;
+
+import com.android.contacts.R;
+import com.android.contacts.callblocking.FilteredNumberAsyncQueryHandler.OnCheckBlockedListener;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.list.ContactEntryListAdapter;
+import com.android.contacts.common.list.ContactListItemView;
+import com.android.contacts.common.list.PhoneNumberPickerFragment;
+import com.android.contacts.common.list.PinnedHeaderListView;
+import com.android.contacts.common.util.ContactDisplayUtils;
+import com.android.contacts.common.util.PermissionsUtil;
+import com.android.contacts.common.util.ViewUtil;
+import com.android.contacts.widget.EmptyContentView;
+import com.android.contacts.widget.SearchEditTextLayout;
+import com.android.contacts.widget.EmptyContentView.OnEmptyViewActionButtonClickedListener;
+
+import static android.Manifest.permission.READ_CONTACTS;
+
+public class SearchFragment extends PhoneNumberPickerFragment
+        implements OnEmptyViewActionButtonClickedListener,
+        FragmentCompat.OnRequestPermissionsResultCallback,
+        BlockNumberDialogFragment.Callback{
+    private static final String TAG  = SearchFragment.class.getSimpleName();
+
+    public static final int PERMISSION_REQUEST_CODE = 1;
+    private static final int SEARCH_DIRECTORY_RESULT_LIMIT = 5;
+
+    private View.OnTouchListener mActivityOnTouchListener;
+    private FilteredNumberAsyncQueryHandler mFilteredNumberAsyncQueryHandler;
+    private EditText mSearchView;
+
+    private final TextWatcher mPhoneSearchQueryTextListener = new TextWatcher() {
+        @Override
+        public void beforeTextChanged(CharSequence s, int start, int count, int after) {}
+
+        @Override
+        public void onTextChanged(CharSequence s, int start, int before, int count) {
+            setQueryString(s.toString(), false);
+        }
+
+        @Override
+        public void afterTextChanged(Editable s) {}
+    };
+
+    private final SearchEditTextLayout.Callback mSearchLayoutCallback =
+            new SearchEditTextLayout.Callback() {
+                @Override
+                public void onBackButtonClicked() {
+                    getActivity().onBackPressed();
+                }
+
+                @Override
+                public void onSearchViewClicked() {
+                }
+            };
+    /**
+     * Stores the untouched user-entered string that is used to populate the add to contacts
+     * intent.
+     */
+    private int mActionBarHeight;
+    private int mShadowHeight;
+    private int mPaddingTop;
+
+    /**
+     * Used to resize the list view containing search results so that it fits the available space
+     * above the dialpad. Does not have a user-visible effect in regular touch usage (since the
+     * dialpad hides that portion of the ListView anyway), but improves usability in accessibility
+     * mode.
+     */
+    private Space mSpacer;
+
+    private HostInterface mActivity;
+
+    protected EmptyContentView mEmptyView;
+
+    public interface HostInterface {
+        boolean isActionBarShowing();
+        boolean isDialpadShown();
+        int getDialpadHeight();
+        int getActionBarHideOffset();
+        int getActionBarHeight();
+    }
+
+    protected String mPermissionToRequest;
+
+    public SearchFragment() {
+        configureDirectorySearch();
+    }
+
+    public void configureDirectorySearch() {
+        setDirectorySearchEnabled(true);
+        setDirectoryResultLimit(SEARCH_DIRECTORY_RESULT_LIMIT);
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        setShowEmptyListForNullQuery(true);
+        /*
+         * Pass in the empty string here so ContactEntryListFragment#setQueryString interprets it as
+         * an empty search query, rather than as an uninitalized value. In the latter case, the
+         * adapter returned by #createListAdapter is used, which populates the view with contacts.
+         * Passing in the empty string forces ContactEntryListFragment to interpret it as an empty
+         * query, which results in showing an empty view
+         */
+        setQueryString(getQueryString() == null ? "" : getQueryString(), false);
+        mFilteredNumberAsyncQueryHandler = new FilteredNumberAsyncQueryHandler(
+                getContext().getContentResolver());
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        ActionBar actionBar = ((AppCompatActivity) getActivity()).getSupportActionBar();
+        actionBar.setCustomView(R.layout.search_edittext);
+        actionBar.setDisplayShowCustomEnabled(true);
+        actionBar.setDisplayHomeAsUpEnabled(false);
+        actionBar.setDisplayShowHomeEnabled(false);
+
+        final SearchEditTextLayout searchEditTextLayout = (SearchEditTextLayout) actionBar
+                .getCustomView().findViewById(R.id.search_view_container);
+        searchEditTextLayout.expand(true);
+        searchEditTextLayout.setCallback(mSearchLayoutCallback);
+        searchEditTextLayout.setBackgroundDrawable(null);
+
+        mSearchView = (EditText) searchEditTextLayout.findViewById(R.id.search_view);
+        mSearchView.addTextChangedListener(mPhoneSearchQueryTextListener);
+        mSearchView.setHint(R.string.block_number_search_hint);
+
+        searchEditTextLayout.findViewById(R.id.search_box_expanded)
+                .setBackgroundColor(getContext().getResources().getColor(android.R.color.white));
+
+        if (!TextUtils.isEmpty(getQueryString())) {
+            mSearchView.setText(getQueryString());
+        }
+
+        // TODO: Don't set custom text size; use default search text size.
+        mSearchView.setTextSize(TypedValue.COMPLEX_UNIT_PX,
+                getResources().getDimension(R.dimen.blocked_number_search_text_size));
+    }
+
+    @Override
+    protected void onCreateView(LayoutInflater inflater, ViewGroup container) {
+        super.onCreateView(inflater, container);
+        ((PinnedHeaderListView) getListView()).setScrollToSectionOnHeaderTouch(true);
+    }
+
+    @Override
+    public void onAttach(Activity activity) {
+        super.onAttach(activity);
+
+        setQuickContactEnabled(true);
+        setAdjustSelectionBoundsEnabled(false);
+        setDarkTheme(false);
+        setPhotoPosition(ContactListItemView.getDefaultPhotoPosition(false /* opposite */));
+        setUseCallableUri(true);
+    }
+
+    @Override
+    public void onStart() {
+        super.onStart();
+        if (isSearchMode()) {
+            getAdapter().setHasHeader(0, false);
+        }
+
+        mActivity = (HostInterface) getActivity();
+
+        final Resources res = getResources();
+        mActionBarHeight = mActivity.getActionBarHeight();
+        mShadowHeight  = res.getDrawable(R.drawable.search_shadow).getIntrinsicHeight();
+        mPaddingTop = res.getDimensionPixelSize(R.dimen.search_list_padding_top);
+
+        final View parentView = getView();
+
+        final ListView listView = getListView();
+
+        if (mEmptyView == null) {
+            mEmptyView = new EmptyContentView(getActivity());
+            ((ViewGroup) getListView().getParent()).addView(mEmptyView);
+            getListView().setEmptyView(mEmptyView);
+            setupEmptyView();
+        }
+
+        listView.setBackgroundColor(res.getColor(R.color.background_contacts_results));
+        listView.setClipToPadding(false);
+        setVisibleScrollbarEnabled(false);
+
+        // Turn off accessibility live region as the list constantly update itself and spam
+        // messages.
+        listView.setAccessibilityLiveRegion(View.ACCESSIBILITY_LIVE_REGION_NONE);
+        ContentChangedFilter.addToParent(listView);
+
+        listView.setOnScrollListener(new OnScrollListener() {
+            @Override
+            public void onScrollStateChanged(AbsListView view, int scrollState) {
+            }
+
+            @Override
+            public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount,
+                                 int totalItemCount) {
+            }
+        });
+        if (mActivityOnTouchListener != null) {
+            listView.setOnTouchListener(mActivityOnTouchListener);
+        }
+
+        updatePosition();
+    }
+
+    @Override
+    public void onViewCreated(View view, Bundle savedInstanceState) {
+        super.onViewCreated(view, savedInstanceState);
+        ViewUtil.addBottomPaddingToListViewForFab(getListView(), getResources());
+    }
+
+    @Override
+    protected void setSearchMode(boolean flag) {
+        super.setSearchMode(flag);
+        // This hides the "All contacts with phone numbers" header in the search fragment
+        final ContactEntryListAdapter adapter = getAdapter();
+        if (adapter != null) {
+            adapter.setHasHeader(0, false);
+        }
+    }
+
+    @Override
+    protected ContactEntryListAdapter createListAdapter() {
+        SearchAdapter adapter = new SearchAdapter(getActivity());
+        adapter.setDisplayPhotos(true);
+        // Don't show SIP addresses.
+        adapter.setUseCallableUri(false);
+        // Keep in sync with the queryString set in #onCreate
+        adapter.setQueryString(getQueryString() == null ? "" : getQueryString());
+        return adapter;
+    }
+
+    protected void setupEmptyView() {
+        if (mEmptyView != null && getActivity() != null) {
+            final int imageResource;
+            final int actionLabelResource;
+            final int descriptionResource;
+            final OnEmptyViewActionButtonClickedListener listener;
+            if (!PermissionsUtil.hasPermission(getActivity(), READ_CONTACTS)) {
+                imageResource = R.drawable.empty_contacts;
+                actionLabelResource = R.string.permission_single_turn_on;
+                descriptionResource = R.string.permission_no_search;
+                listener = this;
+                mPermissionToRequest = READ_CONTACTS;
+            } else {
+                imageResource = EmptyContentView.NO_IMAGE;
+                actionLabelResource = EmptyContentView.NO_LABEL;
+                descriptionResource = EmptyContentView.NO_LABEL;
+                listener = null;
+                mPermissionToRequest = null;
+            }
+
+            mEmptyView.setImage(imageResource);
+            mEmptyView.setActionLabel(actionLabelResource);
+            mEmptyView.setDescription(descriptionResource);
+            if (listener != null) {
+                mEmptyView.setActionClickedListener(listener);
+            }
+        }
+    }
+
+    @Override
+    public void onEmptyViewActionButtonClicked() {
+        final Activity activity = getActivity();
+        if (activity == null) {
+            return;
+        }
+
+        if (READ_CONTACTS.equals(mPermissionToRequest)) {
+            FragmentCompat.requestPermissions(this, new String[]{mPermissionToRequest},
+                    PERMISSION_REQUEST_CODE);
+        }
+    }
+
+
+    @Override
+    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
+        super.onItemClick(parent, view, position, id);
+        final int adapterPosition = position - getListView().getHeaderViewsCount();
+        final SearchAdapter adapter = (SearchAdapter) getAdapter();
+        final int shortcutType = adapter.getShortcutTypeFromPosition(adapterPosition);
+        final Long blockId = (Long) view.getTag(R.id.block_id);
+        final String number;
+        switch (shortcutType) {
+            case SearchAdapter.SHORTCUT_INVALID:
+                // Handles click on a search result, either contact or nearby places result.
+                number = adapter.getPhoneNumber(adapterPosition);
+                blockContactNumber(number, blockId);
+                break;
+            case SearchAdapter.SHORTCUT_BLOCK_NUMBER:
+                // Handles click on 'Block number' shortcut to add the user query as a number.
+                number = adapter.getQueryString();
+                blockNumber(number);
+                break;
+            default:
+                Log.w(TAG, "Ignoring unsupported shortcut type: " + shortcutType);
+                break;
+        }
+    }
+
+    private void blockNumber(final String number) {
+        final String countryIso = GeoUtil.getCurrentCountryIso(getContext());
+        final OnCheckBlockedListener onCheckListener = new OnCheckBlockedListener() {
+            @Override
+            public void onCheckComplete(Long id) {
+                if (id == null) {
+                    BlockNumberDialogFragment.show(
+                            id,
+                            number,
+                            countryIso,
+                            PhoneNumberUtils.formatNumber(number, countryIso),
+                            R.id.blocked_numbers_activity_container,
+                            getFragmentManager(),
+                            SearchFragment.this);
+                } else {
+                    Toast.makeText(getContext(),
+                            ContactDisplayUtils.getTtsSpannedPhoneNumber(getResources(),
+                                    R.string.alreadyBlocked, number),
+                            Toast.LENGTH_SHORT).show();
+                }
+            }
+        };
+        final boolean success = mFilteredNumberAsyncQueryHandler.isBlockedNumber(
+                onCheckListener, number, countryIso);
+        if (!success) {
+            Toast.makeText(getContext(),
+                    ContactDisplayUtils.getTtsSpannedPhoneNumber(
+                            getResources(), R.string.invalidNumber, number),
+                    Toast.LENGTH_SHORT).show();
+        }
+    }
+
+
+    @Override
+    protected void onItemClick(int position, long id) {
+        // Prevent super.onItemClicked(int position, long id) from being called.
+    }
+
+    /**
+     * Updates the position and padding of the search fragment.
+     */
+    public void updatePosition() {
+        int endTranslationValue = 0;
+        // Prevents ListView from being translated down after a rotation when the ActionBar is up.
+        if (mActivity.isActionBarShowing()) {
+            endTranslationValue =
+                    mActivity.isDialpadShown() ? 0 : mActionBarHeight - mShadowHeight;
+        }
+        getView().setTranslationY(endTranslationValue);
+        resizeListView();
+
+        // There is padding which should only be applied when the dialpad is not shown.
+        int paddingTop = mActivity.isDialpadShown() ? 0 : mPaddingTop;
+        final ListView listView = getListView();
+        listView.setPaddingRelative(
+                listView.getPaddingStart(),
+                paddingTop,
+                listView.getPaddingEnd(),
+                listView.getPaddingBottom());
+    }
+
+    public void resizeListView() {
+        if (mSpacer == null) {
+            return;
+        }
+        int spacerHeight = mActivity.isDialpadShown() ? mActivity.getDialpadHeight() : 0;
+        if (spacerHeight != mSpacer.getHeight()) {
+            final LinearLayout.LayoutParams lp =
+                    (LinearLayout.LayoutParams) mSpacer.getLayoutParams();
+            lp.height = spacerHeight;
+            mSpacer.setLayoutParams(lp);
+        }
+    }
+
+    @Override
+    protected void startLoading() {
+        if (getActivity() == null) {
+            return;
+        }
+
+        if (PermissionsUtil.hasContactsPermissions(getActivity())) {
+            super.startLoading();
+        } else if (TextUtils.isEmpty(getQueryString())) {
+            // Clear out any existing call shortcuts.
+            final SearchAdapter adapter = (SearchAdapter) getAdapter();
+            adapter.disableAllShortcuts();
+        } else {
+            // The contact list is not going to change (we have no results since permissions are
+            // denied), but the shortcuts might because of the different query, so update the
+            // list.
+            getAdapter().notifyDataSetChanged();
+        }
+
+        setupEmptyView();
+    }
+
+    public void setOnTouchListener(View.OnTouchListener onTouchListener) {
+        mActivityOnTouchListener = onTouchListener;
+    }
+
+    @Override
+    protected View inflateView(LayoutInflater inflater, ViewGroup container) {
+        final LinearLayout parent = (LinearLayout) super.inflateView(inflater, container);
+        final int orientation = getResources().getConfiguration().orientation;
+        if (orientation == Configuration.ORIENTATION_PORTRAIT) {
+            mSpacer = new Space(getActivity());
+            parent.addView(mSpacer,
+                    new LinearLayout.LayoutParams(LinearLayout.LayoutParams.MATCH_PARENT, 0));
+        }
+        return parent;
+    }
+
+    @Override
+    public void onRequestPermissionsResult(int requestCode, String[] permissions,
+                                           int[] grantResults) {
+        if (requestCode == PERMISSION_REQUEST_CODE) {
+            setupEmptyView();
+            if (grantResults != null && grantResults.length == 1
+                    && PackageManager.PERMISSION_GRANTED == grantResults[0]) {
+                PermissionsUtil.notifyPermissionGranted(getActivity(), mPermissionToRequest);
+            }
+        }
+    }
+
+    @Override
+    public void onFilterNumberSuccess() {
+        goBack();
+    }
+
+    @Override
+    public void onUnfilterNumberSuccess() {
+        Log.wtf(TAG, "Unblocked a number from the SearchFragment");
+        goBack();
+    }
+
+    private void goBack() {
+        Activity activity = getActivity();
+        if (activity == null) {
+            return;
+        }
+        activity.onBackPressed();
+    }
+
+    @Override
+    public void onChangeFilteredNumberUndo() {
+        getAdapter().notifyDataSetChanged();
+    }
+
+    private void blockContactNumber(final String number, final Long blockId) {
+        if (blockId != null) {
+            Toast.makeText(getContext(), ContactDisplayUtils.getTtsSpannedPhoneNumber(
+                            getResources(), R.string.alreadyBlocked, number),
+                    Toast.LENGTH_SHORT).show();
+            return;
+        }
+
+        BlockNumberDialogFragment.show(
+                blockId,
+                number,
+                GeoUtil.getCurrentCountryIso(getContext()),
+                number,
+                R.id.blocked_numbers_activity_container,
+                getFragmentManager(),
+                this);
+    }
+}
diff --git a/src-N/com/android/contacts/callblocking/ViewNumbersToImportAdapter.java b/src-N/com/android/contacts/callblocking/ViewNumbersToImportAdapter.java
new file mode 100644
index 0000000..224e085
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/ViewNumbersToImportAdapter.java
@@ -0,0 +1,57 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.app.FragmentManager;
+import android.database.Cursor;
+import android.content.Context;
+import android.view.View;
+
+import com.android.contacts.common.ContactPhotoManager;
+import com.android.contacts.common.GeoUtil;
+import com.android.contacts.R;
+
+public class ViewNumbersToImportAdapter extends NumbersAdapter {
+
+    private ViewNumbersToImportAdapter(
+            Context context,
+            FragmentManager fragmentManager,
+            ContactInfoHelper contactInfoHelper,
+            ContactPhotoManager contactPhotoManager) {
+        super(context, fragmentManager, contactInfoHelper, contactPhotoManager);
+    }
+
+    public static ViewNumbersToImportAdapter newViewNumbersToImportAdapter(
+            Context context, FragmentManager fragmentManager) {
+        return new ViewNumbersToImportAdapter(
+                context,
+                fragmentManager,
+                new ContactInfoHelper(context, GeoUtil.getCurrentCountryIso(context)),
+                ContactPhotoManager.getInstance(context));
+    }
+
+    @Override
+    public void bindView(View view, Context context, Cursor cursor) {
+        super.bindView(view, context, cursor);
+
+        final String number = cursor.getString(
+                FilteredNumbersUtil.PhoneQuery.NUMBER_COLUMN_INDEX);
+
+        view.findViewById(R.id.delete_button).setVisibility(View.GONE);
+        updateView(view, number, /* countryIso */ null);
+    }
+}
\ No newline at end of file
diff --git a/src-N/com/android/contacts/callblocking/ViewNumbersToImportFragment.java b/src-N/com/android/contacts/callblocking/ViewNumbersToImportFragment.java
new file mode 100644
index 0000000..f756195
--- /dev/null
+++ b/src-N/com/android/contacts/callblocking/ViewNumbersToImportFragment.java
@@ -0,0 +1,132 @@
+/*
+ * Copyright (C) 2016 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.contacts.callblocking;
+
+import android.app.ListFragment;
+import android.app.LoaderManager;
+import android.content.Context;
+import android.content.CursorLoader;
+import android.content.Loader;
+import android.database.Cursor;
+import android.os.Bundle;
+import android.provider.ContactsContract.CommonDataKinds.Phone;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.AppCompatActivity;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+
+import com.android.contacts.R;
+import com.android.contacts.callblocking.FilteredNumbersUtil.ImportSendToVoicemailContactsListener;
+
+public class ViewNumbersToImportFragment extends ListFragment
+        implements LoaderManager.LoaderCallbacks<Cursor>,
+        View.OnClickListener {
+
+    private ViewNumbersToImportAdapter mAdapter;
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
+
+    @Override
+    public void onActivityCreated(Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+
+        if (mAdapter == null) {
+            mAdapter = ViewNumbersToImportAdapter.newViewNumbersToImportAdapter(
+                    getContext(), getActivity().getFragmentManager());
+        }
+        setListAdapter(mAdapter);
+    }
+
+    @Override
+    public void onDestroy() {
+        setListAdapter(null);
+        super.onDestroy();
+    }
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        getLoaderManager().initLoader(0, null, this);
+    }
+
+    @Override
+    public void onResume() {
+        super.onResume();
+
+        ActionBar actionBar = ((AppCompatActivity) getActivity()).getSupportActionBar();
+        actionBar.setTitle(R.string.import_send_to_voicemail_numbers_label);
+        actionBar.setDisplayShowCustomEnabled(false);
+        actionBar.setDisplayHomeAsUpEnabled(true);
+        actionBar.setDisplayShowHomeEnabled(true);
+        actionBar.setDisplayShowTitleEnabled(true);
+
+        getActivity().findViewById(R.id.cancel_button).setOnClickListener(this);
+        getActivity().findViewById(R.id.import_button).setOnClickListener(this);
+    }
+
+    @Override
+    public View onCreateView(
+            LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
+        return inflater.inflate(R.layout.view_numbers_to_import_fragment, container, false);
+    }
+
+    @Override
+    public Loader<Cursor> onCreateLoader(int id, Bundle args) {
+        final CursorLoader cursorLoader = new CursorLoader(
+                getContext(),
+                Phone.CONTENT_URI,
+                FilteredNumbersUtil.PhoneQuery.PROJECTION,
+                FilteredNumbersUtil.PhoneQuery.SELECT_SEND_TO_VOICEMAIL_TRUE,
+                null,
+                null);
+        return cursorLoader;
+    }
+
+    @Override
+    public void onLoadFinished(Loader<Cursor> loader, Cursor data) {
+        mAdapter.swapCursor(data);
+    }
+
+    @Override
+    public void onLoaderReset(Loader<Cursor> loader) {
+        mAdapter.swapCursor(null);
+    }
+
+    @Override
+    public void onClick(final View view) {
+        switch (view.getId()) {
+            case R.id.import_button:
+                FilteredNumbersUtil.importSendToVoicemailContacts(getContext(),
+                        new ImportSendToVoicemailContactsListener() {
+                            @Override
+                            public void onImportComplete() {
+                                if (getActivity() != null) {
+                                    getActivity().onBackPressed();
+                                }
+                            }
+                        });
+                break;
+            case R.id.cancel_button:
+                getActivity().onBackPressed();
+                break;
+        }
+    }
+}
diff --git a/src/com/android/contacts/AppCompatContactsActivity.java b/src/com/android/contacts/AppCompatContactsActivity.java
new file mode 100644
index 0000000..cd5a79f
--- /dev/null
+++ b/src/com/android/contacts/AppCompatContactsActivity.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2016 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.contacts;
+
+import android.app.Fragment;
+import android.app.FragmentManager;
+import android.app.FragmentTransaction;
+import android.content.ContentResolver;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.os.Bundle;
+import android.view.View;
+
+import com.android.contacts.common.activity.AppCompatTransactionSafeActivity;
+import com.android.contacts.common.testing.InjectedServices;
+
+/**
+ * A common superclass for Contacts activities that handles application-wide services, copied from
+ * {@link com.android.contacts.ContactsActivity}, which will be deprecated after Kitkat backporting
+ * is done.
+ */
+public abstract class AppCompatContactsActivity extends AppCompatTransactionSafeActivity
+    implements ContactSaveService.Listener {
+
+    private ContentResolver mContentResolver;
+
+    @Override
+    public ContentResolver getContentResolver() {
+        if (mContentResolver == null) {
+            InjectedServices services = ContactsApplication.getInjectedServices();
+            if (services != null) {
+                mContentResolver = services.getContentResolver();
+            }
+            if (mContentResolver == null) {
+                mContentResolver = super.getContentResolver();
+            }
+        }
+        return mContentResolver;
+    }
+
+    @Override
+    public SharedPreferences getSharedPreferences(String name, int mode) {
+        InjectedServices services = ContactsApplication.getInjectedServices();
+        if (services != null) {
+            SharedPreferences prefs = services.getSharedPreferences();
+            if (prefs != null) {
+                return prefs;
+            }
+        }
+
+        return super.getSharedPreferences(name, mode);
+    }
+
+    @Override
+    public Object getSystemService(String name) {
+        Object service = super.getSystemService(name);
+        if (service != null) {
+            return service;
+        }
+
+        return getApplicationContext().getSystemService(name);
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        ContactSaveService.registerListener(this);
+        super.onCreate(savedInstanceState);
+    }
+
+    @Override
+    protected void onDestroy() {
+        ContactSaveService.unregisterListener(this);
+        super.onDestroy();
+    }
+
+    @Override
+    public void onServiceCompleted(Intent callbackIntent) {
+        onNewIntent(callbackIntent);
+    }
+
+    /**
+     * Convenient version of {@link FragmentManager#findFragmentById(int)}, which throws
+     * an exception if the fragment doesn't exist.
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends Fragment> T getFragment(int id) {
+        T result = (T)getFragmentManager().findFragmentById(id);
+        if (result == null) {
+            throw new IllegalArgumentException("fragment 0x" + Integer.toHexString(id)
+                    + " doesn't exist");
+        }
+        return result;
+    }
+
+    /**
+     * Convenient version of {@link #findViewById(int)}, which throws
+     * an exception if the view doesn't exist.
+     */
+    @SuppressWarnings("unchecked")
+    public <T extends View> T getView(int id) {
+        T result = (T)findViewById(id);
+        if (result == null) {
+            throw new IllegalArgumentException("view 0x" + Integer.toHexString(id)
+                    + " doesn't exist");
+        }
+        return result;
+    }
+
+    protected static void showFragment(FragmentTransaction ft, Fragment f) {
+        if ((f != null) && f.isHidden()) ft.show(f);
+    }
+
+    protected static void hideFragment(FragmentTransaction ft, Fragment f) {
+        if ((f != null) && !f.isHidden()) ft.hide(f);
+    }
+}
diff --git a/src/com/android/contacts/ContactSaveService.java b/src/com/android/contacts/ContactSaveService.java
index d014087..c3a7f24 100755
--- a/src/com/android/contacts/ContactSaveService.java
+++ b/src/com/android/contacts/ContactSaveService.java
@@ -42,20 +42,23 @@
 import android.provider.ContactsContract.Contacts;
 import android.provider.ContactsContract.Data;
 import android.provider.ContactsContract.Groups;
-import android.provider.ContactsContract.PinnedPositions;
 import android.provider.ContactsContract.Profile;
 import android.provider.ContactsContract.RawContacts;
 import android.provider.ContactsContract.RawContactsEntity;
 import android.util.Log;
 import android.widget.Toast;
 
+import com.android.contacts.activities.ContactEditorBaseActivity;
+import com.android.contacts.common.compat.CompatUtils;
 import com.android.contacts.common.database.ContactUpdateUtils;
 import com.android.contacts.common.model.AccountTypeManager;
+import com.android.contacts.common.model.CPOWrapper;
 import com.android.contacts.common.model.RawContactDelta;
 import com.android.contacts.common.model.RawContactDeltaList;
 import com.android.contacts.common.model.RawContactModifier;
 import com.android.contacts.common.model.account.AccountWithDataSet;
 import com.android.contacts.common.util.PermissionsUtil;
+import com.android.contacts.compat.PinnedPositionsCompat;
 import com.android.contacts.util.ContactPhotoUtils;
 
 import com.google.common.collect.Lists;
@@ -172,6 +175,45 @@
         sListeners.remove(listener);
     }
 
+    /**
+     * Returns true if the ContactSaveService was started successfully and false if an exception
+     * was thrown and a Toast error message was displayed.
+     */
+    public static boolean startService(Context context, Intent intent, int saveMode) {
+        try {
+            context.startService(intent);
+        } catch (Exception exception) {
+            final int resId;
+            switch (saveMode) {
+                case ContactEditorBaseActivity.ContactEditor.SaveMode.SPLIT:
+                    resId = R.string.contactUnlinkErrorToast;
+                    break;
+                case ContactEditorBaseActivity.ContactEditor.SaveMode.RELOAD:
+                    resId = R.string.contactJoinErrorToast;
+                    break;
+                case ContactEditorBaseActivity.ContactEditor.SaveMode.CLOSE:
+                    resId = R.string.contactSavedErrorToast;
+                    break;
+                default:
+                    resId = R.string.contactGenericErrorToast;
+            }
+            Toast.makeText(context, resId, Toast.LENGTH_SHORT).show();
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Utility method that starts service and handles exception.
+     */
+    public static void startService(Context context, Intent intent) {
+        try {
+            context.startService(intent);
+        } catch (Exception exception) {
+            Toast.makeText(context, R.string.contactGenericErrorToast, Toast.LENGTH_SHORT).show();
+        }
+    }
+
     @Override
     public Object getSystemService(String name) {
         Object service = super.getSystemService(name);
@@ -385,7 +427,13 @@
         while (tries++ < PERSIST_TRIES) {
             try {
                 // Build operations and try applying
-                final ArrayList<ContentProviderOperation> diff = state.buildDiff();
+                final ArrayList<CPOWrapper> diffWrapper = state.buildDiffWrapper();
+
+                final ArrayList<ContentProviderOperation> diff = Lists.newArrayList();
+
+                for (CPOWrapper cpoWrapper : diffWrapper) {
+                    diff.add(cpoWrapper.getOperation());
+                }
 
                 if (DEBUG) {
                     Log.v(TAG, "Content Provider Operations:");
@@ -413,13 +461,13 @@
                     continue;
                 }
 
-                final long rawContactId = getRawContactId(state, diff, results);
+                final long rawContactId = getRawContactId(state, diffWrapper, results);
                 if (rawContactId == -1) {
                     throw new IllegalStateException("Could not determine RawContact ID after save");
                 }
                 // We don't have to check to see if the value is still -1.  If we reach here,
                 // the previous loop iteration didn't succeed, so any ID that we obtained is bogus.
-                insertedRawContactId = getInsertedRawContactId(diff, results);
+                insertedRawContactId = getInsertedRawContactId(diffWrapper, results);
                 if (isProfile) {
                     // Since the profile supports local raw contacts, which may have been completely
                     // removed if all information was removed, we need to do a special query to
@@ -574,31 +622,31 @@
      * Find the ID of an existing or newly-inserted raw-contact.  If none exists, return -1.
      */
     private long getRawContactId(RawContactDeltaList state,
-            final ArrayList<ContentProviderOperation> diff,
+            final ArrayList<CPOWrapper> diffWrapper,
             final ContentProviderResult[] results) {
         long existingRawContactId = state.findRawContactId();
         if (existingRawContactId != -1) {
             return existingRawContactId;
         }
 
-        return getInsertedRawContactId(diff, results);
+        return getInsertedRawContactId(diffWrapper, results);
     }
 
     /**
      * Find the ID of a newly-inserted raw-contact.  If none exists, return -1.
      */
     private long getInsertedRawContactId(
-            final ArrayList<ContentProviderOperation> diff,
-            final ContentProviderResult[] results) {
+            final ArrayList<CPOWrapper> diffWrapper, final ContentProviderResult[] results) {
         if (results == null) {
             return -1;
         }
-        final int diffSize = diff.size();
+        final int diffSize = diffWrapper.size();
         final int numResults = results.length;
         for (int i = 0; i < diffSize && i < numResults; i++) {
-            ContentProviderOperation operation = diff.get(i);
-            if (operation.isInsert() && operation.getUri().getEncodedPath().contains(
-                            RawContacts.CONTENT_URI.getEncodedPath())) {
+            final CPOWrapper cpoWrapper = diffWrapper.get(i);
+            final boolean isInsert = CompatUtils.isInsertCompat(cpoWrapper);
+            if (isInsert && cpoWrapper.getOperation().getUri().getEncodedPath().contains(
+                    RawContacts.CONTENT_URI.getEncodedPath())) {
                 return ContentUris.parseId(results[i].uri);
             }
         }
@@ -904,7 +952,7 @@
 
                 // Don't bother undemoting if this contact is the user's profile.
                 if (id < Profile.MIN_ID) {
-                    PinnedPositions.undemote(getContentResolver(), id);
+                    PinnedPositionsCompat.undemote(getContentResolver(), id);
                 }
             }
         } finally {
diff --git a/src/com/android/contacts/ContactsApplication.java b/src/com/android/contacts/ContactsApplication.java
index 798614c..f0dc91b 100644
--- a/src/com/android/contacts/ContactsApplication.java
+++ b/src/com/android/contacts/ContactsApplication.java
@@ -29,16 +29,13 @@
 import android.provider.ContactsContract.Contacts;
 import android.util.Log;
 
-import com.android.contacts.common.ContactPhotoManager;
-import com.android.contacts.common.list.ContactListFilterController;
-import com.android.contacts.common.model.AccountTypeManager;
 import com.android.contacts.common.testing.InjectedServices;
 import com.android.contacts.common.util.Constants;
 import com.android.contacts.commonbind.analytics.AnalyticsUtil;
 
 import com.google.common.annotations.VisibleForTesting;
 
-public final class ContactsApplication extends Application {
+public class ContactsApplication extends Application {
     private static final boolean ENABLE_LOADER_LOG = false; // Don't submit with true
     private static final boolean ENABLE_FRAGMENT_LOG = false; // Don't submit with true
 
@@ -48,8 +45,6 @@
      * To enable: adb shell setprop log.tag.ContactsStrictMode DEBUG
      */
     public static final String STRICT_MODE_TAG = "ContactsStrictMode";
-    private ContactPhotoManager mContactPhotoManager;
-    private ContactListFilterController mContactListFilterController;
 
     /**
      * Overrides the system services with mocks for testing.
diff --git a/src/com/android/contacts/activities/ActionBarAdapter.java b/src/com/android/contacts/activities/ActionBarAdapter.java
index fd26035..ad70d92 100644
--- a/src/com/android/contacts/activities/ActionBarAdapter.java
+++ b/src/com/android/contacts/activities/ActionBarAdapter.java
@@ -17,13 +17,15 @@
 package com.android.contacts.activities;
 
 import android.animation.ValueAnimator;
-import android.app.ActionBar;
 import android.app.Activity;
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.content.res.TypedArray;
 import android.os.Bundle;
 import android.preference.PreferenceManager;
+import android.support.v4.content.ContextCompat;
+import android.support.v7.app.ActionBar;
+import android.support.v7.widget.Toolbar;
 import android.text.Editable;
 import android.text.TextUtils;
 import android.text.TextWatcher;
@@ -38,10 +40,10 @@
 import android.view.View.OnClickListener;
 import android.widget.EditText;
 import android.widget.TextView;
-import android.widget.Toolbar;
 
 import com.android.contacts.R;
 import com.android.contacts.activities.ActionBarAdapter.Listener.Action;
+import com.android.contacts.common.compat.CompatUtils;
 import com.android.contacts.list.ContactsRequest;
 
 /**
@@ -73,14 +75,11 @@
     private static final String EXTRA_KEY_QUERY = "navBar.query";
     private static final String EXTRA_KEY_SELECTED_TAB = "navBar.selectedTab";
     private static final String EXTRA_KEY_SELECTED_MODE = "navBar.selectionMode";
-    private static final String EXTRA_KEY_SHOULD_OPEN_OVERFLOW = "navBar.shouldOpenOverflow";
 
     private static final String PERSISTENT_LAST_TAB = "actionBarAdapter.lastTab";
 
     private boolean mSelectionMode;
     private boolean mSearchMode;
-    private boolean mShouldOverflowOpen;
-    private boolean mIsOverflowOpen;
     private String mQueryString;
 
     private EditText mSearchView;
@@ -201,12 +200,11 @@
             mQueryString = request.getQueryString();
             mCurrentTab = loadLastTabPreference();
             mSelectionMode = false;
-            setShouldOpenOverflow(false);
         } else {
             mSearchMode = savedState.getBoolean(EXTRA_KEY_SEARCH_MODE);
             mSelectionMode = savedState.getBoolean(EXTRA_KEY_SELECTED_MODE);
             mQueryString = savedState.getString(EXTRA_KEY_QUERY);
-            setShouldOpenOverflow(savedState.getBoolean(EXTRA_KEY_SHOULD_OPEN_OVERFLOW));
+
             // Just set to the field here.  The listener will be notified by update().
             mCurrentTab = savedState.getInt(EXTRA_KEY_SELECTED_TAB);
         }
@@ -323,22 +321,6 @@
         }
     }
 
-    public void setShouldOpenOverflow(boolean shouldOpenOverflow) {
-        mShouldOverflowOpen = shouldOpenOverflow;
-    }
-
-    public boolean shouldOpenOverflow() {
-        return mShouldOverflowOpen;
-    }
-
-    public void setOverflowOpen(boolean isOverflowOpen) {
-        mIsOverflowOpen = isOverflowOpen;
-    }
-
-    public boolean isOverflowOpen() {
-        return mIsOverflowOpen;
-    }
-
     public String getQueryString() {
         return mSearchMode ? mQueryString : null;
     }
@@ -501,12 +483,16 @@
     }
 
     private void updateStatusBarColor() {
+        if (!CompatUtils.isLollipopCompatible()) {
+            return; // we can't change the status bar color prior to Lollipop
+        }
         if (mSelectionMode) {
-            int cabStatusBarColor = mActivity.getResources().getColor(
+            final int cabStatusBarColor = mActivity.getResources().getColor(
                     R.color.contextual_selection_bar_status_bar_color);
             mActivity.getWindow().setStatusBarColor(cabStatusBarColor);
         } else {
-            int normalStatusBarColor = mActivity.getColor(R.color.primary_color_dark);
+            final int normalStatusBarColor = ContextCompat.getColor(
+                    mActivity, R.color.primary_color_dark);
             mActivity.getWindow().setStatusBarColor(normalStatusBarColor);
         }
     }
@@ -567,7 +553,6 @@
     public void onSaveInstanceState(Bundle outState) {
         outState.putBoolean(EXTRA_KEY_SEARCH_MODE, mSearchMode);
         outState.putBoolean(EXTRA_KEY_SELECTED_MODE, mSelectionMode);
-        outState.putBoolean(EXTRA_KEY_SHOULD_OPEN_OVERFLOW, mShouldOverflowOpen);
         outState.putString(EXTRA_KEY_QUERY, mQueryString);
         outState.putInt(EXTRA_KEY_SELECTED_TAB, mCurrentTab);
     }
diff --git a/src/com/android/contacts/activities/AttachPhotoActivity.java b/src/com/android/contacts/activities/AttachPhotoActivity.java
index 9dad2e7..1abbecf 100644
--- a/src/com/android/contacts/activities/AttachPhotoActivity.java
+++ b/src/com/android/contacts/activities/AttachPhotoActivity.java
@@ -337,7 +337,7 @@
                 raw.getRawContactId() != null ? raw.getRawContactId() : -1,
                 mCroppedPhotoUri
         );
-        startService(intent);
+        ContactSaveService.startService(this, intent);
         finish();
     }
 
diff --git a/src/com/android/contacts/activities/CompactContactEditorActivity.java b/src/com/android/contacts/activities/CompactContactEditorActivity.java
index 0de20e7..dc16049 100644
--- a/src/com/android/contacts/activities/CompactContactEditorActivity.java
+++ b/src/com/android/contacts/activities/CompactContactEditorActivity.java
@@ -44,6 +44,7 @@
     private static final String STATE_PHOTO_MODE = "photo_mode";
     private static final String STATE_IS_PHOTO_SELECTION = "is_photo_selection";
     private static final String STATE_ACTION_BAR_TITLE = "action_bar_title";
+    private static final String STATE_PHOTO_URI = "photo_uri";
 
     /**
      * Displays a PopupWindow with photo edit options.
@@ -147,6 +148,7 @@
             mPhotoMode = savedState.getInt(STATE_PHOTO_MODE);
             mIsPhotoSelection = savedState.getBoolean(STATE_IS_PHOTO_SELECTION);
             mActionBarTitleResId = savedState.getInt(STATE_ACTION_BAR_TITLE);
+            mPhotoUri = Uri.parse(savedState.getString(STATE_PHOTO_URI));
 
             // Show/hide the editor and photo selection fragments (w/o animations)
             mFragment = (CompactContactEditorFragment) getFragmentManager()
@@ -179,12 +181,16 @@
         outState.putInt(STATE_PHOTO_MODE, mPhotoMode);
         outState.putBoolean(STATE_IS_PHOTO_SELECTION, mIsPhotoSelection);
         outState.putInt(STATE_ACTION_BAR_TITLE, mActionBarTitleResId);
+        outState.putString(STATE_PHOTO_URI,
+                mPhotoUri != null ? mPhotoUri.toString() : Uri.EMPTY.toString());
     }
 
     @Override
     public void onActivityResult(int requestCode, int resultCode, Intent data) {
-        if (mPhotoSelectionHandler != null &&
-                mPhotoSelectionHandler.handlePhotoActivityResult(requestCode, resultCode, data)) {
+        if (mPhotoSelectionHandler == null) {
+            mPhotoSelectionHandler = (CompactPhotoSelectionHandler) getPhotoSelectionHandler();
+        }
+        if (mPhotoSelectionHandler.handlePhotoActivityResult(requestCode, resultCode, data)) {
             return;
         }
         super.onActivityResult(requestCode, resultCode, data);
diff --git a/src/com/android/contacts/activities/ConfirmAddDetailActivity.java b/src/com/android/contacts/activities/ConfirmAddDetailActivity.java
index f4e8c78..f9a9735 100644
--- a/src/com/android/contacts/activities/ConfirmAddDetailActivity.java
+++ b/src/com/android/contacts/activities/ConfirmAddDetailActivity.java
@@ -16,7 +16,6 @@
 
 package com.android.contacts.activities;
 
-import android.app.Activity;
 import android.app.Dialog;
 import android.app.ProgressDialog;
 import android.content.AsyncQueryHandler;
@@ -47,6 +46,7 @@
 import android.provider.ContactsContract.Data;
 import android.provider.ContactsContract.RawContacts;
 import android.provider.ContactsContract.RawContactsEntity;
+import android.support.v7.app.AppCompatActivity;
 import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
 import android.util.Log;
@@ -102,7 +102,7 @@
  * Note when there's no accounts, it *is* okay to show the picker / dialog, because the local-only
  * contacts are writable.
  */
-public class ConfirmAddDetailActivity extends Activity implements
+public class ConfirmAddDetailActivity extends AppCompatActivity implements
         DialogManager.DialogShowingViewActivity {
 
     private static final String TAG = "ConfirmAdd"; // The class name is too long to be a tag.
diff --git a/src/com/android/contacts/activities/ContactEditorAccountsChangedActivity.java b/src/com/android/contacts/activities/ContactEditorAccountsChangedActivity.java
index a922ca1..617ef0d 100644
--- a/src/com/android/contacts/activities/ContactEditorAccountsChangedActivity.java
+++ b/src/com/android/contacts/activities/ContactEditorAccountsChangedActivity.java
@@ -16,10 +16,12 @@
 
 package com.android.contacts.activities;
 
-import android.app.Activity;
+import android.app.AlertDialog;
+import android.content.DialogInterface;
 import android.content.Intent;
 import android.os.Bundle;
 import android.provider.ContactsContract.Intents;
+import android.support.v7.app.AppCompatActivity;
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.widget.AdapterView;
@@ -34,6 +36,7 @@
 import com.android.contacts.common.model.account.AccountWithDataSet;
 import com.android.contacts.common.util.AccountsListAdapter;
 import com.android.contacts.common.util.AccountsListAdapter.AccountListFilter;
+import com.android.contacts.util.AccountPromptUtils;
 
 import java.util.List;
 
@@ -45,7 +48,7 @@
  * the new contact in. If the activity result doesn't contain intent data, then there is no
  * account for this contact.
  */
-public class ContactEditorAccountsChangedActivity extends Activity {
+public class ContactEditorAccountsChangedActivity extends AppCompatActivity {
 
     private static final String TAG = ContactEditorAccountsChangedActivity.class.getSimpleName();
 
@@ -67,8 +70,8 @@
     private final OnClickListener mAddAccountClickListener = new OnClickListener() {
         @Override
         public void onClick(View v) {
-            startActivityForResult(mEditorUtils.createAddWritableAccountIntent(),
-                    SUBACTIVITY_ADD_NEW_ACCOUNT);
+            final Intent intent = AccountPromptUtils.getIntentForAddingAccount();
+            startActivityForResult(intent, SUBACTIVITY_ADD_NEW_ACCOUNT);
         }
     };
 
@@ -84,19 +87,21 @@
             throw new IllegalStateException("Cannot have a negative number of accounts");
         }
 
+        final View view;
         if (numAccounts >= 2) {
             // When the user has 2+ writable accounts, show a list of accounts so the user can pick
             // which account to create a contact in.
-            setContentView(R.layout.contact_editor_accounts_changed_activity_with_picker);
+            view = View.inflate(this,
+                    R.layout.contact_editor_accounts_changed_activity_with_picker, null);
 
-            final TextView textView = (TextView) findViewById(R.id.text);
+            final TextView textView = (TextView) view.findViewById(R.id.text);
             textView.setText(getString(R.string.contact_editor_prompt_multiple_accounts));
 
-            final Button button = (Button) findViewById(R.id.add_account_button);
+            final Button button = (Button) view.findViewById(R.id.add_account_button);
             button.setText(getString(R.string.add_new_account));
             button.setOnClickListener(mAddAccountClickListener);
 
-            final ListView accountListView = (ListView) findViewById(R.id.account_list);
+            final ListView accountListView = (ListView) view.findViewById(R.id.account_list);
             mAccountListAdapter = new AccountsListAdapter(this,
                     AccountListFilter.ACCOUNTS_CONTACT_WRITABLE);
             accountListView.setAdapter(mAccountListAdapter);
@@ -104,11 +109,12 @@
         } else if (numAccounts == 1) {
             // If the user has 1 writable account we will just show the user a message with 2
             // possible action buttons.
-            setContentView(R.layout.contact_editor_accounts_changed_activity_with_text);
+            view = View.inflate(this,
+                    R.layout.contact_editor_accounts_changed_activity_with_text, null);
 
-            final TextView textView = (TextView) findViewById(R.id.text);
-            final Button leftButton = (Button) findViewById(R.id.left_button);
-            final Button rightButton = (Button) findViewById(R.id.right_button);
+            final TextView textView = (TextView) view.findViewById(R.id.text);
+            final Button leftButton = (Button) view.findViewById(R.id.left_button);
+            final Button rightButton = (Button) view.findViewById(R.id.right_button);
 
             final AccountWithDataSet account = accounts.get(0);
             textView.setText(getString(R.string.contact_editor_prompt_one_account,
@@ -131,11 +137,12 @@
         } else {
             // If the user has 0 writable accounts, we will just show the user a message with 2
             // possible action buttons.
-            setContentView(R.layout.contact_editor_accounts_changed_activity_with_text);
+            view = View.inflate(this,
+                    R.layout.contact_editor_accounts_changed_activity_with_text, null);
 
-            final TextView textView = (TextView) findViewById(R.id.text);
-            final Button leftButton = (Button) findViewById(R.id.left_button);
-            final Button rightButton = (Button) findViewById(R.id.right_button);
+            final TextView textView = (TextView) view.findViewById(R.id.text);
+            final Button leftButton = (Button) view.findViewById(R.id.left_button);
+            final Button rightButton = (Button) view.findViewById(R.id.right_button);
 
             textView.setText(getString(R.string.contact_editor_prompt_zero_accounts));
 
@@ -158,6 +165,17 @@
             rightButton.setText(getString(R.string.add_account));
             rightButton.setOnClickListener(mAddAccountClickListener);
         }
+
+        new AlertDialog.Builder(this)
+                .setView(view)
+                .setOnCancelListener(new DialogInterface.OnCancelListener() {
+                    @Override
+                    public void onCancel(DialogInterface dialog) {
+                        finish();
+                    }
+                })
+                .create()
+                .show();
     }
 
     @Override
diff --git a/src/com/android/contacts/activities/ContactSelectionActivity.java b/src/com/android/contacts/activities/ContactSelectionActivity.java
index ee6173e..33c3f38 100644
--- a/src/com/android/contacts/activities/ContactSelectionActivity.java
+++ b/src/com/android/contacts/activities/ContactSelectionActivity.java
@@ -16,8 +16,6 @@
 
 package com.android.contacts.activities;
 
-import android.app.ActionBar;
-import android.app.ActionBar.LayoutParams;
 import android.app.Activity;
 import android.app.Fragment;
 import android.content.ActivityNotFoundException;
@@ -27,6 +25,8 @@
 import android.os.Bundle;
 import android.provider.ContactsContract.Contacts;
 import android.provider.ContactsContract.Intents.Insert;
+import android.support.v7.app.ActionBar;
+import android.support.v7.app.ActionBar.LayoutParams;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.LayoutInflater;
@@ -37,12 +37,12 @@
 import android.view.View.OnClickListener;
 import android.view.View.OnFocusChangeListener;
 import android.view.inputmethod.InputMethodManager;
-import android.widget.SearchView;
-import android.widget.SearchView.OnCloseListener;
-import android.widget.SearchView.OnQueryTextListener;
+import android.support.v7.widget.SearchView;
+import android.support.v7.widget.SearchView.OnCloseListener;
+import android.support.v7.widget.SearchView.OnQueryTextListener;
 import android.widget.Toast;
 
-import com.android.contacts.ContactsActivity;
+import com.android.contacts.AppCompatContactsActivity;
 import com.android.contacts.R;
 import com.android.contacts.common.activity.RequestPermissionsActivity;
 import com.android.contacts.common.list.ContactEntryListFragment;
@@ -70,7 +70,7 @@
  * Displays a list of contacts (or phone numbers or postal addresses) for the
  * purposes of selecting one.
  */
-public class ContactSelectionActivity extends ContactsActivity
+public class ContactSelectionActivity extends AppCompatContactsActivity
         implements View.OnCreateContextMenuListener, OnQueryTextListener, OnClickListener,
                 OnCloseListener, OnFocusChangeListener {
     private static final String TAG = "ContactSelectionActivity";
@@ -138,7 +138,7 @@
     }
 
     private void prepareSearchViewAndActionBar() {
-        final ActionBar actionBar = getActionBar();
+        final ActionBar actionBar = getSupportActionBar();
         mSearchViewContainer = LayoutInflater.from(actionBar.getThemedContext())
                 .inflate(R.layout.custom_action_bar, null);
         mSearchView = (SearchView) mSearchViewContainer.findViewById(R.id.search_view);
@@ -181,7 +181,7 @@
     }
 
     private void configureSearchMode() {
-        final ActionBar actionBar = getActionBar();
+        final ActionBar actionBar = getSupportActionBar();
         if (mIsSearchMode) {
             actionBar.setDisplayShowTitleEnabled(false);
             mSearchViewContainer.setVisibility(View.VISIBLE);
@@ -483,7 +483,7 @@
     private final class PhoneNumberPickerActionListener implements
             OnPhoneNumberPickerActionListener {
         @Override
-        public void onPickDataUri(Uri dataUri, int callInitiationType) {
+        public void onPickDataUri(Uri dataUri, boolean isVideoCall, int callInitiationType) {
             returnPickerResult(dataUri);
         }
 
diff --git a/src/com/android/contacts/activities/PeopleActivity.java b/src/com/android/contacts/activities/PeopleActivity.java
index f03f1eb..d887ef9 100644
--- a/src/com/android/contacts/activities/PeopleActivity.java
+++ b/src/com/android/contacts/activities/PeopleActivity.java
@@ -27,18 +27,20 @@
 import android.content.pm.ResolveInfo;
 import android.graphics.Rect;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Bundle;
 import android.os.Parcelable;
 import android.os.UserManager;
-import android.os.Handler;
 import android.preference.PreferenceActivity;
 import android.provider.ContactsContract;
 import android.provider.ContactsContract.Contacts;
 import android.provider.ContactsContract.ProviderStatus;
+import android.provider.ContactsContract.QuickContact;
 import android.provider.Settings;
 import android.support.v13.app.FragmentPagerAdapter;
 import android.support.v4.view.PagerAdapter;
 import android.support.v4.view.ViewPager;
+import android.support.v7.widget.Toolbar;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.KeyCharacterMap;
@@ -48,12 +50,10 @@
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
-import android.view.Window;
 import android.widget.ImageButton;
 import android.widget.Toast;
-import android.widget.Toolbar;
 
-import com.android.contacts.ContactsActivity;
+import com.android.contacts.AppCompatContactsActivity;
 import com.android.contacts.R;
 import com.android.contacts.activities.ActionBarAdapter.TabState;
 import com.android.contacts.common.ContactsUtils;
@@ -61,37 +61,40 @@
 import com.android.contacts.common.dialog.ClearFrequentsDialog;
 import com.android.contacts.common.util.ImplicitIntentsUtil;
 import com.android.contacts.common.widget.FloatingActionButtonController;
-import com.android.contacts.editor.EditorIntents;
-import com.android.contacts.interactions.ContactDeletionInteraction;
 import com.android.contacts.common.interactions.ImportExportDialogFragment;
 import com.android.contacts.common.list.ContactEntryListFragment;
 import com.android.contacts.common.list.ContactListFilter;
 import com.android.contacts.common.list.ContactListFilterController;
 import com.android.contacts.common.list.ContactTileAdapter.DisplayType;
+import com.android.contacts.common.list.DirectoryListLoader;
+import com.android.contacts.common.list.ViewPagerTabs;
+import com.android.contacts.common.logging.Logger;
+import com.android.contacts.common.logging.ScreenEvent;
+import com.android.contacts.common.preference.ContactsPreferenceActivity;
+import com.android.contacts.common.preference.DisplayOptionsPreferenceFragment;
+import com.android.contacts.common.util.AccountFilterUtil;
+import com.android.contacts.common.util.Constants;
+import com.android.contacts.common.util.ViewUtil;
+import com.android.contacts.editor.EditorIntents;
+import com.android.contacts.interactions.ContactDeletionInteraction;
 import com.android.contacts.interactions.ContactMultiDeletionInteraction;
 import com.android.contacts.interactions.ContactMultiDeletionInteraction.MultiContactDeleteListener;
 import com.android.contacts.interactions.JoinContactsDialogFragment;
 import com.android.contacts.interactions.JoinContactsDialogFragment.JoinContactsListener;
-import com.android.contacts.list.MultiSelectContactsListFragment;
-import com.android.contacts.list.MultiSelectContactsListFragment.OnCheckBoxListActionListener;
 import com.android.contacts.list.ContactTileListFragment;
 import com.android.contacts.list.ContactsIntentResolver;
 import com.android.contacts.list.ContactsRequest;
 import com.android.contacts.list.ContactsUnavailableFragment;
-import com.android.contacts.common.list.DirectoryListLoader;
-import com.android.contacts.common.preference.DisplayOptionsPreferenceFragment;
+import com.android.contacts.list.MultiSelectContactsListFragment;
+import com.android.contacts.list.MultiSelectContactsListFragment.OnCheckBoxListActionListener;
 import com.android.contacts.list.OnContactBrowserActionListener;
 import com.android.contacts.list.OnContactsUnavailableActionListener;
 import com.android.contacts.list.ProviderStatusWatcher;
 import com.android.contacts.list.ProviderStatusWatcher.ProviderStatusListener;
-import com.android.contacts.common.list.ViewPagerTabs;
-import com.android.contacts.preference.ContactsPreferenceActivity;
-import com.android.contacts.common.util.AccountFilterUtil;
-import com.android.contacts.common.util.ViewUtil;
 import com.android.contacts.quickcontact.QuickContactActivity;
 import com.android.contacts.util.AccountPromptUtils;
-import com.android.contacts.common.util.Constants;
 import com.android.contacts.util.DialogManager;
+import com.android.contacts.util.PhoneCapabilityTester;
 import com.android.contactsbind.HelpUtils;
 
 import java.util.List;
@@ -101,7 +104,7 @@
 /**
  * Displays a list to browse contacts.
  */
-public class PeopleActivity extends ContactsActivity implements
+public class PeopleActivity extends AppCompatContactsActivity implements
         View.OnCreateContextMenuListener,
         View.OnClickListener,
         ActionBarAdapter.Listener,
@@ -299,10 +302,6 @@
     }
 
     private void createViewsAndFragments(Bundle savedState) {
-        // Disable the ActionBar so that we can use a Toolbar. This needs to be called before
-        // setContentView().
-        getWindow().requestFeature(Window.FEATURE_NO_TITLE);
-
         setContentView(R.layout.people_activity);
 
         final FragmentManager fragmentManager = getFragmentManager();
@@ -318,9 +317,9 @@
         mTabPager.setAdapter(mTabPagerAdapter);
         mTabPager.setOnPageChangeListener(mTabPagerListener);
 
-        // Configure toolbar and toolbar tabs. If in landscape mode, we  configure tabs differntly.
+        // Configure toolbar and toolbar tabs. If in landscape mode, we configure tabs differently.
         final Toolbar toolbar = getView(R.id.toolbar);
-        setActionBar(toolbar);
+        setSupportActionBar(toolbar);
         final ViewPagerTabs portraitViewPagerTabs
                 = (ViewPagerTabs) findViewById(R.id.lists_pager_header);
         ViewPagerTabs landscapeViewPagerTabs = null;
@@ -371,7 +370,7 @@
         // Setting Properties after fragment is created
         mFavoritesFragment.setDisplayType(DisplayType.STREQUENT);
 
-        mActionBarAdapter = new ActionBarAdapter(this, this, getActionBar(),
+        mActionBarAdapter = new ActionBarAdapter(this, this, getSupportActionBar(),
                 portraitViewPagerTabs, landscapeViewPagerTabs, toolbar);
         mActionBarAdapter.initialize(savedState, mRequest);
 
@@ -438,16 +437,6 @@
         // Current tab may have changed since the last onSaveInstanceState().  Make sure
         // the actual contents match the tab.
         updateFragmentsVisibility();
-
-        if (mActionBarAdapter.shouldOpenOverflow() && !mActionBarAdapter.isOverflowOpen()) {
-            new Handler().postDelayed(new Runnable() {
-                @Override
-                public void run() {
-                    openOptionsMenu();
-                }
-            }, /* delayMillis = */ getResources().getInteger(R.integer.
-                    open_overflow_menu_delay_millis));
-        }
     }
 
     @Override
@@ -565,13 +554,14 @@
         switch (action) {
             case ActionBarAdapter.Listener.Action.START_SELECTION_MODE:
                 mAllFragment.displayCheckBoxes(true);
-                // Fall through:
+                startSearchOrSelectionMode();
+                break;
             case ActionBarAdapter.Listener.Action.START_SEARCH_MODE:
-                // Tell the fragments that we're in the search mode or selection mode
-                configureFragments(false /* from request */);
-                updateFragmentsVisibility();
-                invalidateOptionsMenu();
-                showFabWithAnimation(/* showFabWithAnimation = */ false);
+                if (!mIsRecreatedInstance) {
+                    Logger.getInstance().logScreenView(
+                            ScreenEvent.SEARCH, this, ScreenEvent.TAG_SEARCH);
+                }
+                startSearchOrSelectionMode();
                 break;
             case ActionBarAdapter.Listener.Action.BEGIN_STOPPING_SEARCH_AND_SELECTION_MODE:
                 showFabWithAnimation(/* showFabWithAnimation = */ true);
@@ -593,6 +583,13 @@
         }
     }
 
+    private void startSearchOrSelectionMode() {
+        configureFragments(false /* from request */);
+        updateFragmentsVisibility();
+        invalidateOptionsMenu();
+        showFabWithAnimation(/* showFabWithAnimation = */ false);
+    }
+
     @Override
     public void onSelectedTabChanged() {
         updateFragmentsVisibility();
@@ -955,10 +952,17 @@
         }
 
         @Override
-        public void onViewContactAction(Uri contactLookupUri) {
-            final Intent intent = ImplicitIntentsUtil.composeQuickContactIntent(contactLookupUri,
-                    QuickContactActivity.MODE_FULLY_EXPANDED);
-            ImplicitIntentsUtil.startActivityInApp(PeopleActivity.this, intent);
+        public void onViewContactAction(Uri contactLookupUri, boolean isEnterpriseContact) {
+            if (isEnterpriseContact) {
+                // No implicit intent as user may have a different contacts app in work profile.
+                QuickContact.showQuickContact(PeopleActivity.this, new Rect(), contactLookupUri,
+                        QuickContactActivity.MODE_FULLY_EXPANDED, null);
+            } else {
+                final Intent intent = ImplicitIntentsUtil.composeQuickContactIntent(
+                        contactLookupUri,
+                        QuickContactActivity.MODE_FULLY_EXPANDED);
+                ImplicitIntentsUtil.startActivityInApp(PeopleActivity.this, intent);
+            }
         }
 
         @Override
@@ -1020,10 +1024,7 @@
 
         @Override
         public void onAddAccountAction() {
-            Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT);
-            intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
-            intent.putExtra(Settings.EXTRA_AUTHORITIES,
-                    new String[]{ContactsContract.AUTHORITY});
+            final Intent intent = AccountPromptUtils.getIntentForAddingAccount();
             ImplicitIntentsUtil.startActivityOutsideApp(PeopleActivity.this, intent);
         }
 
@@ -1115,9 +1116,12 @@
             helpMenu.setVisible(HelpUtils.isHelpAndFeedbackAvailable());
         }
         final boolean showMiscOptions = !isSearchOrSelectionMode;
+        final boolean showBlockedNumbers = PhoneCapabilityTester.isPhone(this)
+                && ContactsUtils.FLAG_N_FEATURE;
         makeMenuItemVisible(menu, R.id.menu_search, showMiscOptions);
         makeMenuItemVisible(menu, R.id.menu_import_export, showMiscOptions);
         makeMenuItemVisible(menu, R.id.menu_accounts, showMiscOptions);
+        makeMenuItemVisible(menu, R.id.menu_blocked_numbers, showMiscOptions && showBlockedNumbers);
         makeMenuItemVisible(menu, R.id.menu_settings,
                 showMiscOptions && !ContactsPreferenceActivity.isEmpty(this));
 
@@ -1182,18 +1186,7 @@
                 return true;
             }
             case R.id.menu_settings: {
-                final Intent intent = new Intent(this, ContactsPreferenceActivity.class);
-                // Since there is only one section right now, make sure it is selected on
-                // small screens.
-                intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT,
-                        DisplayOptionsPreferenceFragment.class.getName());
-                // By default, the title of the activity should be equivalent to the fragment
-                // title. We set this argument to avoid this. Because of a bug, the following
-                // line isn't necessary. But, once the bug is fixed this may become necessary.
-                // b/5045558 refers to this issue, as well as another.
-                intent.putExtra(PreferenceActivity.EXTRA_SHOW_FRAGMENT_TITLE,
-                        R.string.activity_title_settings);
-                startActivity(intent);
+                startActivity(new Intent(this, ContactsPreferenceActivity.class));
                 return true;
             }
             case R.id.menu_contacts_filter: {
@@ -1235,6 +1228,12 @@
                 ImplicitIntentsUtil.startActivityInAppIfPossible(this, intent);
                 return true;
             }
+            case R.id.menu_blocked_numbers: {
+                final Intent intent = new Intent("android.intent.action.EDIT");
+                intent.setType("blocked_numbers/*");
+                ImplicitIntentsUtil.startActivityInApp(this, intent);
+                return true;
+            }
             case R.id.export_database: {
                 final Intent intent = new Intent("com.android.providers.contacts.DUMP_DATABASE");
                 intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
@@ -1297,6 +1296,7 @@
         intent.putExtra(Intent.EXTRA_STREAM, uri);
         ImplicitIntentsUtil.startActivityOutsideApp(this, intent);
     }
+
     private void joinSelectedContacts() {
         JoinContactsDialogFragment.start(this, mAllFragment.getSelectedContactIds());
     }
@@ -1378,6 +1378,14 @@
             mAllFragment.displayCheckBoxes(false);
         } else if (mActionBarAdapter.isSearchMode()) {
             mActionBarAdapter.setSearchMode(false);
+
+            if (mAllFragment.wasSearchResultClicked()) {
+                mAllFragment.resetSearchResultClicked();
+            } else {
+                Logger.getInstance().logScreenView(
+                        ScreenEvent.SEARCH_EXIT, this, ScreenEvent.TAG_SEARCH_EXIT);
+                Logger.getInstance().logSearchEventImpl(mAllFragment.createSearchState());
+            }
         } else {
             super.onBackPressed();
         }
@@ -1444,24 +1452,4 @@
         }
         return position;
     }
-
-    @Override
-    public boolean onMenuOpened(int featureId, Menu menu) {
-        // When the overflow menu button opens (both manually and automatically), we need to
-        // update both variables; same for closing event.
-        mActionBarAdapter.setOverflowOpen(true);
-        mActionBarAdapter.setShouldOpenOverflow(true);
-        return super.onMenuOpened(featureId, menu);
-    }
-
-    @Override
-    public void onPanelClosed(int featureId, Menu menu) {
-        // Since onPanelClosed will be called when the activity is destroyed on rotation even if
-        // user leaves the menu open, we are relying on onSaveInstanceState being called before
-        // onDestroy and onPanelClosed are invoked in order to store the "opening" status of the
-        // menu.
-        mActionBarAdapter.setOverflowOpen(false);
-        mActionBarAdapter.setShouldOpenOverflow(false);
-        super.onMenuOpened(featureId, menu);
-    }
 }
diff --git a/src/com/android/contacts/compat/AggregationSuggestionsCompat.java b/src/com/android/contacts/compat/AggregationSuggestionsCompat.java
new file mode 100644
index 0000000..aa15f70
--- /dev/null
+++ b/src/com/android/contacts/compat/AggregationSuggestionsCompat.java
@@ -0,0 +1,98 @@
+/*
+ * 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.contacts.compat;
+
+import android.net.Uri;
+import android.provider.ContactsContract;
+
+import java.util.ArrayList;
+
+/**
+ * This class contains Builder class extracted from ContactsContract, and it became visible in API
+ * level 23. We need maintain this class and keep it synced with ContactsContract.
+ */
+public class AggregationSuggestionsCompat {
+
+    /**
+     * Used to specify what kind of data is supplied for the suggestion query.
+     */
+    public static final String PARAMETER_MATCH_NAME = "name";
+
+    /**
+     * A convenience builder for aggregation suggestion content URIs.
+     */
+    public static final class Builder {
+        private long mContactId;
+        private final ArrayList<String> mValues = new ArrayList<String>();
+        private int mLimit;
+
+        /**
+         * Optional existing contact ID.  If it is not provided, the search
+         * will be based exclusively on the values supplied with {@link #addNameParameter}.
+         *
+         * @param contactId contact to find aggregation suggestions for
+         * @return This Builder object to allow for chaining of calls to builder methods
+         */
+        public Builder setContactId(long contactId) {
+            this.mContactId = contactId;
+            return this;
+        }
+
+        /**
+         * Add a name to be used when searching for aggregation suggestions.
+         *
+         * @param name name to find aggregation suggestions for
+         * @return This Builder object to allow for chaining of calls to builder methods
+         */
+        public Builder addNameParameter(String name) {
+            mValues.add(name);
+            return this;
+        }
+
+        /**
+         * Sets the Maximum number of suggested aggregations that should be returned.
+         * @param limit The maximum number of suggested aggregations
+         *
+         * @return This Builder object to allow for chaining of calls to builder methods
+         */
+        public Builder setLimit(int limit) {
+            mLimit = limit;
+            return this;
+        }
+
+        /**
+         * Combine all of the options that have been set and return a new {@link Uri}
+         * object for fetching aggregation suggestions.
+         */
+        public Uri build() {
+            android.net.Uri.Builder builder = ContactsContract.Contacts.CONTENT_URI.buildUpon();
+            builder.appendEncodedPath(String.valueOf(mContactId));
+            builder.appendPath(ContactsContract.Contacts.AggregationSuggestions.CONTENT_DIRECTORY);
+            if (mLimit != 0) {
+                builder.appendQueryParameter("limit", String.valueOf(mLimit));
+            }
+
+            int count = mValues.size();
+            for (int i = 0; i < count; i++) {
+                builder.appendQueryParameter("query", PARAMETER_MATCH_NAME
+                        + ":" + mValues.get(i));
+            }
+
+            return builder.build();
+        }
+    }
+}
diff --git a/src/com/android/contacts/compat/EdgeEffectCompat.java b/src/com/android/contacts/compat/EdgeEffectCompat.java
new file mode 100644
index 0000000..92999a0
--- /dev/null
+++ b/src/com/android/contacts/compat/EdgeEffectCompat.java
@@ -0,0 +1,39 @@
+/*
+ * 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.contacts.compat;
+
+import android.widget.EdgeEffect;
+import com.android.contacts.common.compat.CompatUtils;
+
+/**
+ * Compatibility class for {@link android.widget.EdgeEffect}
+ * The android.support.v4.widget.EdgeEffectCompat doesn't support customized color, so we write
+ * our own and keep using EdgeEffect to customize color.
+ */
+public class EdgeEffectCompat {
+    /**
+     * Compatibility method for {@link EdgeEffect#onPull(float, float)}, which is only available
+     * on Lollipop+.
+     */
+    public static void onPull(EdgeEffect edgeEffect, float deltaDistance, float displacement) {
+        if (CompatUtils.isLollipopCompatible()) {
+            edgeEffect.onPull(deltaDistance, displacement);
+        } else {
+            edgeEffect.onPull(deltaDistance);
+        }
+    }
+}
diff --git a/src/com/android/contacts/compat/PinnedPositionsCompat.java b/src/com/android/contacts/compat/PinnedPositionsCompat.java
new file mode 100644
index 0000000..044ef20
--- /dev/null
+++ b/src/com/android/contacts/compat/PinnedPositionsCompat.java
@@ -0,0 +1,56 @@
+/*
+ * 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.contacts.compat;
+
+import android.content.ContentResolver;
+import android.provider.ContactsContract;
+import android.provider.ContactsContract.PinnedPositions;
+
+import com.android.contacts.common.compat.CompatUtils;
+
+/**
+ * Compatibility class for {@link android.provider.ContactsContract.PinnedPositions}
+ */
+public class PinnedPositionsCompat {
+    /**
+     * Not instantiable.
+     */
+    private PinnedPositionsCompat() {
+    }
+
+    /**
+     * copied from android.provider.ContactsContract.PinnedPositions#UNDEMOTE_METHOD
+     */
+    private static final String UNDEMOTE_METHOD = "undemote";
+
+    /**
+     * Compatibility method for {@link android.provider.ContactsContract.PinnedPositions#undemote}
+     */
+    public static void undemote(ContentResolver contentResolver, long contactId) {
+        if (contentResolver == null) {
+            return;
+        }
+        if (CompatUtils.isLollipopCompatible()) {
+            PinnedPositions.undemote(contentResolver, contactId);
+        } else {
+            // copied from android.provider.ContactsContract.PinnedPositions.undemote()
+            contentResolver.call(ContactsContract.AUTHORITY_URI, UNDEMOTE_METHOD,
+                    String.valueOf(contactId), null);
+        }
+    }
+
+}
diff --git a/src/com/android/contacts/compat/ProviderStatusCompat.java b/src/com/android/contacts/compat/ProviderStatusCompat.java
new file mode 100644
index 0000000..2b5c820
--- /dev/null
+++ b/src/com/android/contacts/compat/ProviderStatusCompat.java
@@ -0,0 +1,69 @@
+/*
+ * 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.contacts.compat;
+
+import android.os.Build;
+import android.provider.ContactsContract.ProviderStatus;
+
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.compat.SdkVersionOverride;
+
+/**
+ * This class contains constants from the pre-M version of ContactsContract.ProviderStatus class
+ * and also the mappings between pre-M constants and M constants for compatibility purpose,
+ * because ProviderStatus class constant names and values changed and the class became visible in
+ * API level 23.
+ */
+public class ProviderStatusCompat {
+    /**
+     * Not instantiable.
+     */
+    private ProviderStatusCompat() {
+    }
+
+    public static final boolean USE_CURRENT_VERSION = CompatUtils.isMarshmallowCompatible();
+
+    public static final int STATUS_EMPTY = USE_CURRENT_VERSION ?
+            ProviderStatus.STATUS_EMPTY : ProviderStatusCompat.STATUS_NO_ACCOUNTS_NO_CONTACTS;
+
+    public static final int STATUS_BUSY = USE_CURRENT_VERSION ?
+            ProviderStatus.STATUS_BUSY : ProviderStatusCompat.STATUS_UPGRADING;
+
+    /**
+     * Default status of the provider, using the actual constant to guard against errors
+     */
+    public static final int STATUS_NORMAL = ProviderStatus.STATUS_NORMAL;
+
+    /**
+     * The following three constants are from pre-M.
+     *
+     * The status used when the provider is in the process of upgrading.  Contacts
+     * are temporarily unaccessible.
+     */
+    private static final int STATUS_UPGRADING = 1;
+
+    /**
+     * The status used during a locale change.
+     */
+    public static final int STATUS_CHANGING_LOCALE = 3;
+
+    /**
+     * The status that indicates that there are no accounts and no contacts
+     * on the device.
+     */
+    private static final int STATUS_NO_ACCOUNTS_NO_CONTACTS = 4;
+}
diff --git a/src/com/android/contacts/editor/AggregationSuggestionEngine.java b/src/com/android/contacts/editor/AggregationSuggestionEngine.java
index aa5f988..6447ff4 100644
--- a/src/com/android/contacts/editor/AggregationSuggestionEngine.java
+++ b/src/com/android/contacts/editor/AggregationSuggestionEngine.java
@@ -21,11 +21,11 @@
 import android.database.ContentObserver;
 import android.database.Cursor;
 import android.net.Uri;
+import android.os.Build;
 import android.os.Handler;
 import android.os.HandlerThread;
 import android.os.Message;
 import android.os.Process;
-import android.provider.ContactsContract;
 import android.provider.ContactsContract.CommonDataKinds.Email;
 import android.provider.ContactsContract.CommonDataKinds.Nickname;
 import android.provider.ContactsContract.CommonDataKinds.Phone;
@@ -39,6 +39,7 @@
 import android.text.TextUtils;
 
 import com.android.contacts.common.model.ValuesDelta;
+import com.android.contacts.compat.AggregationSuggestionsCompat;
 import com.google.common.collect.Lists;
 
 import java.util.ArrayList;
@@ -228,19 +229,32 @@
             return null;
         }
 
-        Builder builder = new AggregationSuggestions.Builder()
+        // AggregationSuggestions.Builder() became visible in API level 23, so use it if applicable.
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+            final Builder uriBuilder = new AggregationSuggestions.Builder()
+                    .setLimit(mSuggestionsLimit)
+                    .setContactId(mContactId);
+            if (nameSb.length() != 0) {
+                uriBuilder.addNameParameter(nameSb.toString());
+            }
+            if (phoneticNameSb.length() != 0) {
+                uriBuilder.addNameParameter(phoneticNameSb.toString());
+            }
+            return uriBuilder.build();
+        }
+
+        // For previous SDKs, use the backup plan.
+        final AggregationSuggestionsCompat.Builder uriBuilder =
+                new AggregationSuggestionsCompat.Builder()
                 .setLimit(mSuggestionsLimit)
                 .setContactId(mContactId);
-
         if (nameSb.length() != 0) {
-            builder.addNameParameter(nameSb.toString());
+            uriBuilder.addNameParameter(nameSb.toString());
         }
-
         if (phoneticNameSb.length() != 0) {
-            builder.addNameParameter(phoneticNameSb.toString());
+            uriBuilder.addNameParameter(phoneticNameSb.toString());
         }
-
-        return builder.build();
+        return uriBuilder.build();
     }
 
     private void appendValue(StringBuilder sb, ValuesDelta values, String column) {
diff --git a/src/com/android/contacts/editor/CancelEditDialogFragment.java b/src/com/android/contacts/editor/CancelEditDialogFragment.java
index 6780578..ba5f9fa 100644
--- a/src/com/android/contacts/editor/CancelEditDialogFragment.java
+++ b/src/com/android/contacts/editor/CancelEditDialogFragment.java
@@ -46,7 +46,7 @@
         return new AlertDialog.Builder(getActivity())
                 .setIconAttribute(android.R.attr.alertDialogIcon)
                 .setMessage(R.string.cancel_confirmation_dialog_message)
-                .setPositiveButton(R.string.cancel_confirmation_dialog_message_positive_button,
+                .setPositiveButton(R.string.cancel_confirmation_dialog_cancel_editing_button,
                         new DialogInterface.OnClickListener() {
                             @Override
                             public void onClick(DialogInterface dialogInterface, int which) {
@@ -55,7 +55,7 @@
                             }
                         }
                 )
-                .setNegativeButton(android.R.string.cancel, null)
+                .setNegativeButton(R.string.cancel_confirmation_dialog_keep_editing_button, null)
                 .create();
     }
 
diff --git a/src/com/android/contacts/editor/CompactContactEditorFragment.java b/src/com/android/contacts/editor/CompactContactEditorFragment.java
index 8b4e260..e441264 100644
--- a/src/com/android/contacts/editor/CompactContactEditorFragment.java
+++ b/src/com/android/contacts/editor/CompactContactEditorFragment.java
@@ -19,7 +19,6 @@
 import com.android.contacts.ContactSaveService;
 import com.android.contacts.R;
 import com.android.contacts.activities.CompactContactEditorActivity;
-import com.android.contacts.activities.ContactEditorBaseActivity;
 import com.android.contacts.common.model.RawContactDelta;
 import com.android.contacts.common.model.ValuesDelta;
 import com.android.contacts.common.model.account.AccountWithDataSet;
@@ -165,28 +164,7 @@
                 ((Activity) mContext).getClass(),
                 CompactContactEditorActivity.ACTION_SAVE_COMPLETED, mUpdatedPhotos,
                 JOIN_CONTACT_ID_EXTRA_KEY, joinContactId);
-        try {
-            mContext.startService(intent);
-        } catch (Exception exception) {
-            final int resId;
-            switch (saveMode) {
-                case ContactEditorBaseActivity.ContactEditor.SaveMode.SPLIT:
-                    resId = R.string.contactUnlinkErrorToast;
-                    break;
-                case ContactEditorBaseActivity.ContactEditor.SaveMode.RELOAD:
-                    resId = R.string.contactJoinErrorToast;
-                    break;
-                case ContactEditorBaseActivity.ContactEditor.SaveMode.CLOSE:
-                    resId = R.string.contactSavedErrorToast;
-                    break;
-                default:
-                    resId = R.string.contactGenericErrorToast;
-            }
-            Toast.makeText(mContext, resId, Toast.LENGTH_SHORT).show();
-            onCancelEditConfirmed();
-            return false;
-        }
-        return true;
+        return startSaveService(mContext, intent, saveMode);
     }
 
     @Override
@@ -205,7 +183,7 @@
     public void updatePhoto(Uri uri) throws FileNotFoundException {
         final Bitmap bitmap = ContactPhotoUtils.getBitmapFromUri(getActivity(), uri);
         if (bitmap == null || bitmap.getHeight() <= 0 || bitmap.getWidth() <= 0) {
-            Toast.makeText(getContext(), R.string.contactPhotoSavedErrorToast,
+            Toast.makeText(mContext, R.string.contactPhotoSavedErrorToast,
                     Toast.LENGTH_SHORT).show();
             return;
         }
@@ -215,6 +193,9 @@
 
     public void setPrimaryPhoto(CompactPhotoSelectionFragment.Photo photo) {
         getContent().setPrimaryPhoto(photo);
+
+        // Update the photo ID we will try to match when selecting the photo to display
+        mPhotoId = photo.photoId;
     }
 
     @Override
@@ -255,6 +236,7 @@
         if (isEditingMultipleRawContacts()) {
             final ArrayList<CompactPhotoSelectionFragment.Photo> photos = getContent().getPhotos();
             if (photos.size() > 1) {
+                updatePrimaryForSelection(photos);
                 // For aggregate contacts, the user may select a new super primary photo from among
                 // the (non-default) raw contact photos, or source a new photo.
                 getEditorActivity().selectPhoto(photos, getPhotoMode());
@@ -266,6 +248,22 @@
         getEditorActivity().changePhoto(getPhotoMode());
     }
 
+    // This method override photo's primary flag based on photoId and set the photo currently
+    // shown in the editor to be the new primary no matter how many primary photos there are in
+    // the photo picker. This is because the photos returned by "getPhoto" may contain 0, 1,
+    // or 2+ primary photos and when we link contacts in the editor, the photos returned may change.
+    // We need to put check mark on the photo currently shown in editor, so we override "primary".
+    // This doesn't modify anything in the database,so there would be no pending changes.
+    private void updatePrimaryForSelection(ArrayList<CompactPhotoSelectionFragment.Photo> photos) {
+        for (CompactPhotoSelectionFragment.Photo photo : photos) {
+            if (photo.photoId == mPhotoId) {
+                photo.primary = true;
+            } else {
+                photo.primary = false;
+            }
+        }
+    }
+
     @Override
     public void onRawContactSelected(Uri uri, long rawContactId, boolean isReadOnly) {
         final Activity activity = getActivity();
diff --git a/src/com/android/contacts/editor/CompactKindSectionView.java b/src/com/android/contacts/editor/CompactKindSectionView.java
index 8962de1..7e5ff11 100644
--- a/src/com/android/contacts/editor/CompactKindSectionView.java
+++ b/src/com/android/contacts/editor/CompactKindSectionView.java
@@ -330,7 +330,7 @@
                 } else {
                     editorListener = new NonNameEditorListener();
                 }
-                for (ValuesDelta valuesDelta : kindSectionData.getValuesDeltas()) {
+                for (ValuesDelta valuesDelta : kindSectionData.getVisibleValuesDeltas()) {
                     addNonNameEditorView(kindSectionData.getRawContactDelta(),
                             kindSectionData.getDataKind(), valuesDelta, editorListener);
                 }
@@ -449,10 +449,12 @@
             // Check whether metadata has been bound for all group views
             for (int i = 0; i < mEditors.getChildCount(); i++) {
                 final View view = mEditors.getChildAt(i);
-                if (view instanceof GroupMembershipView
-                        && !((GroupMembershipView) view).wasGroupMetaDataBound()) {
-                    setVisibility(GONE);
-                    return;
+                if (view instanceof GroupMembershipView) {
+                    final GroupMembershipView groupView = (GroupMembershipView) view;
+                    if (!groupView.wasGroupMetaDataBound() || !groupView.accountHasGroups()) {
+                        setVisibility(GONE);
+                        return;
+                    }
                 }
             }
             // Check that the user has selected to display all fields
@@ -540,10 +542,11 @@
         }
         // Determine if we should add a new empty editor
         final DataKind dataKind = mKindSectionDataList.get(0).getDataKind();
+        final RawContactDelta rawContactDelta =
+                mKindSectionDataList.get(0).getRawContactDelta();
         if (dataKind == null // There is nothing we can do.
                 // We have already reached the maximum number of editors, don't add any more.
-                || (dataKind.typeOverallMax == mEditors.getChildCount()
-                        && dataKind.typeOverallMax != 0)
+                || !RawContactModifier.canInsert(rawContactDelta, dataKind)
                 // We have already reached the maximum number of empty editors, don't add any more.
                 || emptyEditors.size() == 1) {
             return;
@@ -554,8 +557,6 @@
             if (Nickname.CONTENT_ITEM_TYPE.equals(mimeType) && mEditors.getChildCount() > 0) {
                 return;
             }
-            final RawContactDelta rawContactDelta =
-                    mKindSectionDataList.get(0).getRawContactDelta();
             final ValuesDelta values = RawContactModifier.insertChild(rawContactDelta, dataKind);
             final Editor.EditorListener editorListener = Event.CONTENT_ITEM_TYPE.equals(mimeType)
                     ? new EventEditorListener() : new NonNameEditorListener();
diff --git a/src/com/android/contacts/editor/CompactPhotoSelectionFragment.java b/src/com/android/contacts/editor/CompactPhotoSelectionFragment.java
index 060d64d..bc9435b 100644
--- a/src/com/android/contacts/editor/CompactPhotoSelectionFragment.java
+++ b/src/com/android/contacts/editor/CompactPhotoSelectionFragment.java
@@ -28,12 +28,14 @@
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.provider.ContactsContract;
+import android.text.TextUtils;
 import android.util.DisplayMetrics;
 import android.view.Display;
 import android.view.LayoutInflater;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
 import android.widget.AdapterView;
 import android.widget.BaseAdapter;
 import android.widget.GridView;
@@ -95,6 +97,9 @@
         public int iconRes;
         public String syncAdapterPackageName;
 
+        public String contentDescription;
+        public String contentDescriptionChecked; // Talkback announcement when the photo is checked
+
         public ValuesDelta valuesDelta;
 
         /**
@@ -104,8 +109,6 @@
          */
         public boolean primary;
 
-        public long rawContactId;
-
         /**
          * Pointer back to the KindSectionDataList this photo came from.
          * See {@link CompactRawContactsEditorView#getPhotos}
@@ -117,6 +120,8 @@
         /** Newly taken or selected photo that has not yet been saved to CP2. */
         public Uri updatedPhotoUri;
 
+        public long photoId;
+
         @Override
         public int describeContents() {
             return 0;
@@ -132,6 +137,7 @@
             dest.writeInt(kindSectionDataListIndex);
             dest.writeInt(valuesDeltaListIndex);
             dest.writeParcelable(updatedPhotoUri, flags);
+            dest.writeLong(photoId);
         }
 
         private void readFromParcel(Parcel source) {
@@ -144,6 +150,7 @@
             kindSectionDataListIndex = source.readInt();
             valuesDeltaListIndex = source.readInt();
             updatedPhotoUri = source.readParcelable(classLoader);
+            photoId = source.readLong();
         }
     }
 
@@ -193,18 +200,14 @@
                 if (convertView == null || convertView.findViewById(R.id.account_type) != null) {
                     return mLayoutInflater.inflate(R.layout.take_a_photo_button, /* root =*/ null);
                 }
-                else{
-                    return convertView;
-                }
+                return convertView;
             }
 
             if (getItemViewType(position) == 1) {
                 if (convertView == null || convertView.findViewById(R.id.account_type) != null) {
                     return mLayoutInflater.inflate(R.layout.all_photos_button, /* root =*/ null);
                 }
-                else {
-                    return convertView;
-                }
+                return convertView;
             }
 
             // when position greater than 1, we should make sure account_type *is* in convertView
@@ -224,14 +227,14 @@
             // Bind the photo
             final ImageView imageView = (ImageView) photoItemView.findViewById(R.id.image);
             if (photo.updatedPhotoUri != null) {
-                EditorUiUtils.loadPhoto(ContactPhotoManager.getInstance(getContext()),
+                EditorUiUtils.loadPhoto(ContactPhotoManager.getInstance(mContext),
                         imageView, photo.updatedPhotoUri);
             } else {
                 final Long photoFileId = EditorUiUtils.getPhotoFileId(photo.valuesDelta);
                 if (photoFileId != null) {
                     final Uri photoUri = ContactsContract.DisplayPhoto.CONTENT_URI.buildUpon()
                             .appendPath(photoFileId.toString()).build();
-                    EditorUiUtils.loadPhoto(ContactPhotoManager.getInstance(getContext()),
+                    EditorUiUtils.loadPhoto(ContactPhotoManager.getInstance(mContext),
                             imageView, photoUri);
                 } else {
                     imageView.setImageBitmap(EditorUiUtils.getPhotoBitmap(photo.valuesDelta));
@@ -248,6 +251,8 @@
             final ImageView checkImageView = (ImageView) photoItemView.findViewById(R.id.check);
             checkImageView.setVisibility(photo.primary ? View.VISIBLE : View.GONE);
 
+            photoItemView.setContentDescription(photo.contentDescription);
+
             return photoItemView;
         }
     }
@@ -255,6 +260,7 @@
     private ArrayList<Photo> mPhotos;
     private int mPhotoMode;
     private Listener mListener;
+    private GridView mGridView;
 
     public void setListener(Listener listener) {
         mListener = listener;
@@ -263,6 +269,7 @@
     public void setPhotos(ArrayList<Photo> photos, int photoMode) {
         mPhotos = photos;
         mPhotoMode = photoMode;
+        mGridView.setAccessibilityDelegate(new View.AccessibilityDelegate() {});
     }
 
     @Override
@@ -282,12 +289,12 @@
 
         final View view = inflater.inflate(R.layout.compact_photo_selection_fragment,
                 container, false);
-        final GridView gridView = (GridView) view.findViewById(R.id.grid_view);
-        gridView.setAdapter(photoAdapter);
-        gridView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
+        mGridView = (GridView) view.findViewById(R.id.grid_view);
+        mGridView.setAdapter(photoAdapter);
+        mGridView.setOnItemClickListener(new AdapterView.OnItemClickListener() {
             public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
-                final PhotoSourceDialogFragment.Listener listener = (PhotoSourceDialogFragment.Listener)
-                        getActivity();
+                final PhotoSourceDialogFragment.Listener listener =
+                        (PhotoSourceDialogFragment.Listener) getActivity();
                 if (position == 0){
                     listener.onTakePhotoChosen();
                 } else if (position == 1) {
@@ -298,6 +305,7 @@
                     if (mListener != null) {
                         mListener.onPhotoSelected(photo);
                     }
+                    handleAccessibility(photo, position);
                 }
             }
         });
@@ -314,11 +322,27 @@
         float density  = getResources().getDisplayMetrics().density;
         float dpColumnWidth  = (outMetrics.widthPixels - paddingWidth * (mNumberOfColumns - 1) *
                 density) / mNumberOfColumns;
-        gridView.setColumnWidth((int) dpColumnWidth);
+        mGridView.setColumnWidth((int) dpColumnWidth);
 
         return view;
     }
 
+    private void handleAccessibility(Photo photo, int position) {
+        // Use custom AccessibilityDelegate when closing this fragment to suppress event.
+        mGridView.setAccessibilityDelegate(new View.AccessibilityDelegate() {
+            @Override
+            public boolean onRequestSendAccessibilityEvent(
+                    ViewGroup host, View child,AccessibilityEvent event) {
+                if (event.getEventType() == AccessibilityEvent.TYPE_VIEW_ACCESSIBILITY_FOCUSED) {
+                    return false;
+                }
+                return super.onRequestSendAccessibilityEvent(host, child, event);
+            }
+        });
+        final ViewGroup clickedView = (ViewGroup) mGridView.getChildAt(position);
+        clickedView.announceForAccessibility(photo.contentDescriptionChecked);
+    }
+
     @Override
     public void onSaveInstanceState(Bundle outState) {
         outState.putParcelableArrayList(STATE_PHOTOS, mPhotos);
@@ -336,4 +360,9 @@
                 return super.onOptionsItemSelected(item);
         }
     }
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
 }
\ No newline at end of file
diff --git a/src/com/android/contacts/editor/CompactRawContactsEditorView.java b/src/com/android/contacts/editor/CompactRawContactsEditorView.java
index 52b2ba6..72f1c66 100644
--- a/src/com/android/contacts/editor/CompactRawContactsEditorView.java
+++ b/src/com/android/contacts/editor/CompactRawContactsEditorView.java
@@ -464,7 +464,7 @@
     public void updatePhoto(Uri photoUri) {
         mPhotoValuesDelta.setFromTemplate(false);
         // Unset primary for all photos
-        unsetSuperPrimary();
+        unsetSuperPrimaryFromAllPhotos();
         // Mark the currently displayed photo as primary
         mPhotoValuesDelta.setSuperPrimary(true);
 
@@ -487,12 +487,11 @@
         mPhotoView.setFullSizedPhoto(photoUri);
     }
 
-    private void unsetSuperPrimary() {
+    private void unsetSuperPrimaryFromAllPhotos() {
         final List<KindSectionData> kindSectionDataList =
                 mKindSectionDataMap.get(Photo.CONTENT_ITEM_TYPE);
         for (KindSectionData kindSectionData : kindSectionDataList) {
-            final List<ValuesDelta> valuesDeltaList = kindSectionData.getValuesDeltas();
-            for (ValuesDelta valuesDelta : valuesDeltaList) {
+            for (ValuesDelta valuesDelta : kindSectionData.getNonEmptyValuesDeltas()) {
                 valuesDelta.setSuperPrimary(false);
             }
         }
@@ -532,10 +531,10 @@
         for (int i = 0; i < kindSectionDataList.size(); i++) {
             final KindSectionData kindSectionData = kindSectionDataList.get(i);
             final AccountType accountType = kindSectionData.getAccountType();
-            final List<ValuesDelta> valuesDeltaList = kindSectionData.getValuesDeltas();
-            if (valuesDeltaList == null || valuesDeltaList.isEmpty()) continue;
-            for (int j = 0; j < valuesDeltaList.size(); j++) {
-                final ValuesDelta valuesDelta = valuesDeltaList.get(j);
+            final List<ValuesDelta> valuesDeltas = kindSectionData.getNonEmptyValuesDeltas();
+            if (valuesDeltas.isEmpty()) continue;
+            for (int j = 0; j < valuesDeltas.size(); j++) {
+                final ValuesDelta valuesDelta = valuesDeltas.get(j);
                 final Bitmap bitmap = EditorUiUtils.getPhotoBitmap(valuesDelta);
                 if (bitmap == null) continue;
 
@@ -548,12 +547,35 @@
                 photo.primary = valuesDelta.isSuperPrimary();
                 photo.kindSectionDataListIndex = i;
                 photo.valuesDeltaListIndex = j;
+                photo.photoId = valuesDelta.getId();
 
                 if (updatedPhotos != null) {
                     photo.updatedPhotoUri = (Uri) updatedPhotos.get(String.valueOf(
                             kindSectionData.getRawContactDelta().getRawContactId()));
                 }
 
+                // set content descriptions of the photo
+                final CharSequence accountTypeText = accountType.getDisplayLabel(getContext());
+                if (accountTypeText != null) {
+                    final String accountNameText =
+                            kindSectionData.getRawContactDelta().getAccountName();
+                    photo.contentDescription = getResources().getString(photo.primary ?
+                                    R.string.photo_view_description_checked :
+                                    R.string.photo_view_description_not_checked,
+                            accountTypeText,
+                            accountNameText == null ? "" : accountNameText);
+                    photo.contentDescriptionChecked = getResources().getString(
+                            R.string.photo_view_description_checked,
+                            accountTypeText,
+                            accountNameText == null ? "" : accountNameText);
+                } else {
+                    photo.contentDescription = getResources().getString(photo.primary ?
+                            R.string.photo_view_description_checked_no_info :
+                            R.string.photo_view_description_not_checked_no_info);
+                    photo.contentDescriptionChecked = getResources().getString(
+                            R.string.photo_view_description_checked_no_info);
+                }
+
                 photos.add(photo);
             }
         }
@@ -576,17 +598,18 @@
         }
         final KindSectionData kindSectionData =
                 kindSectionDataList.get(photo.kindSectionDataListIndex);
-        final List<ValuesDelta> valuesDeltaList = kindSectionData.getValuesDeltas();
+        final List<ValuesDelta> valuesDeltaList = kindSectionData.getNonEmptyValuesDeltas();
         if (photo.valuesDeltaListIndex >= valuesDeltaList.size()) {
             wlog("Invalid values delta list index");
             return;
         }
+
+        // Update values delta
         final ValuesDelta valuesDelta = valuesDeltaList.get(photo.valuesDeltaListIndex);
         valuesDelta.setFromTemplate(false);
-        // Unset primary for all photos
-        unsetSuperPrimary();
-        // Mark the currently displayed photo as primary
+        unsetSuperPrimaryFromAllPhotos();
         valuesDelta.setSuperPrimary(true);
+
         // Update the UI
         mPhotoView.setPhoto(valuesDelta, mMaterialPalette);
     }
@@ -706,7 +729,10 @@
                 kindSectionDataList.add(kindSectionData);
 
                 vlog("parse: " + i + " " + dataKind.mimeType + " " +
-                        kindSectionData.getValuesDeltas().size() + " value(s)");
+                        kindSectionData.getValuesDeltas().size() + " value(s) " +
+                        kindSectionData.getNonEmptyValuesDeltas().size() + " non-empty value(s) " +
+                        kindSectionData.getVisibleValuesDeltas().size() +
+                        " visible value(s)");
             }
         }
     }
@@ -940,15 +966,15 @@
         mPhotoView.setPhoto(photoToDisplay.second, mMaterialPalette);
 
         // Find the raw contact ID and values delta that will be written when the photo is edited
-        final Pair<KindSectionData, ValuesDelta> pair = kindSectionDataList.getEntryToWrite(
+        final Pair<KindSectionData, ValuesDelta> photoToWrite = kindSectionDataList.getEntryToWrite(
                 mPhotoId, mPrimaryAccount, mIsUserProfile);
-        if (pair == null) {
+        if (photoToWrite == null) {
             mPhotoView.setReadOnly(true);
             return;
         }
         mPhotoView.setReadOnly(false);
-        mPhotoRawContactId = pair.first.getRawContactDelta().getRawContactId();
-        mPhotoValuesDelta = pair.second;
+        mPhotoRawContactId = photoToWrite.first.getRawContactDelta().getRawContactId();
+        mPhotoValuesDelta = photoToWrite.second;
     }
 
     private void addKindSectionViews() {
diff --git a/src/com/android/contacts/editor/ContactEditorBaseFragment.java b/src/com/android/contacts/editor/ContactEditorBaseFragment.java
index e17b2cd..181bc44 100644
--- a/src/com/android/contacts/editor/ContactEditorBaseFragment.java
+++ b/src/com/android/contacts/editor/ContactEditorBaseFragment.java
@@ -978,6 +978,15 @@
      */
     abstract protected boolean doSaveAction(int saveMode, Long joinContactId);
 
+    protected boolean startSaveService(Context context, Intent intent, int saveMode) {
+        final boolean result = ContactSaveService.startService(
+                context, intent, saveMode);
+        if (!result) {
+            onCancelEditConfirmed();
+        }
+        return result;
+    }
+
     //
     // State accessor methods
     //
@@ -1398,7 +1407,10 @@
                         mIntentExtras.getInt(INTENT_EXTRA_MATERIAL_PALETTE_PRIMARY_COLOR),
                         mIntentExtras.getInt(INTENT_EXTRA_MATERIAL_PALETTE_SECONDARY_COLOR));
             }
-            mPhotoId = mIntentExtras.getLong(INTENT_EXTRA_PHOTO_ID);
+            // If the user selected a different photo, don't restore the one from the Intent
+            if (mPhotoId < 0) {
+                mPhotoId = mIntentExtras.getLong(INTENT_EXTRA_PHOTO_ID);
+            }
             mRawContactIdToDisplayAlone = mIntentExtras.getLong(
                     INTENT_EXTRA_RAW_CONTACT_ID_TO_DISPLAY_ALONE, -1);
             mRawContactDisplayAloneIsReadOnly = mIntentExtras.getBoolean(
diff --git a/src/com/android/contacts/editor/ContactEditorFragment.java b/src/com/android/contacts/editor/ContactEditorFragment.java
index 38e43ae..146bc4c 100644
--- a/src/com/android/contacts/editor/ContactEditorFragment.java
+++ b/src/com/android/contacts/editor/ContactEditorFragment.java
@@ -426,8 +426,7 @@
                 SAVE_MODE_EXTRA_KEY, saveMode, isEditingUserProfile(),
                 ((Activity) mContext).getClass(), ContactEditorActivity.ACTION_SAVE_COMPLETED,
                 mUpdatedPhotos, JOIN_CONTACT_ID_EXTRA_KEY, joinContactId);
-        mContext.startService(intent);
-        return true;
+        return startSaveService(mContext, intent, saveMode);
     }
 
     @Override
diff --git a/src/com/android/contacts/editor/ContactEditorUtils.java b/src/com/android/contacts/editor/ContactEditorUtils.java
index 93fa8a3..728211f 100644
--- a/src/com/android/contacts/editor/ContactEditorUtils.java
+++ b/src/com/android/contacts/editor/ContactEditorUtils.java
@@ -148,6 +148,11 @@
      * Also note that the returned account may have been removed already.
      */
     public AccountWithDataSet getDefaultAccount() {
+        final List<AccountWithDataSet> currentWritableAccounts = getWritableAccounts();
+        if (currentWritableAccounts.size() == 1) {
+            return currentWritableAccounts.get(0);
+        }
+
         final String saved = mPrefs.getString(mDefaultAccountKey, null);
         if (TextUtils.isEmpty(saved)) {
             return null;
diff --git a/src/com/android/contacts/editor/GroupMembershipView.java b/src/com/android/contacts/editor/GroupMembershipView.java
index b13da62..cb66b73 100644
--- a/src/com/android/contacts/editor/GroupMembershipView.java
+++ b/src/com/android/contacts/editor/GroupMembershipView.java
@@ -134,6 +134,7 @@
 
     private RawContactDelta mState;
     private Cursor mGroupMetaData;
+    private boolean mAccountHasGroups;
     private String mAccountName;
     private String mAccountType;
     private String mDataSet;
@@ -207,6 +208,14 @@
         return mGroupMetaData != null;
     }
 
+    /**
+     * Return true if the account has groups to edit group membership for contacts
+     * belong to the account.
+     */
+    public boolean accountHasGroups() {
+        return mAccountHasGroups;
+    }
+
     public void setState(RawContactDelta state) {
         mState = state;
         mAccountType = mState.getAccountType();
@@ -224,7 +233,6 @@
             return;
         }
 
-        boolean accountHasGroups = false;
         mFavoritesGroupId = 0;
         mDefaultGroupId = 0;
 
@@ -244,7 +252,7 @@
                             && mGroupMetaData.getInt(GroupMetaDataLoader.AUTO_ADD) != 0) {
                     mDefaultGroupId = groupId;
                 } else {
-                    accountHasGroups = true;
+                    mAccountHasGroups = true;
                 }
 
                 // Exclude favorites from the list - they are handled with special UI (star)
@@ -262,7 +270,7 @@
             }
         }
 
-        if (!accountHasGroups) {
+        if (!mAccountHasGroups) {
             setVisibility(GONE);
             return;
         }
diff --git a/src/com/android/contacts/editor/KindSectionData.java b/src/com/android/contacts/editor/KindSectionData.java
index 8921099..7e2899f 100644
--- a/src/com/android/contacts/editor/KindSectionData.java
+++ b/src/com/android/contacts/editor/KindSectionData.java
@@ -22,11 +22,9 @@
 import com.android.contacts.common.model.account.AccountType.EditField;
 import com.android.contacts.common.model.dataitem.DataKind;
 
-import android.provider.ContactsContract.CommonDataKinds.Nickname;
-import android.provider.ContactsContract.CommonDataKinds.StructuredName;
-import android.provider.ContactsContract.CommonDataKinds.Event;
 import android.text.TextUtils;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -35,7 +33,6 @@
 public final class KindSectionData {
 
     private final AccountType mAccountType;
-    private final List<ValuesDelta> mValuesDeltas;
     private final DataKind mDataKind;
     private final RawContactDelta mRawContactDelta;
 
@@ -44,20 +41,44 @@
         mAccountType = accountType;
         mDataKind = dataKind;
         mRawContactDelta = rawContactDelta;
-        mValuesDeltas = mRawContactDelta.getMimeEntries(dataKind.mimeType, /* lazyCreate= */ true);
     }
 
     public AccountType getAccountType() {
         return mAccountType;
     }
 
+    /** Returns all ValuesDeltas for the data kind this section represents.*/
     public List<ValuesDelta> getValuesDeltas() {
-        return mValuesDeltas;
+        final List<ValuesDelta> valuesDeltas = mRawContactDelta.getMimeEntries(mDataKind.mimeType);
+        return valuesDeltas == null ? new ArrayList<ValuesDelta>() : valuesDeltas;
+    }
+
+    /** Returns visible and non deleted ValuesDeltas for the data kind this section represents. */
+    public List<ValuesDelta> getVisibleValuesDeltas() {
+        final ArrayList<ValuesDelta> valuesDeltas = new ArrayList<> ();
+        for (ValuesDelta valuesDelta : getValuesDeltas()) {
+            // Same conditions as KindSectionView#rebuildFromState
+            if (valuesDelta.isVisible() && !valuesDelta.isDelete()) {
+                valuesDeltas.add(valuesDelta);
+            }
+        }
+        return valuesDeltas;
+    }
+
+    /** Returns non-empty ValuesDeltas for the data kind this section represents. */
+    public List<ValuesDelta> getNonEmptyValuesDeltas() {
+        final ArrayList<ValuesDelta> valuesDeltas = new ArrayList<> ();
+        for (ValuesDelta valuesDelta : getValuesDeltas()) {
+            if (!isEmpty(valuesDelta)) {
+                valuesDeltas.add(valuesDelta);
+            }
+        }
+        return valuesDeltas;
     }
 
     /** Returns the super primary ValuesDelta for the data kind this section represents. */
     public ValuesDelta getSuperPrimaryValuesDelta() {
-        for (ValuesDelta valuesDelta : mValuesDeltas) {
+        for (ValuesDelta valuesDelta : getValuesDeltas()) {
             if (valuesDelta.isSuperPrimary()) return valuesDelta;
         }
         return null;
@@ -65,7 +86,7 @@
 
     /** Returns the ValuesDelta with the given ID. */
     public ValuesDelta getValuesDeltaById(Long id) {
-        for (ValuesDelta valuesDelta : mValuesDeltas) {
+        for (ValuesDelta valuesDelta : getValuesDeltas()) {
             if (valuesDelta.getId().equals(id)) return valuesDelta;
         }
         return null;
@@ -73,24 +94,21 @@
 
     /** Returns the first non empty ValuesDelta for the data kind this section represents. */
     public ValuesDelta getFirstNonEmptyValuesDelta() {
-        for (ValuesDelta valuesDelta : mValuesDeltas) {
+        for (ValuesDelta valuesDelta : getValuesDeltas()) {
             if (!isEmpty(valuesDelta)) return valuesDelta;
         }
         return null;
     }
 
-    /** Whether the given ValuesDelta is empty for the data kind this section represents. */
-    public boolean isEmpty(ValuesDelta valuesDelta) {
-        if (valuesDelta.isNoop()) return true;
-
+    private boolean isEmpty(ValuesDelta valuesDelta) {
         if (mDataKind.fieldList != null) {
             for (EditField editField : mDataKind.fieldList) {
                 final String column = editField.column;
                 final String value = valuesDelta.getAsString(column);
-                if (TextUtils.isEmpty(value)) return true;
+                if (!TextUtils.isEmpty(value)) return false;
             }
         }
-        return false;
+        return true;
     }
 
     public DataKind getDataKind() {
@@ -100,12 +118,4 @@
     public RawContactDelta getRawContactDelta() {
         return mRawContactDelta;
     }
-
-    public String toString() {
-        return String.format("%s<accountType=%s dataSet=%s values=%s>",
-                KindSectionData.class.getSimpleName(),
-                mAccountType.accountType,
-                mAccountType.dataSet,
-                getValuesDeltas().size());
-    }
-}
\ No newline at end of file
+}
diff --git a/src/com/android/contacts/editor/KindSectionDataList.java b/src/com/android/contacts/editor/KindSectionDataList.java
index 7a7dec2..cb82806 100644
--- a/src/com/android/contacts/editor/KindSectionDataList.java
+++ b/src/com/android/contacts/editor/KindSectionDataList.java
@@ -21,7 +21,6 @@
 import com.android.contacts.common.model.dataitem.DataKind;
 import com.android.contacts.common.model.RawContactModifier;
 
-import android.provider.ContactsContract;
 import android.util.Log;
 import android.util.Pair;
 
@@ -105,11 +104,14 @@
         // Just return the first writable entry.
         for (KindSectionData kindSectionData : this) {
             if (kindSectionData.getAccountType().areContactsWritable()) {
+                // Create an entry if necessary
                 RawContactModifier.ensureKindExists(kindSectionData.getRawContactDelta(),
-                        kindSectionData.getAccountType(),
-                        ContactsContract.CommonDataKinds.StructuredName.CONTENT_ITEM_TYPE);
-                vlog(mimeType + ": falling back to first kind section data to write");
-                return new Pair<>(kindSectionData, kindSectionData.getValuesDeltas().get(0));
+                        kindSectionData.getAccountType(), mimeType);
+
+                if (!kindSectionData.getValuesDeltas().isEmpty()) {
+                    vlog(mimeType + ": falling back to first kind section data to write");
+                    return new Pair<>(kindSectionData, kindSectionData.getValuesDeltas().get(0));
+                }
             }
         }
 
@@ -162,7 +164,7 @@
 
         for (KindSectionData kindSectionData : this) {
             final List<ValuesDelta> valuesDeltaList = kindSectionData.getValuesDeltas();
-            if (valuesDeltaList != null && !valuesDeltaList.isEmpty()) {
+            if (!valuesDeltaList.isEmpty()) {
                 vlog(mimeType + ": falling back to first empty entry to display");
                 final ValuesDelta valuesDelta = valuesDeltaList.get(0);
                 return new Pair<>(kindSectionData, valuesDelta);
diff --git a/src/com/android/contacts/editor/KindSectionView.java b/src/com/android/contacts/editor/KindSectionView.java
index ee11645..e612361 100644
--- a/src/com/android/contacts/editor/KindSectionView.java
+++ b/src/com/android/contacts/editor/KindSectionView.java
@@ -249,7 +249,7 @@
         } else if (isReadOnly()) {
             // We don't show empty editors for read only data kinds.
             return;
-        } else if (mKind.typeOverallMax == getEditorCount() && mKind.typeOverallMax != 0) {
+        } else if (!RawContactModifier.canInsert(mState, mKind)) {
             // We have already reached the maximum number of editors. Lets not add any more.
             return;
         } else if (emptyEditors.size() == 1) {
diff --git a/src/com/android/contacts/editor/LabeledEditorView.java b/src/com/android/contacts/editor/LabeledEditorView.java
index f862303..7be748e 100644
--- a/src/com/android/contacts/editor/LabeledEditorView.java
+++ b/src/com/android/contacts/editor/LabeledEditorView.java
@@ -139,6 +139,7 @@
         // Turn off the Spinner's own state management. We do this ourselves on rotation
         mLabel.setId(View.NO_ID);
         mLabel.setOnItemSelectedListener(mSpinnerListener);
+        ViewSelectedFilter.suppressViewSelectedEvent(mLabel);
         mLabel.setOnTouchListener(new OnTouchListener() {
             @Override
             public boolean onTouch(View v, MotionEvent event) {
@@ -457,7 +458,7 @@
                 final String customText = editText.getText().toString().trim();
                 if (ContactsUtils.isGraphic(customText)) {
                     final List<EditType> allTypes =
-                            RawContactModifier.getValidTypes(mState, mKind, null);
+                            RawContactModifier.getValidTypes(mState, mKind, null, true, null, true);
                     mType = null;
                     for (EditType editType : allTypes) {
                         if (editType.customColumn != null) {
@@ -597,7 +598,7 @@
                 }
             }
 
-            addAll(RawContactModifier.getValidTypes(mState, mKind, mType));
+            addAll(RawContactModifier.getValidTypes(mState, mKind, mType, true, null, false));
         }
 
         public boolean hasCustomSelection() {
diff --git a/src/com/android/contacts/editor/RawContactReadOnlyEditorView.java b/src/com/android/contacts/editor/RawContactReadOnlyEditorView.java
index 8c54b05..6e4c055 100644
--- a/src/com/android/contacts/editor/RawContactReadOnlyEditorView.java
+++ b/src/com/android/contacts/editor/RawContactReadOnlyEditorView.java
@@ -25,7 +25,6 @@
 import android.provider.ContactsContract.CommonDataKinds.Photo;
 import android.provider.ContactsContract.CommonDataKinds.StructuredName;
 import android.provider.ContactsContract.RawContacts;
-import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
 import android.util.AttributeSet;
 import android.util.Pair;
@@ -39,6 +38,7 @@
 
 import com.android.contacts.R;
 import com.android.contacts.common.GeoUtil;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
 import com.android.contacts.common.model.RawContactModifier;
 import com.android.contacts.common.model.RawContactDelta;
 import com.android.contacts.common.model.ValuesDelta;
@@ -172,7 +172,7 @@
                 if (TextUtils.isEmpty(phoneNumber)) {
                     continue;
                 }
-                final String formattedNumber = PhoneNumberUtils.formatNumber(
+                final String formattedNumber = PhoneNumberUtilsCompat.formatNumber(
                         phoneNumber, phone.getPhoneNormalizedNumber(),
                         GeoUtil.getCurrentCountryIso(getContext()));
                 CharSequence phoneType = null;
diff --git a/src/com/android/contacts/editor/StructuredNameEditorView.java b/src/com/android/contacts/editor/StructuredNameEditorView.java
index 23cb4c1..1a9c693 100644
--- a/src/com/android/contacts/editor/StructuredNameEditorView.java
+++ b/src/com/android/contacts/editor/StructuredNameEditorView.java
@@ -221,8 +221,13 @@
      */
     public void setDisplayName(String name) {
         // For now, assume the first text field is the name.
-        // TODO: Find a better way to get a hold of the name field.
+        // TODO: Find a better way to get a hold of the name field,
+        // including given_name and family_name.
         super.setValue(0, name);
+        getValues().setDisplayName(name);
+        rebuildStructuredName(getValues());
+        super.setValue(1, getValues().getAsString(StructuredName.GIVEN_NAME));
+        super.setValue(3, getValues().getAsString(StructuredName.FAMILY_NAME));
     }
 
     /**
@@ -230,6 +235,7 @@
      */
     public String getDisplayName() {
         final ValuesDelta valuesDelta = getValues();
+        rebuildFullName(valuesDelta);
         if (hasShortAndLongForms() && areOptionalFieldsVisible()) {
             final Map<String, String> structuredNameMap = valuesToStructuredNameMap(valuesDelta);
             final String displayName = NameConverter.structuredNameToDisplayName(
diff --git a/src/com/android/contacts/editor/TextFieldsEditorView.java b/src/com/android/contacts/editor/TextFieldsEditorView.java
index 8a6141d..0ec71fb 100644
--- a/src/com/android/contacts/editor/TextFieldsEditorView.java
+++ b/src/com/android/contacts/editor/TextFieldsEditorView.java
@@ -21,7 +21,6 @@
 import android.os.Parcel;
 import android.os.Parcelable;
 import android.provider.ContactsContract;
-import android.telephony.PhoneNumberUtils;
 import android.text.Editable;
 import android.text.InputType;
 import android.text.TextUtils;
@@ -39,6 +38,7 @@
 
 import com.android.contacts.R;
 import com.android.contacts.common.model.RawContactDelta;
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
 import com.android.contacts.common.ContactsUtils;
 import com.android.contacts.common.model.ValuesDelta;
 import com.android.contacts.common.model.account.AccountType.EditField;
@@ -255,13 +255,13 @@
             final String column = field.column;
             final String value = entry.getAsString(column);
             if (ContactsContract.CommonDataKinds.Phone.CONTENT_ITEM_TYPE.equals(kind.mimeType)) {
-                fieldView.setText(PhoneNumberUtils.createTtsSpannable(value));
+                fieldView.setText(PhoneNumberUtilsCompat.createTtsSpannable(value));
             } else {
                 fieldView.setText(value);
             }
 
-            // Show the delete button if we have a non-null value
-            setDeleteButtonVisible(value != null);
+            // Show the delete button if we have a non-empty value
+            setDeleteButtonVisible(!TextUtils.isEmpty(value));
 
             // Prepare listener for writing changes
             fieldView.addTextChangedListener(new TextWatcher() {
diff --git a/src/com/android/contacts/editor/ViewSelectedFilter.java b/src/com/android/contacts/editor/ViewSelectedFilter.java
new file mode 100644
index 0000000..85b1a96
--- /dev/null
+++ b/src/com/android/contacts/editor/ViewSelectedFilter.java
@@ -0,0 +1,53 @@
+/*
+ * 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.contacts.editor;
+
+import android.view.View;
+import android.view.View.AccessibilityDelegate;
+import android.view.ViewGroup;
+import android.view.accessibility.AccessibilityEvent;
+
+/**
+ * This is an AccessibilityDelegate that filters out the TYPE_VIEW_SELECTED event.
+ */
+public class ViewSelectedFilter extends AccessibilityDelegate {
+    private View mView; //the view we don't want TYPE_VIEW_SELECTED event to fire.
+
+    private ViewSelectedFilter(View view) {
+        super();
+        mView = view;
+    }
+
+    /**
+     * AccessibilityEvent can only be suppressed at a view's parent, so this function adds the
+     * delegate to the view's parent.
+     * @param view the view whose TYPE_VIEW_SELECTED event should be suppressed.
+     */
+    public static void suppressViewSelectedEvent(View view) {
+        final View parent = (View) view.getParent();
+        parent.setAccessibilityDelegate(new ViewSelectedFilter(view));
+    }
+
+    @Override
+    public boolean onRequestSendAccessibilityEvent(
+            ViewGroup host, View child,AccessibilityEvent event) {
+        if (child == mView && event.getEventType() == AccessibilityEvent.TYPE_VIEW_SELECTED) {
+            return false;
+        }
+        return super.onRequestSendAccessibilityEvent(host, child, event);
+    }
+}
diff --git a/src/com/android/contacts/interactions/CallLogInteractionsLoader.java b/src/com/android/contacts/interactions/CallLogInteractionsLoader.java
index 2340d3f..4277a27 100644
--- a/src/com/android/contacts/interactions/CallLogInteractionsLoader.java
+++ b/src/com/android/contacts/interactions/CallLogInteractionsLoader.java
@@ -23,11 +23,11 @@
 import android.database.DatabaseUtils;
 import android.net.Uri;
 import android.provider.CallLog.Calls;
-import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
 
 import com.google.common.annotations.VisibleForTesting;
 
+import com.android.contacts.common.compat.PhoneNumberUtilsCompat;
 import com.android.contacts.common.util.PermissionsUtil;
 
 import java.util.ArrayList;
@@ -107,9 +107,7 @@
     }
 
     private List<ContactInteraction> getCallLogInteractions(String phoneNumber) {
-        // TODO: the phone number added to the ContactInteractions result should retain their
-        // original formatting since TalkBack is not reading the normalized number correctly
-        final String normalizedNumber = PhoneNumberUtils.normalizeNumber(phoneNumber);
+        final String normalizedNumber = PhoneNumberUtilsCompat.normalizeNumber(phoneNumber);
         // If the number contains only symbols, we can skip it
         if (TextUtils.isEmpty(normalizedNumber)) {
             return Collections.emptyList();
diff --git a/src/com/android/contacts/interactions/SmsInteractionsLoader.java b/src/com/android/contacts/interactions/SmsInteractionsLoader.java
index 0cd1e5e..5c7d5e3 100644
--- a/src/com/android/contacts/interactions/SmsInteractionsLoader.java
+++ b/src/com/android/contacts/interactions/SmsInteractionsLoader.java
@@ -24,6 +24,8 @@
 import android.provider.Telephony;
 import android.util.Log;
 
+import com.android.contacts.common.compat.TelephonyThreadsCompat;
+
 import java.util.ArrayList;
 import java.util.Collections;
 import java.util.List;
@@ -70,7 +72,7 @@
             // original formatting since TalkBack is not reading the normalized numbers correctly
             try {
                 threadIdStrings.add(String.valueOf(
-                        Telephony.Threads.getOrCreateThreadId(getContext(), phone)));
+                        TelephonyThreadsCompat.getOrCreateThreadId(getContext(), phone)));
             } catch (Exception e) {
                 // Do nothing. Telephony.Threads.getOrCreateThreadId() throws exceptions when
                 // it can't find/create a threadId (b/17657656).
diff --git a/src/com/android/contacts/list/ContactBrowseListFragment.java b/src/com/android/contacts/list/ContactBrowseListFragment.java
index 2381ea5..923208c 100644
--- a/src/com/android/contacts/list/ContactBrowseListFragment.java
+++ b/src/com/android/contacts/list/ContactBrowseListFragment.java
@@ -600,9 +600,9 @@
         mListener = listener;
     }
 
-    public void viewContact(Uri contactUri) {
+    public void viewContact(Uri contactUri, boolean isEnterpriseContact) {
         setSelectedContactUri(contactUri, false, false, true, false);
-        if (mListener != null) mListener.onViewContactAction(contactUri);
+        if (mListener != null) mListener.onViewContactAction(contactUri, isEnterpriseContact);
     }
 
     public void deleteContact(Uri contactUri) {
diff --git a/src/com/android/contacts/list/ContactsUnavailableFragment.java b/src/com/android/contacts/list/ContactsUnavailableFragment.java
index bd811b2..8cbbaa8 100644
--- a/src/com/android/contacts/list/ContactsUnavailableFragment.java
+++ b/src/com/android/contacts/list/ContactsUnavailableFragment.java
@@ -16,9 +16,10 @@
 package com.android.contacts.list;
 
 import android.app.Fragment;
+import android.content.Context;
+import android.content.res.Configuration;
 import android.graphics.PorterDuff;
 import android.os.Bundle;
-import android.provider.ContactsContract.ProviderStatus;
 import android.support.v4.content.ContextCompat;
 import android.view.Gravity;
 import android.view.LayoutInflater;
@@ -30,8 +31,9 @@
 import android.widget.ProgressBar;
 import android.widget.TextView;
 
-import com.android.contacts.activities.ActionBarAdapter.TabState;
 import com.android.contacts.R;
+import com.android.contacts.activities.ActionBarAdapter.TabState;
+import com.android.contacts.compat.ProviderStatusCompat;
 
 /**
  * Fragment shown when contacts are unavailable. It contains provider status
@@ -45,6 +47,7 @@
     private Button mAddAccountButton;
     private Button mImportContactsButton;
     private ProgressBar mProgress;
+    private View mButtonsContainer;
     private int mNoContactsMsgResId = -1;
     private int mLastTab = -1;
 
@@ -68,13 +71,17 @@
         mAddAccountButton = (Button) mView.findViewById(R.id.add_account_button);
         mAddAccountButton.setOnClickListener(this);
         mAddAccountButton.getBackground().setColorFilter(ContextCompat.getColor(getContext(), R
-                .color.primary_color), PorterDuff.Mode.MULTIPLY);
+                .color.primary_color), PorterDuff.Mode.SRC_ATOP);
         mImportContactsButton = (Button) mView.findViewById(R.id.import_contacts_button);
         mImportContactsButton.setOnClickListener(this);
         mImportContactsButton.getBackground().setColorFilter(ContextCompat.getColor(getContext(),
-                R.color.primary_color), PorterDuff.Mode.MULTIPLY);
+                R.color.primary_color), PorterDuff.Mode.SRC_ATOP);
         mProgress = (ProgressBar) mView.findViewById(R.id.progress);
 
+        if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            mButtonsContainer = mView.findViewById(R.id.buttons_container);
+        }
+
         if (mProviderStatus != null) {
             updateStatus(mProviderStatus);
         }
@@ -93,24 +100,46 @@
             // The view hasn't been inflated yet.
             return;
         }
-        switch (providerStatus) {
-            case ProviderStatus.STATUS_EMPTY:
-                setTabInfo(mNoContactsMsgResId, mLastTab);
-                if (mLastTab == TabState.ALL) {
-                    mAddAccountButton.setVisibility(View.VISIBLE);
-                    mImportContactsButton.setVisibility(View.VISIBLE);
-                }
-                mProgress.setVisibility(View.GONE);
-                break;
+        if (providerStatus == ProviderStatusCompat.STATUS_EMPTY) {
+            updateViewsForEmptyStatus();
+        } else if (providerStatus == ProviderStatusCompat.STATUS_BUSY) {
+            updateViewsForBusyStatus(R.string.upgrade_in_progress);
+        } else if (providerStatus == ProviderStatusCompat.STATUS_CHANGING_LOCALE) {
+            updateViewsForBusyStatus(R.string.locale_change_in_progress);
+        }
+    }
 
-            case ProviderStatus.STATUS_BUSY:
-                mMessageView.setText(R.string.upgrade_in_progress);
-                mMessageView.setGravity(Gravity.CENTER_HORIZONTAL);
-                mMessageView.setVisibility(View.VISIBLE);
-                mAddAccountButton.setVisibility(View.GONE);
-                mImportContactsButton.setVisibility(View.GONE);
-                mProgress.setVisibility(View.VISIBLE);
-                break;
+    /**
+     * Update views in the fragment when provider status is empty.
+     */
+    private void updateViewsForEmptyStatus() {
+        setTabInfo(mNoContactsMsgResId, mLastTab);
+        if (mLastTab == TabState.ALL) {
+            updateButtonVisibilty(View.VISIBLE);
+        }
+        mProgress.setVisibility(View.GONE);
+    }
+
+    /**
+     * Update views in the fragment when provider status is busy.
+     *
+     * @param resId resource ID of the string to show in mMessageView.
+     */
+    private void updateViewsForBusyStatus(int resId) {
+        mMessageView.setText(resId);
+        mMessageView.setGravity(Gravity.CENTER_HORIZONTAL);
+        mMessageView.setVisibility(View.VISIBLE);
+        updateButtonVisibilty(View.GONE);
+        mProgress.setVisibility(View.VISIBLE);
+        if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            final ViewGroup.MarginLayoutParams lp =
+                    (ViewGroup.MarginLayoutParams) mMessageView.getLayoutParams();
+            final int marginTop =
+                    (int) getResources().getDimension(R.dimen.update_contact_list_top_margin);
+            lp.setMargins(0, marginTop, 0, 0);
+            mImageView.setVisibility(View.GONE);
+        } else {
+            mImageView.setVisibility(View.INVISIBLE);
         }
     }
 
@@ -128,6 +157,7 @@
                 break;
         }
     }
+
     /**
      * Set the message to be shown if no data is available for the selected tab
      *
@@ -137,24 +167,38 @@
         mNoContactsMsgResId = resId;
         mLastTab = callerTab;
         if ((mMessageView != null) && (mProviderStatus != null) &&
-                (mProviderStatus.equals(ProviderStatus.STATUS_EMPTY))) {
+                mProviderStatus.equals(ProviderStatusCompat.STATUS_EMPTY)) {
             if (resId != -1) {
                 mMessageView.setText(mNoContactsMsgResId);
                 mMessageView.setGravity(Gravity.CENTER_HORIZONTAL);
                 mMessageView.setVisibility(View.VISIBLE);
                 if (callerTab == TabState.FAVORITES) {
                     mImageView.setImageResource(R.drawable.ic_star_black_128dp);
-                    mAddAccountButton.setVisibility(View.GONE);
-                    mImportContactsButton.setVisibility(View.GONE);
                     mProgress.setVisibility(View.GONE);
+                    updateButtonVisibilty(View.GONE);
                 } else if (callerTab == TabState.ALL) {
                     mImageView.setImageResource(R.drawable.ic_person_black_128dp);
-                    mAddAccountButton.setVisibility(View.VISIBLE);
-                    mImportContactsButton.setVisibility(View.VISIBLE);
+                    updateButtonVisibilty(View.VISIBLE);
                 }
             } else {
                 mMessageView.setVisibility(View.GONE);
             }
         }
     }
+
+    private void updateButtonVisibilty(int visibility) {
+        if (getResources().getConfiguration().orientation == Configuration.ORIENTATION_LANDSCAPE) {
+            mAddAccountButton.setVisibility(visibility);
+            mImportContactsButton.setVisibility(visibility);
+            mButtonsContainer.setVisibility(visibility);
+        } else {
+            mAddAccountButton.setVisibility(visibility);
+            mImportContactsButton.setVisibility(visibility);
+        }
+    }
+
+    @Override
+    public Context getContext() {
+        return getActivity();
+    }
 }
diff --git a/src/com/android/contacts/list/DefaultContactBrowseListFragment.java b/src/com/android/contacts/list/DefaultContactBrowseListFragment.java
index fefe28b..9ea8a1d 100644
--- a/src/com/android/contacts/list/DefaultContactBrowseListFragment.java
+++ b/src/com/android/contacts/list/DefaultContactBrowseListFragment.java
@@ -92,7 +92,7 @@
         if (uri == null) {
             return;
         }
-        viewContact(uri);
+        viewContact(uri, getAdapter().isEnterpriseContact(position));
     }
 
     @Override
diff --git a/src/com/android/contacts/list/LegacyPhoneNumberPickerFragment.java b/src/com/android/contacts/list/LegacyPhoneNumberPickerFragment.java
index d62c730..5b6e11f 100644
--- a/src/com/android/contacts/list/LegacyPhoneNumberPickerFragment.java
+++ b/src/com/android/contacts/list/LegacyPhoneNumberPickerFragment.java
@@ -60,7 +60,7 @@
     }
 
     @Override
-    protected void startPhoneNumberShortcutIntent(Uri uri) {
+    protected void startPhoneNumberShortcutIntent(Uri uri, boolean isVideoCall) {
         throw new UnsupportedOperationException();
     }
 
diff --git a/src/com/android/contacts/list/MultiSelectContactsListFragment.java b/src/com/android/contacts/list/MultiSelectContactsListFragment.java
index 4d2eae8..1c5d7e7 100644
--- a/src/com/android/contacts/list/MultiSelectContactsListFragment.java
+++ b/src/com/android/contacts/list/MultiSelectContactsListFragment.java
@@ -19,14 +19,19 @@
 import com.android.contacts.common.list.ContactListAdapter;
 import com.android.contacts.common.list.ContactListItemView;
 import com.android.contacts.common.list.DefaultContactListAdapter;
+import com.android.contacts.common.logging.SearchState;
 import com.android.contacts.list.MultiSelectEntryContactListAdapter.SelectedContactsListener;
+import com.android.contacts.common.logging.Logger;
 
+import android.database.Cursor;
 import android.net.Uri;
 import android.os.Bundle;
 import android.provider.ContactsContract;
 import android.text.TextUtils;
 import android.view.accessibility.AccessibilityEvent;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.TreeSet;
 
 /**
@@ -44,12 +49,31 @@
 
     private static final String EXTRA_KEY_SELECTED_CONTACTS = "selected_contacts";
 
+    private static final String KEY_SEARCH_RESULT_CLICKED = "search_result_clicked";
+
     private OnCheckBoxListActionListener mCheckBoxListListener;
+    private boolean mSearchResultClicked;
 
     public void setCheckBoxListListener(OnCheckBoxListActionListener checkBoxListListener) {
         mCheckBoxListListener = checkBoxListListener;
     }
 
+    /**
+     * Whether a search result was clicked by the user. Tracked so that we can distinguish
+     * between exiting the search mode after a result was clicked from existing w/o clicking
+     * any search result.
+     */
+    public boolean wasSearchResultClicked() {
+        return mSearchResultClicked;
+    }
+
+    /**
+     * Resets whether a search result was clicked by the user to false.
+     */
+    public void resetSearchResultClicked() {
+        mSearchResultClicked = false;
+    }
+
     @Override
     public void onSelectedContactsChanged() {
         if (mCheckBoxListListener != null) {
@@ -77,6 +101,7 @@
             if (mCheckBoxListListener != null) {
                 mCheckBoxListListener.onSelectedContactIdsChanged();
             }
+            mSearchResultClicked = savedInstanceState.getBoolean(KEY_SEARCH_RESULT_CLICKED);
         }
     }
 
@@ -100,6 +125,7 @@
     public void onSaveInstanceState(Bundle outState) {
         super.onSaveInstanceState(outState);
         outState.putSerializable(EXTRA_KEY_SELECTED_CONTACTS, getSelectedContactIds());
+        outState.putBoolean(KEY_SEARCH_RESULT_CLICKED, mSearchResultClicked);
     }
 
     public void displayCheckBoxes(boolean displayCheckBoxes) {
@@ -157,6 +183,10 @@
                 getAdapter().toggleSelectionOfContactId(Long.valueOf(contactId));
             }
         } else {
+            mSearchResultClicked = true;
+            Logger.getInstance().logSearchEventImpl(
+                    createSearchStateForSearchResultClick(position));
+
             super.onItemClick(position, id);
         }
         if (mCheckBoxListListener != null && getAdapter().getSelectedContactIds().size() == 0) {
@@ -164,6 +194,73 @@
         }
     }
 
+    /**
+     * Returns the state of the search results currently presented to the user.
+     */
+    public SearchState createSearchState() {
+        return createSearchState(/* selectedPosition */ -1);
+    }
+
+    /**
+     * Returns the state of the search results presented to the user
+     * at the time the result in the given position was clicked.
+     */
+    public SearchState createSearchStateForSearchResultClick(int selectedPosition) {
+        return createSearchState(selectedPosition);
+    }
+
+    private SearchState createSearchState(int selectedPosition) {
+        final MultiSelectEntryContactListAdapter adapter = getAdapter();
+        if (adapter == null) {
+            return null;
+        }
+        final SearchState searchState = new SearchState();
+        searchState.queryLength = adapter.getQueryString() == null
+                ? 0 : adapter.getQueryString().length();
+        searchState.numPartitions = adapter.getPartitionCount();
+
+        // Set the number of results displayed to the user.  Note that the adapter.getCount(),
+        // value does not always match the number of results actually displayed to the user,
+        // which is why we calculate it manually.
+        final List<Integer> numResultsInEachPartition = new ArrayList<>();
+        for (int i = 0; i < adapter.getPartitionCount(); i++) {
+            final Cursor cursor = adapter.getCursor(i);
+            if (cursor == null || cursor.isClosed()) {
+                // Something went wrong, abort.
+                numResultsInEachPartition.clear();
+                break;
+            }
+            numResultsInEachPartition.add(cursor.getCount());
+        }
+        if (!numResultsInEachPartition.isEmpty()) {
+            int numResults = 0;
+            for (int i = 0; i < numResultsInEachPartition.size(); i++) {
+                numResults += numResultsInEachPartition.get(i);
+            }
+            searchState.numResults = numResults;
+        }
+
+        // If a selection was made, set additional search state
+        if (selectedPosition >= 0) {
+            searchState.selectedPartition = adapter.getPartitionForPosition(selectedPosition);
+            searchState.selectedIndexInPartition = adapter.getOffsetInPartition(selectedPosition);
+            final Cursor cursor = adapter.getCursor(searchState.selectedPartition);
+            searchState.numResultsInSelectedPartition =
+                    cursor == null || cursor.isClosed() ? -1 : cursor.getCount();
+
+            // Calculate the index across all partitions
+            if (!numResultsInEachPartition.isEmpty()) {
+                int selectedIndex = 0;
+                for (int i = 0; i < searchState.selectedPartition; i++) {
+                    selectedIndex += numResultsInEachPartition.get(i);
+                }
+                selectedIndex += searchState.selectedIndexInPartition;
+                searchState.selectedIndex = selectedIndex;
+            }
+        }
+        return searchState;
+    }
+
     @Override
     protected ContactListAdapter createListAdapter() {
         DefaultContactListAdapter adapter = new MultiSelectEntryContactListAdapter(getContext());
diff --git a/src/com/android/contacts/list/OnContactBrowserActionListener.java b/src/com/android/contacts/list/OnContactBrowserActionListener.java
index d91fee4..59fc611 100644
--- a/src/com/android/contacts/list/OnContactBrowserActionListener.java
+++ b/src/com/android/contacts/list/OnContactBrowserActionListener.java
@@ -33,7 +33,7 @@
      *
      * @param contactLookupUri The lookup-uri of the Contact that should be opened
      */
-    void onViewContactAction(Uri contactLookupUri);
+    void onViewContactAction(Uri contactLookupUri, boolean isEnterpriseContact);
 
     /**
      * Initiates the contact deletion process.
diff --git a/src/com/android/contacts/list/ProviderStatusWatcher.java b/src/com/android/contacts/list/ProviderStatusWatcher.java
index f42bc3e..51f776b 100644
--- a/src/com/android/contacts/list/ProviderStatusWatcher.java
+++ b/src/com/android/contacts/list/ProviderStatusWatcher.java
@@ -25,6 +25,8 @@
 import android.provider.ContactsContract.ProviderStatus;
 import android.util.Log;
 
+import com.android.contacts.compat.ProviderStatusCompat;
+
 import com.google.common.collect.Lists;
 
 import java.util.ArrayList;
@@ -167,16 +169,16 @@
      * provider?) this may still cause ANRs.
      *
      * In order to avoid that, if we can't load the status within {@link #LOAD_WAIT_TIMEOUT_MS},
-     * we'll give up and just returns {@link ProviderStatus#STATUS_BUSY} in order to unblock
+     * we'll give up and just returns {@link ProviderStatusCompat#STATUS_BUSY} in order to unblock
      * the UI thread.  The actual result will be delivered later via {@link ProviderStatusListener}.
-     * (If {@link ProviderStatus#STATUS_BUSY} is returned, the app (should) shows an according
+     * (If {@link ProviderStatusCompat#STATUS_BUSY} is returned, the app (should) shows an according
      * message, like "contacts are being updated".)
      */
     public int getProviderStatus() {
         waitForLoaded();
 
         if (mProviderStatus == null) {
-            return ProviderStatus.STATUS_BUSY;
+            return ProviderStatusCompat.STATUS_BUSY;
         }
 
         return mProviderStatus;
diff --git a/src/com/android/contacts/preference/ContactsPreferenceActivity.java b/src/com/android/contacts/preference/ContactsPreferenceActivity.java
deleted file mode 100644
index a779a94..0000000
--- a/src/com/android/contacts/preference/ContactsPreferenceActivity.java
+++ /dev/null
@@ -1,85 +0,0 @@
-/*
- * Copyright (C) 2009 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.contacts.preference;
-
-import android.app.ActionBar;
-import android.content.Context;
-import android.content.Intent;
-import android.os.Bundle;
-import android.preference.PreferenceActivity;
-import android.view.MenuItem;
-
-import com.android.contacts.R;
-import com.android.contacts.activities.PeopleActivity;
-
-import java.util.List;
-
-/**
- * Contacts settings.
- */
-public final class ContactsPreferenceActivity extends PreferenceActivity {
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-
-        // This Activity will always fall back to the "top" Contacts screen when touched on the
-        // app up icon, regardless of launch context.
-        ActionBar actionBar = getActionBar();
-        if (actionBar != null) {
-            actionBar.setDisplayOptions(ActionBar.DISPLAY_HOME_AS_UP, ActionBar.DISPLAY_HOME_AS_UP);
-        }
-    }
-
-    /**
-     * Populate the activity with the top-level headers.
-     */
-    @Override
-    public void onBuildHeaders(List<Header> target) {
-        loadHeadersFromResource(R.xml.preference_headers, target);
-    }
-
-    /**
-     * Returns true if there are no preferences to display and therefore the
-     * corresponding menu item can be removed.
-     */
-    public static boolean isEmpty(Context context) {
-        return !context.getResources().getBoolean(R.bool.config_sort_order_user_changeable)
-                && !context.getResources().getBoolean(R.bool.config_display_order_user_changeable)
-                && !context.getResources().getBoolean(
-                        R.bool.config_default_account_user_changeable);
-    }
-
-    @Override
-    public boolean onOptionsItemSelected(MenuItem item) {
-        switch (item.getItemId()) {
-            case android.R.id.home: {
-                Intent intent = new Intent(this, PeopleActivity.class);
-                intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP);
-                startActivity(intent);
-                finish();
-                return true;
-            }
-        }
-        return false;
-    }
-
-    @Override
-    protected boolean isValidFragment(String fragmentName) {
-        return true;
-    }
-}
diff --git a/src/com/android/contacts/quickcontact/ExpandingEntryCardView.java b/src/com/android/contacts/quickcontact/ExpandingEntryCardView.java
index 10887cb..762ff6c 100644
--- a/src/com/android/contacts/quickcontact/ExpandingEntryCardView.java
+++ b/src/com/android/contacts/quickcontact/ExpandingEntryCardView.java
@@ -108,7 +108,7 @@
         private final Intent mIntent;
         private final Drawable mAlternateIcon;
         private final Intent mAlternateIntent;
-        private final String mAlternateContentDescription;
+        private Spannable mAlternateContentDescription;
         private final boolean mShouldApplyColor;
         private final boolean mIsEditable;
         private final EntryContextMenuInfo mEntryContextMenuInfo;
@@ -122,8 +122,8 @@
         public Entry(int id, Drawable mainIcon, String header, String subHeader,
                 Drawable subHeaderIcon, String text, Drawable textIcon,
                 Spannable primaryContentDescription, Intent intent,
-                Drawable alternateIcon, Intent alternateIntent, String alternateContentDescription,
-                boolean shouldApplyColor, boolean isEditable,
+                Drawable alternateIcon, Intent alternateIntent,
+                Spannable alternateContentDescription, boolean shouldApplyColor, boolean isEditable,
                 EntryContextMenuInfo entryContextMenuInfo, Drawable thirdIcon, Intent thirdIntent,
                 String thirdContentDescription, int thirdAction, Bundle thirdExtras,
                 int iconResourceId) {
@@ -190,7 +190,7 @@
             return mAlternateIntent;
         }
 
-        String getAlternateContentDescription() {
+        Spannable getAlternateContentDescription() {
             return mAlternateContentDescription;
         }
 
diff --git a/src/com/android/contacts/quickcontact/InvisibleContactUtil.java b/src/com/android/contacts/quickcontact/InvisibleContactUtil.java
index 706cfdb..fa1132b 100644
--- a/src/com/android/contacts/quickcontact/InvisibleContactUtil.java
+++ b/src/com/android/contacts/quickcontact/InvisibleContactUtil.java
@@ -96,7 +96,7 @@
                 contactDeltaList, "", 0, false, QuickContactActivity.class,
                 Intent.ACTION_VIEW, null, /* joinContactIdExtraKey =*/ null,
                 /* joinContactId =*/ null);
-        context.startService(intent);
+        ContactSaveService.startService(context, intent);
     }
 
     /** return default group id or -1 if no group or several groups are marked as default */
diff --git a/src/com/android/contacts/quickcontact/QuickContactActivity.java b/src/com/android/contacts/quickcontact/QuickContactActivity.java
index 143cb47..577eebe 100644
--- a/src/com/android/contacts/quickcontact/QuickContactActivity.java
+++ b/src/com/android/contacts/quickcontact/QuickContactActivity.java
@@ -31,6 +31,7 @@
 import android.content.Loader;
 import android.content.pm.PackageManager;
 import android.content.pm.ResolveInfo;
+import android.content.res.ColorStateList;
 import android.content.res.Resources;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
@@ -67,6 +68,7 @@
 import android.provider.ContactsContract.Intents;
 import android.provider.ContactsContract.QuickContact;
 import android.provider.ContactsContract.RawContacts;
+import android.support.v4.content.ContextCompat;
 import android.support.v7.graphics.Palette;
 import android.support.v7.widget.CardView;
 import android.telecom.PhoneAccount;
@@ -107,6 +109,8 @@
 import com.android.contacts.common.ContactPhotoManager;
 import com.android.contacts.common.ContactsUtils;
 import com.android.contacts.common.activity.RequestPermissionsActivity;
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.common.compat.EventCompat;
 import com.android.contacts.common.dialog.CallSubjectDialog;
 import com.android.contacts.common.editor.SelectAccountDialogFragment;
 import com.android.contacts.common.interactions.TouchPointManager;
@@ -183,9 +187,6 @@
 import java.util.TreeSet;
 import java.util.concurrent.ConcurrentHashMap;
 
-import android.graphics.PorterDuff;
-import android.support.v4.content.ContextCompat;
-
 /**
  * Mostly translucent {@link Activity} that shows QuickContact dialog. It loads
  * data asynchronously, and then shows a popup with details centered around
@@ -208,7 +209,6 @@
     private static final String KEY_SELECTED_SUGGESTION_CONTACTS = "selected_suggestion_contacts";
     private static final String KEY_PREVIOUS_CONTACT_ID = "previous_contact_id";
     private static final String KEY_SUGGESTIONS_AUTO_SELECTED = "suggestions_auto_seleted";
-    private static final String KEY_SELECTED_SUGGESTION_NUMBER = "selected_suggestion_number";
 
     private static final int ANIMATION_STATUS_BAR_COLOR_CHANGE_DURATION = 150;
     private static final int REQUEST_CODE_CONTACT_EDITOR_ACTIVITY = 1;
@@ -494,6 +494,9 @@
 
     @Override
     public void onAggregationSuggestionChange() {
+        if (mAggregationSuggestionEngine == null) {
+            return;
+        }
         mSuggestions = mAggregationSuggestionEngine.getSuggestions();
         mCollapsedSuggestionCardView.setVisibility(View.GONE);
         mExpandSuggestionCardView.setVisibility(View.GONE);
@@ -611,6 +614,12 @@
         }
 
         final CheckBox checkbox = (CheckBox) suggestionView.findViewById(R.id.suggestion_checkbox);
+        final int[][] stateSet = new int[][] {
+                new int[] { android.R.attr.state_checked },
+                new int[] { -android.R.attr.state_checked }
+        };
+        final int[] colors = new int[] { mColorFilterColor, mColorFilterColor };
+        checkbox.setButtonTintList(new ColorStateList(stateSet, colors));
         checkbox.setChecked(mSuggestionsShouldAutoSelected ||
                 mSelectedAggregationIds.contains(suggestion.contactId));
         if (checkbox.isChecked()) {
@@ -645,10 +654,9 @@
 
     private void enableLinkButton() {
         mSuggestionsLinkButton.setClickable(true);
-        mSuggestionsLinkButton.getBackground().setColorFilter(getResources().getColor(
-                R.color.primary_color, getTheme()), PorterDuff.Mode.SRC_ATOP);
-        mSuggestionsLinkButton.setTextColor(getResources().getColor(android.R.color.white,
-                getTheme()));
+        mSuggestionsLinkButton.getBackground().setColorFilter(mColorFilter);
+        mSuggestionsLinkButton.setTextColor(
+                ContextCompat.getColor(this, android.R.color.white));
         mSuggestionsLinkButton.setOnClickListener(new OnClickListener() {
             @Override
             public void onClick(View view) {
@@ -670,10 +678,10 @@
     private void disableLinkButton() {
         mSuggestionsLinkButton.setClickable(false);
         mSuggestionsLinkButton.getBackground().setColorFilter(
-                getResources().getColor(R.color.disabled_button_background, getTheme()),
+                ContextCompat.getColor(this, R.color.disabled_button_background),
                 PorterDuff.Mode.SRC_ATOP);
         mSuggestionsLinkButton.setTextColor(
-                getResources().getColor(R.color.disabled_button_text, getTheme()));
+                ContextCompat.getColor(this, R.color.disabled_button_text));
     }
 
     private interface ContextMenuIds {
@@ -930,7 +938,9 @@
             return;
         }
 
-        getWindow().setStatusBarColor(Color.TRANSPARENT);
+        if (CompatUtils.isLollipopCompatible()) {
+            getWindow().setStatusBarColor(Color.TRANSPARENT);
+        }
 
         processIntent(getIntent());
 
@@ -961,7 +971,6 @@
         mSuggestionList = (LinearLayout) findViewById(R.id.suggestion_list);
         mSuggestionsCancelButton= (Button) findViewById(R.id.cancel_button);
         mSuggestionsLinkButton = (Button) findViewById(R.id.link_button);
-        final int previousSelectedSuggestion;
         if (savedInstanceState != null) {
             mIsSuggestionListCollapsed = savedInstanceState.getBoolean(
                     KEY_IS_SUGGESTION_LIST_COLLAPSED, true);
@@ -970,16 +979,14 @@
                     KEY_SUGGESTIONS_AUTO_SELECTED, true);
             mSelectedAggregationIds = (TreeSet<Long>)
                     savedInstanceState.getSerializable(KEY_SELECTED_SUGGESTION_CONTACTS);
-            previousSelectedSuggestion = savedInstanceState.getInt(KEY_SELECTED_SUGGESTION_NUMBER);
         } else {
             mIsSuggestionListCollapsed = true;
             mSelectedAggregationIds.clear();
-            previousSelectedSuggestion = -1;
         }
-        if (previousSelectedSuggestion == -1 || previousSelectedSuggestion > 0) {
-            enableLinkButton();
-        } else {
+        if (mSelectedAggregationIds.isEmpty()) {
             disableLinkButton();
+        } else {
+            enableLinkButton();
         }
         mCollapasedSuggestionHeader.setOnClickListener(new OnClickListener() {
             @Override
@@ -987,7 +994,6 @@
                 mCollapsedSuggestionCardView.setVisibility(View.GONE);
                 mExpandSuggestionCardView.setVisibility(View.VISIBLE);
                 mIsSuggestionListCollapsed = false;
-                mSuggestionsShouldAutoSelected = true;
             }
         });
 
@@ -1136,13 +1142,6 @@
                 KEY_SUGGESTIONS_AUTO_SELECTED, mSuggestionsShouldAutoSelected);
         savedInstanceState.putSerializable(
                 KEY_SELECTED_SUGGESTION_CONTACTS, mSelectedAggregationIds);
-        final int selectedSuggestion;
-        if (mSelectedAggregationIds.contains(mContactData.getId())) {
-            selectedSuggestion = mSelectedAggregationIds.size() - 1;
-        } else {
-            selectedSuggestion = mSelectedAggregationIds.size();
-        }
-        savedInstanceState.putInt(KEY_SELECTED_SUGGESTION_NUMBER, selectedSuggestion);
     }
 
     private void processIntent(Intent intent) {
@@ -1393,9 +1392,16 @@
             mCollapsedSuggestionCardView.setVisibility(View.GONE);
             mExpandSuggestionCardView.setVisibility(View.GONE);
             mIsSuggestionListCollapsed = true;
+            mSuggestionsShouldAutoSelected = true;
             mSuggestionList.removeAllViews();
         }
 
+        // Do not show the card when it's directory contact or invisible.
+        if (DirectoryContactUtil.isDirectoryContact(mContactData)
+                || InvisibleContactUtil.isInvisibleAndAddable(mContactData, this)) {
+            return;
+        }
+
         if (mAggregationSuggestionEngine == null) {
             mAggregationSuggestionEngine = new AggregationSuggestionEngine(this);
             mAggregationSuggestionEngine.setListener(this);
@@ -1706,6 +1712,7 @@
         Drawable textIcon = null;
         StringBuilder primaryContentDescription = new StringBuilder();
         Spannable phoneContentDescription = null;
+        Spannable smsContentDescription = null;
         Intent intent = null;
         boolean shouldApplyColor = true;
         Drawable alternateIcon = null;
@@ -1805,7 +1812,7 @@
             }
             header = res.getString(R.string.header_event_entry);
             if (event.hasKindTypeColumn(kind)) {
-                subHeader = Event.getTypeLabel(res, event.getKindTypeColumn(kind),
+                subHeader = EventCompat.getTypeLabel(res, event.getKindTypeColumn(kind),
                         event.getLabel()).toString();
             }
             text = DateUtils.formatDate(context, dataString);
@@ -1863,13 +1870,19 @@
 
                 alternateIcon = res.getDrawable(R.drawable.ic_message_24dp);
                 alternateContentDescription.append(res.getString(R.string.sms_custom, header));
+                smsContentDescription = com.android.contacts.common.util.ContactDisplayUtils
+                        .getTelephoneTtsSpannable(alternateContentDescription.toString(), header);
+
+                int videoCapability = CallUtil.getVideoCallingAvailability(context);
+                boolean isPresenceEnabled =
+                        (videoCapability & CallUtil.VIDEO_CALLING_PRESENCE) != 0;
+                boolean isVideoEnabled = (videoCapability & CallUtil.VIDEO_CALLING_ENABLED) != 0;
 
                 if (CallUtil.isCallWithSubjectSupported(context)) {
                     thirdIcon = res.getDrawable(R.drawable.ic_call_note_white_24dp);
                     thirdAction = Entry.ACTION_CALL_WITH_SUBJECT;
                     thirdContentDescription =
                             res.getString(R.string.call_with_a_note);
-
                     // Create a bundle containing the data the call subject dialog requires.
                     thirdExtras = new Bundle();
                     thirdExtras.putLong(CallSubjectDialog.ARG_PHOTO_ID,
@@ -1887,14 +1900,19 @@
                             phone.getFormattedPhoneNumber());
                     thirdExtras.putString(CallSubjectDialog.ARG_NUMBER_LABEL,
                             phoneLabel);
-                } else if (CallUtil.isVideoEnabled(context)) {
-                    // Add video call button if supported
-                    thirdIcon = res.getDrawable(R.drawable.ic_videocam);
-                    thirdAction = Entry.ACTION_INTENT;
-                    thirdIntent = CallUtil.getVideoCallIntent(phone.getNumber(),
-                            CALL_ORIGIN_QUICK_CONTACTS_ACTIVITY);
-                    thirdContentDescription =
-                            res.getString(R.string.description_video_call);
+                } else if (isVideoEnabled) {
+                    // Check to ensure carrier presence indicates the number supports video calling.
+                    int carrierPresence = dataItem.getCarrierPresence();
+                    boolean isPresent = (carrierPresence & Phone.CARRIER_PRESENCE_VT_CAPABLE) != 0;
+
+                    if ((isPresenceEnabled && isPresent) || !isPresenceEnabled) {
+                        thirdIcon = res.getDrawable(R.drawable.ic_videocam);
+                        thirdAction = Entry.ACTION_INTENT;
+                        thirdIntent = CallUtil.getVideoCallIntent(phone.getNumber(),
+                                CALL_ORIGIN_QUICK_CONTACTS_ACTIVITY);
+                        thirdContentDescription =
+                                res.getString(R.string.description_video_call);
+                    }
                 }
             }
         } else if (dataItem instanceof EmailDataItem) {
@@ -2088,7 +2106,10 @@
                         ? new SpannableString(primaryContentDescription.toString())
                         : phoneContentDescription,
                 intent, alternateIcon, alternateIntent,
-                alternateContentDescription.toString(), shouldApplyColor, isEditable,
+                smsContentDescription == null
+                        ? new SpannableString(alternateContentDescription.toString())
+                        : smsContentDescription,
+                shouldApplyColor, isEditable,
                 entryContextMenuInfo, thirdIcon, thirdIntent, thirdContentDescription, thirdAction,
                 thirdExtras, iconResourceId);
     }
@@ -2289,6 +2310,8 @@
                 if (imageViewDrawable == mPhotoView.getDrawable()) {
                     mHasComputedThemeColor = true;
                     setThemeColor(palette);
+                    // update color and photo in suggestion card
+                    onAggregationSuggestionChange();
                 }
             }
         }.execute();
@@ -2306,10 +2329,11 @@
         mContactCard.setColorAndFilter(mColorFilterColor, mColorFilter);
         mRecentCard.setColorAndFilter(mColorFilterColor, mColorFilter);
         mAboutCard.setColorAndFilter(mColorFilterColor, mColorFilter);
+        mSuggestionsCancelButton.setTextColor(mColorFilterColor);
     }
 
     private void updateStatusBarColor() {
-        if (mScroller == null) {
+        if (mScroller == null || !CompatUtils.isLollipopCompatible()) {
             return;
         }
         final int desiredStatusBarColor;
diff --git a/src/com/android/contacts/util/AccountPromptUtils.java b/src/com/android/contacts/util/AccountPromptUtils.java
index 172d274..4fc95a5 100644
--- a/src/com/android/contacts/util/AccountPromptUtils.java
+++ b/src/com/android/contacts/util/AccountPromptUtils.java
@@ -24,9 +24,12 @@
 import android.accounts.OperationCanceledException;
 import android.app.Activity;
 import android.content.Context;
+import android.content.Intent;
 import android.content.SharedPreferences;
 import android.os.Bundle;
 import android.preference.PreferenceManager;
+import android.provider.ContactsContract;
+import android.provider.Settings;
 import android.util.Log;
 
 import com.android.contacts.R;
@@ -100,6 +103,18 @@
                 activity, getAccountManagerCallback(activity), null);
     }
 
+    /**
+     * When adding account
+     * open the same UI screen for user to choose account
+     */
+    public static Intent getIntentForAddingAccount() {
+         final Intent intent = new Intent(Settings.ACTION_ADD_ACCOUNT);
+         intent.setFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
+         intent.putExtra(Settings.EXTRA_AUTHORITIES,
+                 new String[]{ContactsContract.AUTHORITY});
+         return intent;
+    }
+
     private static AccountManagerCallback<Bundle> getAccountManagerCallback(
             final Activity activity) {
         return new AccountManagerCallback<Bundle>() {
diff --git a/src/com/android/contacts/util/PhoneCapabilityTester.java b/src/com/android/contacts/util/PhoneCapabilityTester.java
index a510b76..d1373f4 100644
--- a/src/com/android/contacts/util/PhoneCapabilityTester.java
+++ b/src/com/android/contacts/util/PhoneCapabilityTester.java
@@ -28,6 +28,7 @@
 import android.telephony.TelephonyManager;
 
 import com.android.contacts.common.ContactsUtils;
+import com.android.contacts.common.compat.TelephonyManagerCompat;
 
 import java.util.List;
 
@@ -61,9 +62,8 @@
     }
 
     private static void initialize(Context context) {
-        final TelephonyManager telephonyManager
-                = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
-        sIsPhone = telephonyManager.isVoiceCapable();
+        sIsPhone = TelephonyManagerCompat.isVoiceCapable(
+                (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE));
         sIsSipPhone = sIsPhone && SipManager.isVoipSupported(context);
         sIsInitialized = true;
     }
diff --git a/src/com/android/contacts/widget/EmptyContentView.java b/src/com/android/contacts/widget/EmptyContentView.java
new file mode 100644
index 0000000..12795e3
--- /dev/null
+++ b/src/com/android/contacts/widget/EmptyContentView.java
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2016 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.contacts.widget;
+
+import android.content.Context;
+import android.util.AttributeSet;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import com.android.contacts.R;
+
+public class EmptyContentView extends LinearLayout implements View.OnClickListener {
+
+    public static final int NO_LABEL = 0;
+    public static final int NO_IMAGE = 0;
+
+    private ImageView mImageView;
+    private TextView mDescriptionView;
+    private TextView mActionView;
+    private OnEmptyViewActionButtonClickedListener mOnActionButtonClickedListener;
+
+    public interface OnEmptyViewActionButtonClickedListener {
+        public void onEmptyViewActionButtonClicked();
+    }
+
+    public EmptyContentView(Context context) {
+        this(context, null);
+    }
+
+    public EmptyContentView(Context context, AttributeSet attrs) {
+        this(context, attrs, 0);
+    }
+
+    public EmptyContentView(Context context, AttributeSet attrs, int defStyleAttr) {
+        this(context, attrs, defStyleAttr, 0);
+    }
+
+    public EmptyContentView(Context context, AttributeSet attrs, int defStyleAttr,
+            int defStyleRes) {
+        super(context, attrs, defStyleAttr, defStyleRes);
+        setOrientation(LinearLayout.VERTICAL);
+
+        final LayoutInflater inflater = (LayoutInflater) getContext().getSystemService(
+                Context.LAYOUT_INFLATER_SERVICE);
+        inflater.inflate(R.layout.empty_content_view, this);
+        // Don't let touches fall through the empty view.
+        setClickable(true);
+        mImageView = (ImageView) findViewById(R.id.emptyListViewImage);
+        mDescriptionView = (TextView) findViewById(R.id.emptyListViewMessage);
+        mActionView = (TextView) findViewById(R.id.emptyListViewAction);
+        mActionView.setOnClickListener(this);
+    }
+
+    public void setDescription(int resourceId) {
+        if (resourceId == NO_LABEL) {
+            mDescriptionView.setText(null);
+            mDescriptionView.setVisibility(View.GONE);
+        } else {
+            mDescriptionView.setText(resourceId);
+            mDescriptionView.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public void setImage(int resourceId) {
+        if (resourceId == NO_LABEL) {
+            mImageView.setImageDrawable(null);
+            mImageView.setVisibility(View.GONE);
+        } else {
+            mImageView.setImageResource(resourceId);
+            mImageView.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public void setActionLabel(int resourceId) {
+        if (resourceId == NO_LABEL) {
+            mActionView.setText(null);
+            mActionView.setVisibility(View.GONE);
+        } else {
+            mActionView.setText(resourceId);
+            mActionView.setVisibility(View.VISIBLE);
+        }
+    }
+
+    public boolean isShowingContent() {
+        return mImageView.getVisibility() == View.VISIBLE
+                || mDescriptionView.getVisibility() == View.VISIBLE
+                || mActionView.getVisibility() == View.VISIBLE;
+    }
+
+    public void setActionClickedListener(OnEmptyViewActionButtonClickedListener listener) {
+        mOnActionButtonClickedListener = listener;
+    }
+
+    @Override
+    public void onClick(View v) {
+        if (mOnActionButtonClickedListener != null) {
+            mOnActionButtonClickedListener.onEmptyViewActionButtonClicked();
+        }
+    }
+}
diff --git a/src/com/android/contacts/widget/MultiShrinkScroller.java b/src/com/android/contacts/widget/MultiShrinkScroller.java
index d1cb9f8..1fbd3ae 100644
--- a/src/com/android/contacts/widget/MultiShrinkScroller.java
+++ b/src/com/android/contacts/widget/MultiShrinkScroller.java
@@ -1,6 +1,8 @@
 package com.android.contacts.widget;
 
 import com.android.contacts.R;
+import com.android.contacts.common.compat.CompatUtils;
+import com.android.contacts.compat.EdgeEffectCompat;
 import com.android.contacts.quickcontact.ExpandingEntryCardView;
 import com.android.contacts.test.NeededForReflection;
 import com.android.contacts.util.SchedulingUtils;
@@ -20,6 +22,8 @@
 import android.graphics.drawable.GradientDrawable;
 import android.hardware.display.DisplayManager;
 import android.os.Trace;
+import android.support.v4.view.ViewCompat;
+import android.support.v4.view.animation.PathInterpolatorCompat;
 import android.util.AttributeSet;
 import android.util.TypedValue;
 import android.view.Display;
@@ -31,7 +35,6 @@
 import android.view.ViewConfiguration;
 import android.view.animation.AnimationUtils;
 import android.view.animation.Interpolator;
-import android.view.animation.PathInterpolator;
 import android.widget.EdgeEffect;
 import android.widget.FrameLayout;
 import android.widget.LinearLayout;
@@ -177,8 +180,8 @@
             0, 0, 0, 1, 0
     };
 
-    private final PathInterpolator mTextSizePathInterpolator
-            = new PathInterpolator(0.16f, 0.4f, 0.2f, 1);
+    private final Interpolator mTextSizePathInterpolator =
+            PathInterpolatorCompat.create(0.16f, 0.4f, 0.2f, 1);
 
     private final int[] mGradientColors = new int[] {0,0x88000000};
     private GradientDrawable mTitleGradientDrawable = new GradientDrawable(
@@ -499,7 +502,8 @@
                     if (delta > distanceFromMaxScrolling) {
                         // The ScrollView is being pulled upwards while there is no more
                         // content offscreen, and the view port is already fully expanded.
-                        mEdgeGlowBottom.onPull(delta / getHeight(), 1 - event.getX() / getWidth());
+                        EdgeEffectCompat.onPull(mEdgeGlowBottom, delta / getHeight(),
+                                1 - event.getX() / getWidth());
                     }
 
                     if (!mEdgeGlowBottom.isFinished()) {
@@ -526,10 +530,12 @@
     public void setHeaderTintColor(int color) {
         mHeaderTintColor = color;
         updatePhotoTintAndDropShadow();
-        // We want to use the same amount of alpha on the new tint color as the previous tint color.
-        final int edgeEffectAlpha = Color.alpha(mEdgeGlowBottom.getColor());
-        mEdgeGlowBottom.setColor((color & 0xffffff) | Color.argb(edgeEffectAlpha, 0, 0, 0));
-        mEdgeGlowTop.setColor(mEdgeGlowBottom.getColor());
+        if (CompatUtils.isLollipopCompatible()) {
+            // Use the same amount of alpha on the new tint color as the previous tint color.
+            final int edgeEffectAlpha = Color.alpha(mEdgeGlowBottom.getColor());
+            mEdgeGlowBottom.setColor((color & 0xffffff) | Color.argb(edgeEffectAlpha, 0, 0, 0));
+            mEdgeGlowTop.setColor(mEdgeGlowBottom.getColor());
+        }
     }
 
     /**
@@ -1117,9 +1123,9 @@
         final int toolbarHeight = getToolbarHeight();
 
         if (toolbarHeight <= mMinimumHeaderHeight && !mIsTwoPanel) {
-            mPhotoViewContainer.setElevation(mToolbarElevation);
+            ViewCompat.setElevation(mPhotoViewContainer, mToolbarElevation);
         } else {
-            mPhotoViewContainer.setElevation(0);
+            ViewCompat.setElevation(mPhotoViewContainer, 0);
         }
 
         // Reuse an existing mColorFilter (to avoid GC pauses) to change the photo's tint.
diff --git a/src/com/android/contacts/widget/QuickContactImageView.java b/src/com/android/contacts/widget/QuickContactImageView.java
index a8f0b10..f85fe16 100644
--- a/src/com/android/contacts/widget/QuickContactImageView.java
+++ b/src/com/android/contacts/widget/QuickContactImageView.java
@@ -36,12 +36,7 @@
     }
 
     public QuickContactImageView(Context context, AttributeSet attrs, int defStyleAttr) {
-        this(context, attrs, defStyleAttr, 0);
-    }
-
-    public QuickContactImageView(Context context, AttributeSet attrs, int defStyleAttr,
-            int defStyleRes) {
-        super(context, attrs, defStyleAttr, defStyleRes);
+        super(context, attrs, defStyleAttr);
     }
 
     public void setTint(int color) {
diff --git a/src/com/android/contacts/widget/SearchEditTextLayout.java b/src/com/android/contacts/widget/SearchEditTextLayout.java
new file mode 100644
index 0000000..6d24fbb
--- /dev/null
+++ b/src/com/android/contacts/widget/SearchEditTextLayout.java
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2016 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.contacts.widget;
+
+import android.content.Context;
+import android.text.Editable;
+import android.text.TextUtils;
+import android.text.TextWatcher;
+import android.util.AttributeSet;
+import android.view.KeyEvent;
+import android.view.View;
+import android.view.inputmethod.InputMethodManager;
+import android.widget.EditText;
+import android.widget.FrameLayout;
+
+import com.android.contacts.R;
+import com.android.phone.common.animation.AnimUtils;
+
+public class SearchEditTextLayout extends FrameLayout {
+    private static final int ANIMATION_DURATION = 200;
+
+    private OnKeyListener mPreImeKeyListener;
+    private int mTopMargin;
+    private int mBottomMargin;
+    private int mLeftMargin;
+    private int mRightMargin;
+
+    /* Subclass-visible for testing */
+    protected boolean mIsExpanded = false;
+    protected boolean mIsFadedOut = false;
+
+    private View mExpanded;
+    private EditText mSearchView;
+    private View mBackButtonView;
+    private View mClearButtonView;
+
+    private Callback mCallback;
+
+    /**
+     * Listener for the back button next to the search view being pressed
+     */
+    public interface Callback {
+        public void onBackButtonClicked();
+        public void onSearchViewClicked();
+    }
+
+    public SearchEditTextLayout(Context context, AttributeSet attrs) {
+        super(context, attrs);
+    }
+
+    public void setPreImeKeyListener(OnKeyListener listener) {
+        mPreImeKeyListener = listener;
+    }
+
+    public void setCallback(Callback listener) {
+        mCallback = listener;
+    }
+
+    @Override
+    protected void onFinishInflate() {
+        MarginLayoutParams params = (MarginLayoutParams) getLayoutParams();
+        mTopMargin = params.topMargin;
+        mBottomMargin = params.bottomMargin;
+        mLeftMargin = params.leftMargin;
+        mRightMargin = params.rightMargin;
+
+        mExpanded = findViewById(R.id.search_box_expanded);
+        mSearchView = (EditText) mExpanded.findViewById(R.id.search_view);
+
+        mBackButtonView = findViewById(R.id.search_back_button);
+        mClearButtonView = findViewById(R.id.search_close_button);
+
+        mSearchView.setOnFocusChangeListener(new OnFocusChangeListener() {
+            @Override
+            public void onFocusChange(View v, boolean hasFocus) {
+                if (hasFocus) {
+                    showInputMethod(v);
+                } else {
+                    hideInputMethod(v);
+                }
+            }
+        });
+
+        mSearchView.setOnClickListener(new View.OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (mCallback != null) {
+                    mCallback.onSearchViewClicked();
+                }
+            }
+        });
+
+        mSearchView.addTextChangedListener(new TextWatcher() {
+            @Override
+            public void beforeTextChanged(CharSequence s, int start, int count, int after) {
+            }
+
+            @Override
+            public void onTextChanged(CharSequence s, int start, int before, int count) {
+                mClearButtonView.setVisibility(TextUtils.isEmpty(s) ? View.GONE : View.VISIBLE);
+            }
+
+            @Override
+            public void afterTextChanged(Editable s) {
+            }
+        });
+
+        findViewById(R.id.search_close_button).setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                mSearchView.setText(null);
+            }
+        });
+
+        findViewById(R.id.search_back_button).setOnClickListener(new OnClickListener() {
+            @Override
+            public void onClick(View v) {
+                if (mCallback != null) {
+                    mCallback.onBackButtonClicked();
+                }
+            }
+        });
+
+        super.onFinishInflate();
+    }
+
+    @Override
+    public boolean dispatchKeyEventPreIme(KeyEvent event) {
+        if (mPreImeKeyListener != null) {
+            if (mPreImeKeyListener.onKey(this, event.getKeyCode(), event)) {
+                return true;
+            }
+        }
+        return super.dispatchKeyEventPreIme(event);
+    }
+
+    public void fadeOut() {
+        fadeOut(null);
+    }
+
+    public void fadeOut(AnimUtils.AnimationCallback callback) {
+        AnimUtils.fadeOut(this, ANIMATION_DURATION, callback);
+        mIsFadedOut = true;
+    }
+
+    public void fadeIn() {
+        AnimUtils.fadeIn(this, ANIMATION_DURATION);
+        mIsFadedOut = false;
+    }
+
+    public void setVisible(boolean visible) {
+        if (visible) {
+            setAlpha(1);
+            setVisibility(View.VISIBLE);
+            mIsFadedOut = false;
+        } else {
+            setAlpha(0);
+            setVisibility(View.GONE);
+            mIsFadedOut = true;
+        }
+    }
+
+    public void expand(boolean requestFocus) {
+        updateVisibility(true /* isExpand */);
+        mExpanded.setVisibility(View.VISIBLE);
+        mExpanded.setAlpha(1);
+        setMargins(0f);
+        // Set 9-patch background. This owns the padding, so we need to restore the original values.
+        int paddingTop = this.getPaddingTop();
+        int paddingStart = this.getPaddingStart();
+        int paddingBottom = this.getPaddingBottom();
+        int paddingEnd = this.getPaddingEnd();
+        setBackgroundResource(R.drawable.search_shadow);
+        setElevation(0);
+        setPaddingRelative(paddingStart, paddingTop, paddingEnd, paddingBottom);
+
+        if (requestFocus) {
+            mSearchView.requestFocus();
+        }
+        mIsExpanded = true;
+    }
+
+    /**
+     * Updates the visibility of views depending on whether we will show the expanded or collapsed
+     * search view. This helps prevent some jank with the crossfading if we are animating.
+     *
+     * @param isExpand Whether we are about to show the expanded search box.
+     */
+    private void updateVisibility(boolean isExpand) {
+        int expandedViewVisibility = isExpand ? View.VISIBLE : View.GONE;
+
+        mBackButtonView.setVisibility(expandedViewVisibility);
+        if (TextUtils.isEmpty(mSearchView.getText())) {
+            mClearButtonView.setVisibility(View.GONE);
+        } else {
+            mClearButtonView.setVisibility(expandedViewVisibility);
+        }
+    }
+
+    public boolean isExpanded() {
+        return mIsExpanded;
+    }
+
+    /**
+     * Assigns margins to the search box as a fraction of its maximum margin size
+     *
+     * @param fraction How large the margins should be as a fraction of their full size
+     */
+    private void setMargins(float fraction) {
+        MarginLayoutParams params = (MarginLayoutParams) getLayoutParams();
+        params.topMargin = (int) (mTopMargin * fraction);
+        params.bottomMargin = (int) (mBottomMargin * fraction);
+        params.leftMargin = (int) (mLeftMargin * fraction);
+        params.rightMargin = (int) (mRightMargin * fraction);
+        requestLayout();
+    }
+
+    private void showInputMethod(View view) {
+        final InputMethodManager imm = (InputMethodManager) view.getContext().getSystemService(
+                Context.INPUT_METHOD_SERVICE);
+        if (imm != null) {
+            imm.showSoftInput(view, 0);
+        }
+    }
+
+    private void hideInputMethod(View view) {
+        final InputMethodManager imm = (InputMethodManager) view.getContext().getSystemService(
+                Context.INPUT_METHOD_SERVICE);
+        if (imm != null) {
+            imm.hideSoftInputFromWindow(view.getWindowToken(), 0);
+        }
+    }
+}
diff --git a/tests/src/com/android/contacts/tests/allintents/AllIntentsActivity.java b/tests/src/com/android/contacts/tests/allintents/AllIntentsActivity.java
index fcd3e8b..6514d23 100644
--- a/tests/src/com/android/contacts/tests/allintents/AllIntentsActivity.java
+++ b/tests/src/com/android/contacts/tests/allintents/AllIntentsActivity.java
@@ -47,7 +47,7 @@
 
 import com.android.contacts.tests.R;
 
-import com.google.common.collect.Lists;
+import java.util.ArrayList;
 
 /**
  * An activity that provides access to various modes of the contacts application.
@@ -631,6 +631,10 @@
         row2.put(Email.LABEL, "Green Bot");
         row2.put(Email.ADDRESS, "android@android.com");
 
-        intent.putParcelableArrayListExtra(Insert.DATA, Lists.newArrayList(row1, row2));
+        final ArrayList<ContentValues> rows = new ArrayList<>();
+        rows.add(row1);
+        rows.add(row2);
+
+        intent.putParcelableArrayListExtra(Insert.DATA, rows);
     }
 }
