diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index f4dcdf6..df65877 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -45,6 +45,7 @@
     <uses-permission android:name="com.android.voicemail.permission.READ_WRITE_ALL_VOICEMAIL" />
     <!-- allow broadcasting secret code intents that reboot the phone -->
     <uses-permission android:name="android.permission.REBOOT" />
+    <uses-permission android:name="android.permission.RECEIVE_BOOT_COMPLETED" />
 
     <application
         android:name="com.android.contacts.ContactsApplication"
diff --git a/res/drawable-hdpi/badge_action_call.png b/res/drawable-hdpi/badge_action_call.png
old mode 100755
new mode 100644
index 105f7d0..0b1c6b4
--- a/res/drawable-hdpi/badge_action_call.png
+++ b/res/drawable-hdpi/badge_action_call.png
Binary files differ
diff --git a/res/drawable-hdpi/badge_action_sms.png b/res/drawable-hdpi/badge_action_sms.png
old mode 100755
new mode 100644
index a7862f6..0dfdbf5
--- a/res/drawable-hdpi/badge_action_sms.png
+++ b/res/drawable-hdpi/badge_action_sms.png
Binary files differ
diff --git a/res/drawable-mdpi/badge_action_call.png b/res/drawable-mdpi/badge_action_call.png
index 3bc88a3..af2abaa 100644
--- a/res/drawable-mdpi/badge_action_call.png
+++ b/res/drawable-mdpi/badge_action_call.png
Binary files differ
diff --git a/res/drawable-mdpi/badge_action_sms.png b/res/drawable-mdpi/badge_action_sms.png
index bbcfb59..13dd8bc 100644
--- a/res/drawable-mdpi/badge_action_sms.png
+++ b/res/drawable-mdpi/badge_action_sms.png
Binary files differ
diff --git a/res/drawable-xhdpi/badge_action_call.png b/res/drawable-xhdpi/badge_action_call.png
index aa28018..2589e33 100644
--- a/res/drawable-xhdpi/badge_action_call.png
+++ b/res/drawable-xhdpi/badge_action_call.png
Binary files differ
diff --git a/res/drawable-xhdpi/badge_action_sms.png b/res/drawable-xhdpi/badge_action_sms.png
index 5e4cd82..460451f 100644
--- a/res/drawable-xhdpi/badge_action_sms.png
+++ b/res/drawable-xhdpi/badge_action_sms.png
Binary files differ
diff --git a/res/layout-sw580dp-w1000dp/contact_detail_list_item.xml b/res/layout-sw580dp-w1000dp/contact_detail_list_item.xml
index 0d94622..de6cd97 100644
--- a/res/layout-sw580dp-w1000dp/contact_detail_list_item.xml
+++ b/res/layout-sw580dp-w1000dp/contact_detail_list_item.xml
@@ -18,26 +18,26 @@
 -->
 
 <!-- Note: padding might be controlled programatically -->
-<LinearLayout
+<FrameLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:orientation="horizontal"
-    android:gravity="center_vertical"
-    android:minHeight="@dimen/detail_min_line_item_height">
+    android:paddingLeft="16dip">
 
-    <!-- Note: padding might be controlled programatically -->
-    <com.android.contacts.detail.PrimaryActionViewContainer
-        android:id="@+id/primary_action_view_container"
-        android:layout_width="0dip"
-        android:layout_weight="1"
+    <com.android.contacts.detail.ActionsViewContainer
+        android:id="@+id/actions_view_container"
+        android:layout_width="match_parent"
         android:layout_height="wrap_content"
+        android:minHeight="@dimen/detail_min_line_item_height"
+        android:gravity="center_vertical"
         android:orientation="horizontal"
-        android:layout_gravity="center_vertical"
         android:focusable="true"
-        android:background="?android:attr/selectableItemBackground">
+        android:background="?android:attr/selectableItemBackground"
+        android:nextFocusRight="@+id/secondary_action_view_container">
 
+        <!-- Note: padding might be controlled programatically -->
         <LinearLayout
+            android:id="@+id/primary_action_view"
             android:layout_width="wrap_content"
             android:layout_height="wrap_content"
             android:layout_gravity="center_vertical"
@@ -80,7 +80,7 @@
             android:id="@+id/type"
             style="@style/ContactDetailItemType"
             android:layout_width="wrap_content"
-            android:layout_height="match_parent"
+            android:layout_height="wrap_content"
             android:layout_gravity="center_vertical"
             android:paddingRight="16dip" />
 
@@ -92,33 +92,34 @@
             android:layout_gravity="center_vertical"
             android:background="@drawable/ic_menu_mark" />
 
-    </com.android.contacts.detail.PrimaryActionViewContainer>
 
-    <View
-        android:id="@+id/vertical_divider"
-        android:layout_width="1px"
-        android:layout_height="match_parent"
-        android:layout_marginTop="@dimen/detail_vertical_divider_vertical_margin"
-        android:layout_marginBottom="@dimen/detail_vertical_divider_vertical_margin"
-        android:background="?android:attr/dividerVertical" />
-
-    <!-- Note: padding might be controlled programatically -->
-    <FrameLayout
-        android:id="@+id/secondary_action_view_container"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"
-        android:paddingLeft="@dimen/detail_item_icon_margin"
-        android:paddingRight="@dimen/detail_item_icon_margin"
-        android:duplicateParentState="false"
-        android:focusable="true"
-        android:background="?android:attr/selectableItemBackground">
-        <ImageView
-            android:id="@+id/secondary_action_button"
-            android:layout_width="32dip"
+        <View
+            android:id="@+id/vertical_divider"
+            android:layout_width="1px"
             android:layout_height="match_parent"
-            android:layout_centerVertical="true"
-            android:gravity="center"
-            android:scaleType="center"
-            android:duplicateParentState="false" />
-    </FrameLayout>
-</LinearLayout>
+            android:layout_marginTop="@dimen/detail_vertical_divider_vertical_margin"
+            android:layout_marginBottom="@dimen/detail_vertical_divider_vertical_margin"
+            android:background="?android:attr/dividerVertical" />
+
+        <!-- Note: padding might be controlled programatically -->
+        <FrameLayout
+            android:id="@+id/secondary_action_view_container"
+            android:layout_width="wrap_content"
+            android:layout_height="match_parent"
+            android:paddingLeft="@dimen/detail_item_icon_margin"
+            android:paddingRight="@dimen/detail_item_icon_margin"
+            android:duplicateParentState="false"
+            android:focusable="true"
+            android:background="?android:attr/selectableItemBackground"
+            android:nextFocusLeft="@id/actions_view_container">
+            <ImageView
+                android:id="@+id/secondary_action_button"
+                android:layout_width="32dip"
+                android:layout_height="match_parent"
+                android:layout_centerVertical="true"
+                android:gravity="center"
+                android:scaleType="center"
+                android:duplicateParentState="false" />
+        </FrameLayout>
+    </com.android.contacts.detail.ActionsViewContainer>
+</FrameLayout>
diff --git a/res/layout/call_detail.xml b/res/layout/call_detail.xml
index a890ddf..13124f2 100644
--- a/res/layout/call_detail.xml
+++ b/res/layout/call_detail.xml
@@ -79,16 +79,6 @@
             android:background="@android:color/holo_blue_light"
             android:layout_below="@+id/contact_background_sizer"
         />
-        <LinearLayout
-            android:id="@+id/voicemail_container"
-            android:layout_width="match_parent"
-            android:layout_height="wrap_content"
-            android:paddingBottom="@dimen/call_detail_button_spacing"
-            android:layout_below="@id/blue_separator"
-            android:background="@android:color/black"
-        >
-            <!-- The voicemail fragment will be put here. -->
-        </LinearLayout>
         <View
             android:id="@+id/photo_text_bar"
             android:layout_width="match_parent"
@@ -132,6 +122,16 @@
             android:layout_alignBottom="@id/contact_background_sizer"
             android:background="?android:attr/selectableItemBackground"
         />
+        <LinearLayout
+            android:id="@+id/voicemail_container"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:paddingBottom="@dimen/call_detail_button_spacing"
+            android:layout_below="@id/blue_separator"
+            android:background="@android:color/black"
+        >
+            <!-- The voicemail fragment will be put here. -->
+        </LinearLayout>
         <FrameLayout android:id="@+id/call_and_sms_container"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
diff --git a/res/layout/contact_detail_list_item.xml b/res/layout/contact_detail_list_item.xml
index 99f027f..a410dc9 100644
--- a/res/layout/contact_detail_list_item.xml
+++ b/res/layout/contact_detail_list_item.xml
@@ -18,27 +18,25 @@
 -->
 
 <!-- Note: padding might be controlled programatically -->
-<LinearLayout
+<FrameLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:orientation="horizontal"
-    android:gravity="center_vertical"
-    android:paddingTop="8dip"
-    android:paddingBottom="8dip"
-    android:minHeight="@dimen/detail_min_line_item_height">
+    android:paddingLeft="16dip">
 
-    <!-- Note: padding might be controlled programatically -->
-    <com.android.contacts.detail.PrimaryActionViewContainer
-        android:id="@+id/primary_action_view_container"
-        android:layout_width="0dip"
-        android:layout_weight="1"
+    <com.android.contacts.detail.ActionsViewContainer
+        android:id="@+id/actions_view_container"
+        android:layout_width="match_parent"
         android:layout_height="wrap_content"
         android:orientation="horizontal"
         android:focusable="true"
-        android:background="?android:attr/selectableItemBackground">
+        android:background="?android:attr/selectableItemBackground"
+        android:nextFocusRight="@+id/secondary_action_view_container"
+        android:minHeight="@dimen/detail_min_line_item_height">
 
+        <!-- Note: padding might be controlled programatically -->
         <LinearLayout
+            android:id="@+id/primary_action_view"
             android:layout_width="0dip"
             android:layout_height="wrap_content"
             android:layout_weight="1"
@@ -93,30 +91,31 @@
                 android:visibility="gone" />
 
         </LinearLayout>
-    </com.android.contacts.detail.PrimaryActionViewContainer>
 
-    <View
-        android:id="@+id/vertical_divider"
-        android:layout_width="1dip"
-        android:layout_height="match_parent"
-        android:layout_marginTop="@dimen/detail_vertical_divider_vertical_margin"
-        android:layout_marginBottom="@dimen/detail_vertical_divider_vertical_margin"
-        android:background="?android:attr/dividerVertical" />
+        <View
+            android:id="@+id/vertical_divider"
+            android:layout_width="1dip"
+            android:layout_height="match_parent"
+            android:layout_marginTop="@dimen/detail_vertical_divider_vertical_margin"
+            android:layout_marginBottom="@dimen/detail_vertical_divider_vertical_margin"
+            android:background="?android:attr/dividerVertical" />
 
-    <!-- Note: padding might be controlled programatically -->
-    <FrameLayout
-        android:id="@+id/secondary_action_view_container"
-        android:layout_width="wrap_content"
-        android:layout_height="match_parent"
-        android:paddingLeft="@dimen/detail_item_icon_margin"
-        android:paddingRight="@dimen/detail_item_icon_margin"
-        android:focusable="true"
-        android:background="?android:attr/selectableItemBackground">
-        <ImageView
-            android:id="@+id/secondary_action_button"
-            android:layout_width="32dip"
-            android:layout_height="32dip"
-            android:layout_gravity="center_vertical"
-            android:duplicateParentState="false" />
-    </FrameLayout>
-</LinearLayout>
+        <!-- Note: padding might be controlled programatically -->
+        <FrameLayout
+            android:id="@+id/secondary_action_view_container"
+            android:layout_width="wrap_content"
+            android:layout_height="match_parent"
+            android:paddingLeft="@dimen/detail_item_icon_margin"
+            android:paddingRight="@dimen/detail_item_icon_margin"
+            android:focusable="true"
+            android:background="?android:attr/selectableItemBackground"
+            android:nextFocusLeft="@id/actions_view_container">
+            <ImageView
+                android:id="@+id/secondary_action_button"
+                android:layout_width="32dip"
+                android:layout_height="32dip"
+                android:layout_gravity="center_vertical"
+                android:duplicateParentState="false" />
+        </FrameLayout>
+    </com.android.contacts.detail.ActionsViewContainer>
+</FrameLayout>
diff --git a/res/layout/contact_tile_frequent_phone.xml b/res/layout/contact_tile_frequent_phone.xml
index 26c221c..dffdfc7 100644
--- a/res/layout/contact_tile_frequent_phone.xml
+++ b/res/layout/contact_tile_frequent_phone.xml
@@ -55,31 +55,38 @@
             android:fadingEdgeLength="3dip"
             android:ellipsize="marquee" />
 
-        <TextView
-            android:id="@+id/contact_tile_phone_number"
-            android:layout_width="wrap_content"
+        <LinearLayout
+            android:orientation="horizontal"
             android:layout_height="wrap_content"
-            android:textSize="14sp"
-            android:textColor="@color/dialtacts_secondary_text_color"
-            android:layout_marginLeft="8dip"
-            android:singleLine="true"
-            android:maxLength="18"
+            android:layout_width="match_parent"
+            android:layout_below="@id/contact_tile_name"
             android:layout_toRightOf="@id/image_container"
-            android:layout_below="@id/contact_tile_name" />
+            android:gravity="center_vertical">
 
-        <TextView
-            android:id="@+id/contact_tile_phone_type"
-            android:layout_width="wrap_content"
-            android:layout_height="wrap_content"
-            android:textSize="14sp"
-            android:ellipsize="end"
-            android:singleLine="true"
-            android:textAllCaps="true"
-            android:textColor="@color/dialtacts_secondary_text_color"
-            android:layout_marginLeft="12dip"
-            android:maxLength="8"
-            android:layout_alignParentRight="true"
-            android:layout_alignTop="@id/contact_tile_phone_number" />
+            <TextView
+                android:id="@+id/contact_tile_phone_number"
+                android:layout_width="0dip"
+                android:layout_height="wrap_content"
+                android:layout_weight="5"
+                android:textSize="14sp"
+                android:textColor="@color/dialtacts_secondary_text_color"
+                android:layout_marginLeft="8dip"
+                android:singleLine="true"/>
+
+            <TextView
+                android:id="@+id/contact_tile_phone_type"
+                android:layout_width="0dip"
+                android:layout_height="wrap_content"
+                android:layout_weight="3"
+                android:textSize="12sp"
+                android:ellipsize="end"
+                android:singleLine="true"
+                android:textAllCaps="true"
+                android:textColor="@color/dialtacts_secondary_text_color"
+                android:layout_marginLeft="8dip"
+                android:gravity="right" />
+
+        </LinearLayout>
 
         <View
             android:id="@+id/contact_tile_horizontal_divider"
diff --git a/res/layout/editor_account_header.xml b/res/layout/editor_account_header.xml
index ff33cf1..6dd55fd 100644
--- a/res/layout/editor_account_header.xml
+++ b/res/layout/editor_account_header.xml
@@ -38,18 +38,20 @@
 
         <TextView
             android:id="@+id/account_type"
-            android:layout_width="wrap_content"
+            android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:textAppearance="?android:attr/textAppearanceMedium"
-            android:singleLine="true" />
+            android:singleLine="true"
+            android:ellipsize="end" />
 
         <TextView
              android:id="@+id/account_name"
-             android:layout_width="wrap_content"
+             android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:textAppearance="?android:attr/textAppearanceSmall"
              android:textColor="?android:attr/textColorTertiary"
-             android:singleLine="true" />
+             android:singleLine="true"
+             android:ellipsize="end" />
 
     </LinearLayout>
 
diff --git a/res/layout/editor_account_header_with_dropdown.xml b/res/layout/editor_account_header_with_dropdown.xml
index 001eaae..12c2a84 100644
--- a/res/layout/editor_account_header_with_dropdown.xml
+++ b/res/layout/editor_account_header_with_dropdown.xml
@@ -29,37 +29,35 @@
     <LinearLayout
         android:id="@+id/account"
         android:layout_height="wrap_content"
-        android:layout_width="wrap_content"
+        android:layout_width="0dip"
+        android:layout_weight="1"
         android:orientation="vertical"
         style="?android:attr/spinnerStyle">
 
         <TextView
             android:id="@+id/account_type"
-            android:layout_width="wrap_content"
+            android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:textAppearance="?android:attr/textAppearanceMedium"
-            android:singleLine="true" />
+            android:singleLine="true"
+            android:ellipsize="end" />
 
         <TextView
              android:id="@+id/account_name"
-             android:layout_width="wrap_content"
+             android:layout_width="match_parent"
              android:layout_height="wrap_content"
              android:paddingRight="8dip"
              android:textAppearance="?android:attr/textAppearanceSmall"
              android:textColor="?android:attr/textColorTertiary"
-             android:singleLine="true" />
+             android:singleLine="true"
+             android:ellipsize="end" />
 
     </LinearLayout>
 
-    <!-- Spacer between the account type / name dropdown and the account icon -->
-    <View
-        android:layout_width="0dip"
-        android:layout_height="match_parent"
-        android:layout_weight="1"/>
-
     <FrameLayout
         android:layout_width="wrap_content"
-        android:layout_height="match_parent">
+        android:layout_height="match_parent"
+        android:layout_marginLeft="10dip">
 
         <ImageView
              android:id="@+id/account_icon"
diff --git a/res/layout/quickcontact_list_item.xml b/res/layout/quickcontact_list_item.xml
index 7929718..c018eea 100755
--- a/res/layout/quickcontact_list_item.xml
+++ b/res/layout/quickcontact_list_item.xml
@@ -16,22 +16,23 @@
 
 <LinearLayout
     xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/actions_view_container"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
+    android:minHeight="?android:attr/listPreferredItemHeight"
     android:orientation="horizontal"
-    android:background="@drawable/quickcontact_list_item_background"
-    android:gravity="center_vertical">
+    android:gravity="center_vertical"
+    android:background="?android:attr/selectableItemBackground"
+    android:nextFocusRight="@+id/secondary_action_button">
     <LinearLayout
-        android:id="@+id/primary_action_view_container"
         android:layout_width="0dip"
         android:layout_height="wrap_content"
-        android:minHeight="?android:attr/listPreferredItemHeight"
         android:layout_weight="1"
-        android:orientation="vertical"
         android:paddingLeft="16dip"
         android:paddingRight="16dip"
         android:gravity="center_vertical"
-        android:background="?android:attr/selectableItemBackground">
+        android:orientation="vertical"
+    >
         <TextView
             android:id="@android:id/text1"
             android:layout_width="wrap_content"
@@ -61,5 +62,6 @@
         android:paddingLeft="@dimen/detail_item_icon_margin"
         android:paddingRight="@dimen/detail_item_icon_margin"
         android:background="?android:attr/selectableItemBackground"
-        android:duplicateParentState="false" />
+        android:duplicateParentState="false"
+        android:nextFocusLeft="@id/actions_view_container" />
 </LinearLayout>
diff --git a/res/layout/external_raw_contact_editor_view.xml b/res/layout/raw_contact_readonly_editor_view.xml
similarity index 94%
rename from res/layout/external_raw_contact_editor_view.xml
rename to res/layout/raw_contact_readonly_editor_view.xml
index f1ba198..b34028a 100644
--- a/res/layout/external_raw_contact_editor_view.xml
+++ b/res/layout/raw_contact_readonly_editor_view.xml
@@ -14,8 +14,7 @@
      limitations under the License.
 -->
 
-<!-- placed inside act_edit as tabcontent -->
-<com.android.contacts.editor.ExternalRawContactEditorView
+<com.android.contacts.editor.RawContactReadOnlyEditorView
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
@@ -77,4 +76,4 @@
         android:layout_height="wrap_content"
         android:orientation="vertical"/>
 
-</com.android.contacts.editor.ExternalRawContactEditorView>
+</com.android.contacts.editor.RawContactReadOnlyEditorView>
diff --git a/res/layout/select_dialog_item.xml b/res/layout/select_dialog_item.xml
index ea671dd..d49ae10 100644
--- a/res/layout/select_dialog_item.xml
+++ b/res/layout/select_dialog_item.xml
@@ -23,7 +23,7 @@
     android:id="@android:id/text1"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:minHeight="48dip"
+    android:minHeight="?android:attr/listPreferredItemHeightSmall"
     android:textAppearance="?android:attr/textAppearanceMedium"
     android:textColor="?android:attr/textColorAlertDialogListItem"
     android:gravity="center_vertical"
diff --git a/res/layout/user_profile_header.xml b/res/layout/user_profile_header.xml
index ff01a11..6867dea 100644
--- a/res/layout/user_profile_header.xml
+++ b/res/layout/user_profile_header.xml
@@ -40,6 +40,7 @@
             android:ellipsize="end"
             android:gravity="left|center_vertical"
             android:layout_weight="1"
+            android:textAllCaps="true"
             android:textAppearance="?android:attr/textAppearanceSmall"
             android:paddingLeft="?attr/list_item_text_indent"
             android:textColor="@color/people_app_theme_color" />
@@ -52,7 +53,7 @@
             android:ellipsize="end"
             android:layout_gravity="right|center_vertical"
             android:textAppearance="?android:attr/textAppearanceSmall"
-            android:textSize="12dip"
+            android:textSize="12sp"
             android:textColor="@color/contact_count_text_color" />
     </LinearLayout>
 
diff --git a/res/values-af/strings.xml b/res/values-af/strings.xml
index bd87364..cd2dd8c 100644
--- a/res/values-af/strings.xml
+++ b/res/values-af/strings.xml
@@ -17,52 +17,33 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="launcherDialer" msgid="8636288196618486553">"Foon"</string>
-    <!-- no translation found for people (1048457247435785074) -->
-    <skip />
-    <!-- no translation found for contactsList (8661624236494819731) -->
-    <skip />
-    <!-- no translation found for shortcutContact (749243779392912958) -->
-    <skip />
+    <string name="people" msgid="1048457247435785074">"Mense"</string>
+    <string name="contactsList" msgid="8661624236494819731">"Kontakte"</string>
+    <string name="shortcutContact" msgid="749243779392912958">"Kontak"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Direk skakel"</string>
     <string name="shortcutMessageContact" msgid="2460337253595976198">"Direkte boodskap"</string>
     <string name="shortcutActivityTitle" msgid="6642877210643565436">"Kies \'n kontakkortpad"</string>
     <string name="callShortcutActivityTitle" msgid="6065749861423648991">"Kies \'n nommer om te bel"</string>
     <string name="messageShortcutActivityTitle" msgid="3084542316620335911">"Kies \'n nommer om te stuur"</string>
     <string name="contactPickerActivityTitle" msgid="6886592363525235031">"Kies \'n kontak"</string>
-    <!-- no translation found for starredList (4817256136413959463) -->
-    <skip />
-    <!-- no translation found for frequentList (7154768136473953056) -->
-    <skip />
-    <!-- no translation found for strequentList (5640192862059373511) -->
-    <skip />
-    <!-- no translation found for viewContactTitle (7989394521836644384) -->
-    <skip />
-    <!-- no translation found for viewContactDesription (214186610887547860) -->
-    <skip />
-    <!-- no translation found for editContactDescription (2947202828256214947) -->
-    <skip />
-    <!-- no translation found for insertContactDescription (4709878105452681987) -->
-    <skip />
-    <!-- no translation found for editGroupDescription (6321161304201540561) -->
-    <skip />
-    <!-- no translation found for insertGroupDescription (5658512271662210139) -->
-    <skip />
-    <!-- no translation found for contactDetailAbout (5430408883907061400) -->
-    <skip />
-    <!-- no translation found for contactDetailUpdates (3780588624763446941) -->
-    <skip />
-    <!-- no translation found for searchHint (8482945356247760701) -->
-    <skip />
+    <string name="starredList" msgid="4817256136413959463">"Gester"</string>
+    <string name="frequentList" msgid="7154768136473953056">"Gereeld"</string>
+    <string name="strequentList" msgid="5640192862059373511">"Gunstelinge"</string>
+    <string name="viewContactTitle" msgid="7989394521836644384">"Kontakbesonderhede"</string>
+    <string name="viewContactDesription" msgid="214186610887547860">"Bekyk kontak"</string>
+    <string name="editContactDescription" msgid="2947202828256214947">"Redigeer kontak"</string>
+    <string name="insertContactDescription" msgid="4709878105452681987">"Skep kontak"</string>
+    <string name="editGroupDescription" msgid="6321161304201540561">"Redigeer groep"</string>
+    <string name="insertGroupDescription" msgid="5658512271662210139">"Skep groep"</string>
+    <string name="contactDetailAbout" msgid="5430408883907061400">"Meer oor"</string>
+    <string name="contactDetailUpdates" msgid="3780588624763446941">"Opdaterings"</string>
+    <string name="searchHint" msgid="8482945356247760701">"Deursoek kontakte"</string>
     <string name="menu_search" msgid="9147752853603483719">"Soek"</string>
-    <!-- no translation found for menu_newContact (1209922412763274638) -->
-    <skip />
-    <!-- no translation found for menu_viewContact (2795575601596468581) -->
-    <skip />
+    <string name="menu_newContact" msgid="1209922412763274638">"Nuwe kontak"</string>
+    <string name="menu_viewContact" msgid="2795575601596468581">"Bekyk kontak"</string>
     <string name="menu_callNumber" msgid="5142851348489387516">"Bel <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for menu_addStar (2908478235715404876) -->
-    <skip />
-    <!-- no translation found for menu_removeStar (5844227078364227030) -->
-    <skip />
+    <string name="menu_addStar" msgid="2908478235715404876">"Voeg by gunstelinge"</string>
+    <string name="menu_removeStar" msgid="5844227078364227030">"Verwyder van gunstelinge"</string>
     <string name="menu_editContact" msgid="9042415603857662633">"Redigeer"</string>
     <string name="menu_deleteContact" msgid="6788644058868189393">"Vee uit"</string>
     <string name="menu_call" msgid="3992595586042260618">"Bel kontak"</string>
@@ -71,8 +52,7 @@
     <string name="menu_editGroup" msgid="5062005185370983720">"Redigeer"</string>
     <string name="menu_deleteGroup" msgid="3486380004411482874">"Vee uit"</string>
     <string name="menu_new_contact_action_bar" msgid="8887818026717394343">"Nuut"</string>
-    <!-- no translation found for menu_new_group_action_bar (5055346725617932394) -->
-    <skip />
+    <string name="menu_new_group_action_bar" msgid="5055346725617932394">"Nuut"</string>
     <string name="splitConfirmation_title" msgid="2209511048593467012">"Skei kontak"</string>
     <string name="splitConfirmation" msgid="1067993957986345974">"Is jy seker jy wil hierdie enkele kontak  skei in verskeie kontakte?"</string>
     <string name="menu_joinAggregate" msgid="5027981918265667970">"Voeg saam"</string>
@@ -82,81 +62,61 @@
     <string name="separatorJoinAggregateSuggestions" msgid="2831414448851313345">"Voorgestelde kontakte"</string>
     <string name="separatorJoinAggregateAll" msgid="7939932265026181043">"Alle kontakte"</string>
     <string name="contactsJoinedMessage" msgid="7208148163607047389">"Kontakte saamgevoeg"</string>
-    <!-- no translation found for deleteConfirmation_title (6394309508930335204) -->
-    <skip />
-    <!-- no translation found for menu_set_ring_tone (8728345772068064946) -->
-    <skip />
+    <string name="deleteConfirmation_title" msgid="6394309508930335204">"Vee uit"</string>
+    <string name="menu_set_ring_tone" msgid="8728345772068064946">"Stel luitoon op"</string>
     <string name="menu_redirect_calls_to_vm" msgid="4181789196416396656">"Alle oproepe na stempos"</string>
     <string name="readOnlyContactWarning" msgid="1390849295342594265">"Jy kan nie kontakte uit leesalleen-rekeninge uitvee nie, maar jy kan hulle wel in jou kontaklyste versteek."</string>
     <string name="readOnlyContactDeleteConfirmation" msgid="2137170726670196909">"Hierdie kontak bevat inligting uit meerdere rekeninge. Inligting uit leesalleen-rekeninge sal in jou kontaklyste versteek word, nie verwyder word nie."</string>
     <string name="multipleContactDeleteConfirmation" msgid="938900978442960800">"As jy hierdie kontak uitvee, sal dit inligting uit meerdere rekeninge uitvee."</string>
-    <!-- no translation found for deleteConfirmation (811706994761610640) -->
-    <skip />
+    <string name="deleteConfirmation" msgid="811706994761610640">"Hierdie kontak sal uitgevee word."</string>
     <string name="menu_done" msgid="796017761764190697">"Klaar"</string>
     <string name="menu_doNotSave" msgid="58593876893538465">"Kanselleer"</string>
-    <!-- no translation found for menu_discard (6456087569315685632) -->
-    <skip />
-    <!-- no translation found for label_notes (8337354953278341042) -->
-    <skip />
+    <string name="menu_discard" msgid="6456087569315685632">"Gooi weg"</string>
+    <string name="label_notes" msgid="8337354953278341042">"Notas"</string>
     <string name="label_sip_address" msgid="124073911714324974">"Internetoproep"</string>
-    <!-- no translation found for ghostData_company (5414421120553765775) -->
-    <skip />
+    <string name="ghostData_company" msgid="5414421120553765775">"Maatskappy"</string>
     <string name="ghostData_title" msgid="7496735200318496110">"Titel"</string>
-    <!-- no translation found for invalidContactMessage (5816991830260044593) -->
-    <skip />
-    <!-- no translation found for pickerNewContactHeader (7750705279843568147) -->
-    <skip />
-    <!-- no translation found for phoneLabelsGroup (6468091477851199285) -->
-    <skip />
-    <!-- no translation found for emailLabelsGroup (8389931313045344406) -->
-    <skip />
-    <!-- no translation found for imLabelsGroup (3898238486262614027) -->
-    <skip />
+    <string name="invalidContactMessage" msgid="5816991830260044593">"Die kontak bestaan nie."</string>
+    <string name="pickerNewContactHeader" msgid="7750705279843568147">"Skep nuwe kontak"</string>
+    <string name="phoneLabelsGroup" msgid="6468091477851199285">"Foon"</string>
+    <string name="emailLabelsGroup" msgid="8389931313045344406">"E-pos"</string>
+    <string name="imLabelsGroup" msgid="3898238486262614027">"IM"</string>
     <string name="postalLabelsGroup" msgid="3487738141112589324">"Adres"</string>
   <string-array name="otherLabels">
     <item msgid="8287841928119937597">"Organisasie"</item>
     <item msgid="7196592230748086755">"Let wel"</item>
   </string-array>
     <string name="photoPickerNotFoundText" product="tablet" msgid="6247290728908599701">"Geen prente is op die tablet beskikbaar nie."</string>
-    <!-- outdated translation 6247290728908599701 -->     <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Geen prente is op die tablet beskikbaar nie."</string>
+    <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Geen prente is beskikbaar op die foon nie."</string>
     <string name="attach_photo_dialog_title" msgid="5599827035558557169">"Kontak se foto"</string>
     <string name="customLabelPickerTitle" msgid="1081475101983255212">"Gepasmaakte etiketnaam"</string>
     <string name="send_to_voicemail_checkbox" msgid="9001686764070676353">"Stuur oproepe direk na stemboodskap"</string>
     <string name="removePhoto" msgid="4898105274130284565">"Verwyder foto"</string>
-    <!-- no translation found for noContacts (4955659076981974652) -->
-    <skip />
-    <!-- no translation found for noGroups (7315200974181864731) -->
-    <skip />
-    <!-- no translation found for noAccounts (4742609114153797268) -->
-    <skip />
+    <string name="noContacts" msgid="4955659076981974652">"Geen kontakte"</string>
+    <string name="noGroups" msgid="7315200974181864731">"Geen groepe nie"</string>
+    <string name="noAccounts" msgid="4742609114153797268">"Jy het \'n rekening nodig om groepe te skep"</string>
     <string name="noMatchingContacts" msgid="4266283206853990471">"Geen passende kontakte gevind nie."</string>
-    <!-- no translation found for noContactsWithPhoneNumbers (1605457050218824269) -->
-    <skip />
+    <string name="noContactsWithPhoneNumbers" msgid="1605457050218824269">"Geen kontakte met foonnommers nie."</string>
     <string name="savingContact" msgid="4075751076741924939">"Stoor tans kontak..."</string>
     <string name="savingDisplayGroups" msgid="2133152192716475939">"Stoor tans vertoonopsies..."</string>
     <string name="contactSavedToast" msgid="9171862279493213075">"Kontak gestoor"</string>
     <string name="contactSavedErrorToast" msgid="9189098776225004666">"Fout, kan nie kontakwysigings stoor nie."</string>
     <string name="groupSavedToast" msgid="6675062559302493011">"Groep gestoor"</string>
-    <!-- no translation found for groupSavedErrorToast (6434135707953150875) -->
-    <skip />
+    <string name="groupSavedErrorToast" msgid="6434135707953150875">"Fout, kan nie groepveranderings stoor nie."</string>
   <plurals name="listTotalPhoneContacts">
     <item quantity="one" msgid="3015357862286673986">"1 kontak met foonnommer"</item>
     <item quantity="other" msgid="3299954047880968205">"<xliff:g id="COUNT">%d</xliff:g> kontakte met foonnommers"</item>
   </plurals>
-    <!-- outdated translation 2756295259674938869 -->     <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"Geen sigbare kontakte met foonnommers nie"</string>
+    <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"Geen kontakte met foonnommers nie"</string>
   <plurals name="listTotalAllContacts">
     <item quantity="one" msgid="3405747744700823280">"1 kontak"</item>
     <item quantity="other" msgid="3578469907265375314">"<xliff:g id="COUNT">%d</xliff:g> kontakte"</item>
   </plurals>
-    <!-- outdated translation 6811347506748072822 -->     <string name="listTotalAllContactsZero" msgid="1889349925514589304">"Geen sigbare kontakte nie"</string>
-    <!-- no translation found for listTotalAllContactsZeroCustom (4058252141420128998) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroStarred (1289318488170099285) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroGroup (5448979458248027615) -->
-    <skip />
-    <!-- no translation found for listAllContactsInAccount (7496143179265311758) -->
-    <skip />
+    <string name="listTotalAllContactsZero" msgid="1889349925514589304">"Geen kontakte nie"</string>
+    <string name="listTotalAllContactsZeroCustom" msgid="4058252141420128998">"Geen sigbare kontakte nie"</string>
+    <string name="listTotalAllContactsZeroStarred" msgid="1289318488170099285">"Geen gunstelinge nie"</string>
+    <string name="listTotalAllContactsZeroGroup" msgid="5448979458248027615">"Geen kontakte in <xliff:g id="NAME">%s</xliff:g> nie"</string>
+    <string name="listAllContactsInAccount" msgid="7496143179265311758">"Kontakte in <xliff:g id="NAME">%s</xliff:g>"</string>
     <string name="listSingleContact" msgid="6067813698903535563">"Enigste kontak"</string>
     <string name="listCustomView" msgid="6950713892532194050">"Kontakte in gepasmaakte aansig"</string>
   <plurals name="listFoundAllContacts">
@@ -169,53 +129,36 @@
     <item quantity="one" msgid="4826918429708286628">"1 gevind"</item>
     <item quantity="other" msgid="7988132539476575389">"<xliff:g id="COUNT">%d</xliff:g> gevind"</item>
   </plurals>
-    <!-- no translation found for contactsAllLabel (6178225597569649305) -->
-    <skip />
-    <!-- no translation found for contactsGroupsLabel (2841971472518003524) -->
-    <skip />
-    <!-- no translation found for contactsFavoritesLabel (8417039765586853670) -->
-    <skip />
+    <string name="contactsAllLabel" msgid="6178225597569649305">"Alle"</string>
+    <string name="contactsGroupsLabel" msgid="2841971472518003524">"Groepe"</string>
+    <string name="contactsFavoritesLabel" msgid="8417039765586853670">"Gunstelinge"</string>
     <string name="dialerIconLabel" msgid="6500826552823403796">"Foon"</string>
-    <!-- no translation found for recentCallsIconLabel (1419116422359067949) -->
-    <skip />
+    <string name="recentCallsIconLabel" msgid="1419116422359067949">"Oproeprekord"</string>
     <string name="liveFolderAll" msgid="4789010460767506206">"Alle kontakte"</string>
     <string name="liveFolderFavorites" msgid="3100957542927222282">"Gesterde kontakte"</string>
     <string name="liveFolderPhone" msgid="3739376066610926780">"Kontakte met foonnommers"</string>
     <string name="menu_sendTextMessage" msgid="6937343460284499306">"Stuur teksboodskap"</string>
     <string name="recentCalls_callNumber" msgid="1756372533999226126">"Bel <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for recentCalls_editNumberBeforeCall (7756171675833267857) -->
-    <skip />
-    <!-- no translation found for recentCalls_addToContact (1429899535546487008) -->
-    <skip />
-    <!-- no translation found for recentCalls_removeFromRecentList (401662244636511330) -->
-    <skip />
-    <!-- no translation found for recentCalls_deleteAll (6352364392762163704) -->
-    <skip />
+    <string name="recentCalls_editNumberBeforeCall" msgid="7756171675833267857">"Redigeer nommer voor oproep"</string>
+    <string name="recentCalls_addToContact" msgid="1429899535546487008">"Voeg by kontakte"</string>
+    <string name="recentCalls_removeFromRecentList" msgid="401662244636511330">"Verwyder uit oproeprekord"</string>
+    <string name="recentCalls_deleteAll" msgid="6352364392762163704">"Maak oproeprekord skoon"</string>
     <string name="recentCalls_trashVoicemail" msgid="7604696960787435655">"Vee stemboodskap uit"</string>
     <string name="recentCalls_shareVoicemail" msgid="1416112847592942840">"Deel stemboodskap"</string>
-    <!-- no translation found for recentCalls_empty (247053222448663107) -->
-    <skip />
+    <string name="recentCalls_empty" msgid="247053222448663107">"Oproeprekord is leeg."</string>
     <string name="clearCallLogConfirmation_title" msgid="718072843006222703">"Vee oproeprekord uit"</string>
     <string name="clearCallLogConfirmation" msgid="7625927669136267636">"Is jy seker jy wil die oproeprekord uitvee?"</string>
-    <!-- no translation found for clearCallLogProgress_title (6870412675015656948) -->
-    <skip />
-    <!-- no translation found for imei (3045126336951684285) -->
-    <skip />
+    <string name="clearCallLogProgress_title" msgid="6870412675015656948">"Vee oproeprekord uit"</string>
+    <string name="imei" msgid="3045126336951684285">"IMEI"</string>
     <string name="meid" msgid="6210568493746275750">"MEID"</string>
-    <!-- no translation found for voicemail (3851469869202611441) -->
-    <skip />
-    <!-- no translation found for unknown (740067747858270469) -->
-    <skip />
-    <!-- no translation found for private_num (6374339738119166953) -->
-    <skip />
+    <string name="voicemail" msgid="3851469869202611441">"Stemboodskap"</string>
+    <string name="unknown" msgid="740067747858270469">"Onbekend"</string>
+    <string name="private_num" msgid="6374339738119166953">"Private nommer"</string>
     <string name="payphone" msgid="4864313342828942922">"Betaalfoon"</string>
-    <!-- no translation found for dialerKeyboardHintText (5401660096579787344) -->
-    <skip />
+    <string name="dialerKeyboardHintText" msgid="5401660096579787344">"Gebruik sleutelbord om te skakel"</string>
     <string name="dialerDialpadHintText" msgid="5824490365898349041">"Skakel om \'n oproep by te voeg"</string>
-    <!-- no translation found for simContacts_emptyLoading (6700035985448642408) -->
-    <skip />
-    <!-- no translation found for simContacts_title (27341688347689769) -->
-    <skip />
+    <string name="simContacts_emptyLoading" msgid="6700035985448642408">"Laai tans van SIM-kaart af…"</string>
+    <string name="simContacts_title" msgid="27341688347689769">"SIM-kaartkontakte"</string>
     <string name="noContactsHelpTextWithSyncForCreateShortcut" msgid="801504710275614594">"Jy het geen kontakte om te wys nie. (As jy sopas \'n rekening bygevoeg het, kan dit \'n rukkie neem om kontakte te sinkroniseer.)"</string>
     <string name="noContactsHelpTextForCreateShortcut" msgid="3081286388667108335">"Jy het geen kontakte om te wys nie."</string>
     <string name="noContactsHelpText" product="tablet" msgid="6450346791169710787">"Jy het nie enige kontakte om te wys nie."\n\n"Om kontakte by te voeg, druk "<font fgcolor="#ffffffff"><b>"Kieslys"</b></font>" en raak:"\n" "\n<li><font fgcolor="#ffffffff"><b>"Rekeninge"</b></font>" om \'n rekening met kontakte by te voeg of op te stel wat jy met die tablet kan sinkroniseer"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Nuwe kontak"</b></font>" om \'n nuwe kontak van meet af te skep"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Invoer/uitvoer"</b></font>" om kontakte van jou SD-kaart in te voer"\n</li></string>
@@ -238,8 +181,7 @@
     <string name="type_incoming" msgid="6502076603836088532">"Inkomende oproep"</string>
     <string name="type_outgoing" msgid="343108709599392641">"Uitgaande oproep"</string>
     <string name="type_missed" msgid="2720502601640509542">"Gemiste oproep"</string>
-    <!-- no translation found for type_voicemail (5153139450668549908) -->
-    <skip />
+    <string name="type_voicemail" msgid="5153139450668549908">"Stemboodskap"</string>
     <string name="actionIncomingCall" msgid="6028930669817038600">"Inkomende oproepe"</string>
     <string name="callBack" msgid="5498224409038809224">"Bel terug"</string>
     <string name="callAgain" msgid="3197312117049874778">"Bel weer"</string>
@@ -262,30 +204,27 @@
     <string name="description_image_button_zero" msgid="4133108949401820710">"nul"</string>
     <string name="description_image_button_pound" msgid="3039765597595889230">"huts"</string>
     <string name="description_voicemail_button" msgid="3402506823655455591">"stemboodskap"</string>
-    <!-- no translation found for description_search_button (3660807558587384889) -->
-    <skip />
+    <string name="description_search_button" msgid="3660807558587384889">"soek"</string>
     <string name="description_dial_button" msgid="1274091017188142646">"bel"</string>
     <string name="description_delete_button" msgid="6263102114033407382">"terugvee"</string>
     <string name="description_digits_edittext" msgid="8760207516497016437">"nommer om te skakel"</string>
     <string name="description_contact_photo" msgid="3387458082667894062">"kontakfoto"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
-    <!-- outdated translation 5362631473262100989 -->     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"USB-berging nie beskikbaar nie"</string>
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Bekyk kontak"</string>
+    <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Berging nie beskikbaar nie"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Geen SD-kaart nie"</string>
-    <!-- outdated translation 8045830739790534254 -->     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Geen USB-berging bespeur nie"</string>
+    <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Geen bergingstoestelle bespeur nie"</string>
     <string name="no_sdcard_message" product="default" msgid="6019391476490445358">"Geen SD-kaart bespeur nie"</string>
     <string name="searching_vcard_title" msgid="4970508055399376813">"Soek vir vCard"</string>
     <string name="import_from_sim" msgid="3859272228033941659">"Voer in van SIM-kaart"</string>
-    <!-- outdated translation 8294728696808674154 -->     <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"Voer in uit USB-berging"</string>
-    <!-- outdated translation 7201274701382901259 -->     <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"Voer uit na USB-berging"</string>
+    <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"Voer in uit berging"</string>
+    <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"Voer uit na berging"</string>
     <string name="share_visible_contacts" msgid="890150378880783797">"Deel sigbare kontakte"</string>
     <string name="import_one_vcard_string" msgid="9059163467020328433">"Voer een vCard-lêer in"</string>
     <string name="import_multiple_vcard_string" msgid="3810226492811062392">"Voer meerdere vCard-lêers in"</string>
     <string name="import_all_vcard_string" msgid="5518136113853448474">"Voer alle vCard-lêers in"</string>
-    <!-- outdated translation 8214795338181412751 -->     <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"Soek vir vCard-data in USB-berging"</string>
+    <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"Soek vir vCard-data in berging"</string>
     <string name="searching_vcard_message" product="default" msgid="6917522333561434546">"Soek vir vCard-data op SD-kaart"</string>
     <string name="scanning_sdcard_failed_title" product="nosdcard" msgid="4944932641334764942">"Kon berging nie skandeer nie."</string>
     <string name="scanning_sdcard_failed_title" product="default" msgid="6664940444476572612">"Kon nie SD-kaart skandeer nie"</string>
@@ -296,7 +235,7 @@
     <string name="fail_reason_vcard_parse_error" msgid="4492947335972369711">"Kon nie vCard ontleed nie weens onverwagte redes."</string>
     <string name="fail_reason_not_supported" msgid="294499264620201243">"Die formaat word nie ondersteun nie."</string>
     <string name="vcard_import_failed" msgid="8856125211629574066">"Kon nie vCard invoer nie."</string>
-    <!-- outdated translation 1730986357514922756 -->     <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"Geen vCard-lêer op die SD-kaart gevind nie"</string>
+    <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"Geen vCard-lêer in die berging gevind nie"</string>
     <string name="import_failure_no_vcard_file" product="default" msgid="1730986357514922756">"Geen vCard-lêer op die SD-kaart gevind nie"</string>
     <string name="fail_reason_failed_to_collect_vcard_meta_info" msgid="6427931733267328564">"Kon nie meta-inligting van gegewe vCard-lêer(s) versamel nie."</string>
     <string name="fail_reason_failed_to_read_files" msgid="5823434810622484922">"Een of meer lêers kon nie ingevoer word nie (%s)."</string>
@@ -322,7 +261,7 @@
     <string name="exporting_contact_failed_title" msgid="2339788270863991417">"Kon nie kontakdata uitvoer nie"</string>
     <string name="exporting_contact_failed_message" msgid="2704925031146288635">"Kon nie kontakdata uitvoer nie."\n"Rede: \"<xliff:g id="FAIL_REASON">%s</xliff:g>\""</string>
     <string name="fail_reason_no_exportable_contact" msgid="4919714086648344495">"Daar is geen uitvoerbare kontak nie"</string>
-    <!-- outdated translation 2638638826954895225 -->     <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"Te veel vCard-lêers in die USB-berging"</string>
+    <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"Te veel vCard-lêers in die berging"</string>
     <string name="fail_reason_too_many_vcard" product="default" msgid="7084146295639672658">"Te veel vCard-lêers op die SD-kaart"</string>
     <string name="fail_reason_too_long_filename" msgid="1915716071321839166">"Vereiste lêernaam is te lank (\"<xliff:g id="FILENAME">%s</xliff:g>\")"</string>
     <string name="exporting_vcard_finished_title" msgid="4259736138838583213">"Het <xliff:g id="FILENAME">%s</xliff:g> klaar uitgevoer"</string>
@@ -352,8 +291,7 @@
     <string name="quickcontact_missing_app" msgid="4600366393134289038">"Geen program gevind om hierdie handeling te hanteer nie"</string>
     <string name="missing_name" msgid="7930716592850443705">"(geen naam nie)"</string>
     <string name="menu_accounts" msgid="8499114602017077970">"Rekeninge"</string>
-    <!-- no translation found for menu_contacts_filter (2165153460860262501) -->
-    <skip />
+    <string name="menu_contacts_filter" msgid="2165153460860262501">"Kontakte om te wys"</string>
     <string name="menu_import_export" msgid="3765725645491577190">"Voer in/uit"</string>
     <string name="dialog_import_export" msgid="4771877268244096596">"Voer kontakte in/uit"</string>
     <string name="menu_share" msgid="943789700636542260">"Deel"</string>
@@ -373,8 +311,7 @@
     <string name="type_short_pager" msgid="2613818970827594238">"P"</string>
     <string name="type_short_other" msgid="5669407180177236769">"O"</string>
     <string name="dialog_new_contact_account" msgid="9044704073286262197">"Skep kontak onder rekening"</string>
-    <!-- no translation found for dialog_new_group_account (2318032089273496830) -->
-    <skip />
+    <string name="dialog_new_group_account" msgid="2318032089273496830">"Skep groep onder rekening"</string>
     <string name="menu_sync_remove" msgid="3266725887008450161">"Verwyder sinkroniseergroep"</string>
     <string name="dialog_sync_add" msgid="8267045393119375803">"Voeg sinkroniseergroep by"</string>
     <string name="display_more_groups" msgid="2682547080423434170">"Meer groepe..."</string>
@@ -461,20 +398,17 @@
     <string name="name_phonetic_given" msgid="6853570431394449191">"Fonetiese voornaam"</string>
     <string name="name_phonetic_middle" msgid="8643721493320405200">"Fonetiese middelnaam"</string>
     <string name="name_phonetic_family" msgid="462095502140180305">"Fonetiese van"</string>
-    <!-- no translation found for name_phonetic (4259595234312430484) -->
-    <skip />
+    <string name="name_phonetic" msgid="4259595234312430484">"Fonetiese naam"</string>
     <string name="connections" msgid="8098440723172028350">"Kennisse"</string>
     <string name="add_connection_button" msgid="4861308615789601727">"Voeg kennis by"</string>
-    <!-- no translation found for recent_updates (2062236709538790412) -->
-    <skip />
+    <string name="recent_updates" msgid="2062236709538790412">"Onlangs"</string>
     <string name="account_type_format" msgid="718948015590343010">"<xliff:g id="SOURCE">%1$s</xliff:g> kontak"</string>
     <!-- no translation found for from_account_format (4469138575127580203) -->
     <skip />
     <string name="use_photo_as_primary" msgid="8807110122951157246">"Gebruik hierdie foto"</string>
     <string name="contact_read_only" msgid="1856479476063888348">"Nie redigeerbaar vanuit hierdie program nie"</string>
     <string name="no_contact_details" msgid="6754415338321837001">"Geen bykomende inligting vir hierdie kontak nie"</string>
-    <!-- no translation found for group_read_only (7924922658394449477) -->
-    <skip />
+    <string name="group_read_only" msgid="7924922658394449477">"Nie redigeerbaar op hierdie toestel nie"</string>
     <string name="display_options_sort_list_by" msgid="6080091755852211076">"Rangskik lys volgens"</string>
     <string name="display_options_sort_by_given_name" msgid="184916793466387067">"Voornaam"</string>
     <string name="display_options_sort_by_family_name" msgid="7857986975275712622">"Van"</string>
@@ -498,8 +432,7 @@
     <string name="menu_select_none" msgid="7093222469852132345">"Ontkies almal"</string>
     <string name="no_contacts_selected" msgid="5877803471037324613">"Geen kontakte gekies nie."</string>
     <string name="add_field" msgid="2384260056674995230">"Voeg nog \'n veld by"</string>
-    <!-- no translation found for add_new_entry_for_section (5223080690667565044) -->
-    <skip />
+    <string name="add_new_entry_for_section" msgid="5223080690667565044">"Voeg nuwe by"</string>
     <string name="add_organization" msgid="7311893231158291197">"Voeg organisasie by"</string>
     <string name="event_edit_field_hint_text" msgid="5794424930242630477">"Datum"</string>
     <string name="group_edit_field_hint_text" msgid="3966441850870457808">"Groepnaam"</string>
@@ -517,8 +450,7 @@
     <string name="aggregation_suggestion_edit_dialog_title" msgid="1064042382692091314">"Redigeer gekose kontakte"</string>
     <string name="aggregation_suggestion_edit_dialog_message" msgid="6549585283910518095">"Wissel na redigering van die gekose kontak? Inligting wat jy tot dusver ingevoer het, sal gekopieer word."</string>
     <string name="menu_copyContact" msgid="4401683725471696686">"Kopieer na my kontakte"</string>
-    <!-- no translation found for add_to_my_contacts (1068274916793627723) -->
-    <skip />
+    <string name="add_to_my_contacts" msgid="1068274916793627723">"Voeg by My kontakte"</string>
     <string name="contact_directory_description" msgid="683398073603909119">"Gids <xliff:g id="TYPE">%1$s</xliff:g>"</string>
     <string name="directory_search_label" msgid="1887759056597975053">"Gids"</string>
     <string name="local_search_label" msgid="2551177578246113614">"Alle kontakte"</string>
@@ -531,8 +463,7 @@
     <string name="list_filter_single" msgid="5871400283515893087">"Kontak"</string>
     <string name="custom_list_filter" msgid="7836035257402013957">"Definieer gepasmaakte aansig"</string>
     <string name="activity_title_settings" msgid="5464130076132770781">"Instellings"</string>
-    <!-- no translation found for activity_title_contacts_filter (8275542497615516969) -->
-    <skip />
+    <string name="activity_title_contacts_filter" msgid="8275542497615516969">"Kontakte om te wys"</string>
     <string name="menu_settings" msgid="377929915873428211">"Instellings"</string>
     <string name="preference_displayOptions" msgid="1341720270148252393">"Vertoonopsies"</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>
@@ -551,100 +482,77 @@
     <string name="create_group_dialog_title" msgid="6874527142828424475">"Skep nuwe groep"</string>
     <string name="create_group_item_label" msgid="5218022006186243310">"[Skep nuwe groep]"</string>
     <string name="delete_group_dialog_title" msgid="7368429698398624427">"Vee groep uit"</string>
-    <!-- no translation found for num_groups_in_account:one (2944819210288517794) -->
-    <!-- no translation found for num_groups_in_account:other (1276758425904917367) -->
+  <plurals name="num_groups_in_account">
+    <item quantity="one" msgid="2944819210288517794">"1 groep"</item>
+    <item quantity="other" msgid="1276758425904917367">"<xliff:g id="COUNT">%0$d</xliff:g> groepe"</item>
+  </plurals>
     <string name="delete_group_dialog_message" msgid="295063284548750881">"Is jy seker jy wil die groep \'<xliff:g id="GROUP_LABEL">%1$s</xliff:g>\' uitvee? (Kontakte sal nie uitgevee word nie.)"</string>
-    <!-- no translation found for num_contacts_in_group:one (1352418549951013448) -->
-    <!-- no translation found for num_contacts_in_group:other (8146027769011086349) -->
-    <!-- no translation found for group_list_num_contacts_in_group:one (3323065321661972446) -->
-    <!-- no translation found for group_list_num_contacts_in_group:other (6251996206137048525) -->
+  <plurals name="num_contacts_in_group">
+    <item quantity="one" msgid="1352418549951013448">"<xliff:g id="COUNT_0">%1$d</xliff:g> persoon van <xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+    <item quantity="other" msgid="8146027769011086349">"<xliff:g id="COUNT_0">%1$d</xliff:g> persone uit <xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+  </plurals>
+  <plurals name="group_list_num_contacts_in_group">
+    <item quantity="one" msgid="3323065321661972446">"<xliff:g id="COUNT">%1$d</xliff:g> persoon"</item>
+    <item quantity="other" msgid="6251996206137048525">"<xliff:g id="COUNT">%1$d</xliff:g> mense"</item>
+  </plurals>
     <string name="toast_join_with_empty_contact" msgid="5015189525953438968">"Voer asseblief kontaknaam in voor jy dit by \'n ander kontak saamvoeg."</string>
-    <!-- no translation found for copy_text (3257145021583508761) -->
-    <skip />
-    <!-- no translation found for set_default (4417505153468300351) -->
-    <skip />
-    <!-- no translation found for clear_default (7193185801596678067) -->
-    <skip />
+    <string name="copy_text" msgid="3257145021583508761">"Kopieer na knipbord"</string>
+    <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_title" msgid="3950463632415908534">"Ontdoen wysigings"</string>
     <string name="cancel_confirmation_dialog_message" msgid="7021968394611740251">"Wil jy jou wysigings ontdoen?"</string>
-    <!-- no translation found for call_type_and_date (1766269584078149149) -->
-    <skip />
+    <string name="call_type_and_date" msgid="1766269584078149149">"<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>
-    <!-- no translation found for view_updates_from_group (1782685984905600034) -->
-    <skip />
-    <!-- no translation found for notification_voicemail_title:one (1746619685488504230) -->
-    <!-- no translation found for notification_voicemail_title:other (5513481419205061254) -->
-    <!-- no translation found for notification_voicemail_callers_list (1153954809339404149) -->
-    <skip />
-    <!-- no translation found for notification_new_voicemail_ticker (895342132049452081) -->
-    <skip />
+    <string name="view_updates_from_group" msgid="1782685984905600034">"Sien opdaterings"</string>
+  <plurals name="notification_voicemail_title">
+    <item quantity="one" msgid="1746619685488504230">"Stemboodskap"</item>
+    <item quantity="other" msgid="5513481419205061254">"<xliff:g id="COUNT">%1$d</xliff:g> stemboodskappe"</item>
+  </plurals>
+    <string name="notification_voicemail_callers_list" msgid="1153954809339404149">"<xliff:g id="NEWER_CALLERS">%1$s</xliff:g>, <xliff:g id="OLDER_CALLER">%2$s</xliff:g>"</string>
+    <string name="notification_new_voicemail_ticker" msgid="895342132049452081">"Nuwe stemboodskap van <xliff:g id="CALLER">%1$s</xliff:g>"</string>
     <string name="voicemail_playback_error" msgid="1811242131549854624">"Kon nie stemboodskap speel nie."</string>
     <string name="voicemail_buffering" msgid="738287747618697097">"Buffering???"</string>
     <string name="voicemail_fetching_content" msgid="877911315738258780">"Haal stemboodskappe???"</string>
     <string name="voicemail_fetching_timout" msgid="6691792377574905201">"Kon nie stemboodskap haal nie."</string>
-    <!-- no translation found for call_log_new_header (846546437517724715) -->
-    <skip />
-    <!-- no translation found for call_log_old_header (6262205894314263629) -->
-    <skip />
-    <!-- no translation found for voicemail_status_voicemail_not_available (3164200979671881947) -->
-    <skip />
-    <!-- no translation found for voicemail_status_messages_waiting (2970301042310727909) -->
-    <skip />
-    <!-- no translation found for voicemail_status_configure_voicemail (3940240432123700974) -->
-    <skip />
-    <!-- no translation found for voicemail_status_audio_not_available (3369618334553341626) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_configure (7008713959076506385) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_call_server (1824816252288551794) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slowest (6047030504814773029) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slower (7890393922358642543) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_normal (6030110237820243006) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_faster (4161478290979905481) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_fastest (3373646875150544205) -->
-    <skip />
+    <string name="call_log_new_header" msgid="846546437517724715">"Nuut"</string>
+    <string name="call_log_old_header" msgid="6262205894314263629">"Ouer"</string>
+    <string name="voicemail_status_voicemail_not_available" msgid="3164200979671881947">"Kan nie aan stemboodskapsbediener koppel nie."</string>
+    <string name="voicemail_status_messages_waiting" msgid="2970301042310727909">"Kan nie aan stemboodskapsbediener koppel nie. Nuwe stemboodskappe wag."</string>
+    <string name="voicemail_status_configure_voicemail" msgid="3940240432123700974">"Stel jou stemboodskappe op."</string>
+    <string name="voicemail_status_audio_not_available" msgid="3369618334553341626">"Oudio nie beskikbaar nie."</string>
+    <string name="voicemail_status_action_configure" msgid="7008713959076506385">"Stel op"</string>
+    <string name="voicemail_status_action_call_server" msgid="1824816252288551794">"Bel stemboodskap"</string>
+    <string name="voicemail_speed_slowest" msgid="6047030504814773029">"stadigste spoed"</string>
+    <string name="voicemail_speed_slower" msgid="7890393922358642543">"stadige spoed"</string>
+    <string name="voicemail_speed_normal" msgid="6030110237820243006">"normale spoed"</string>
+    <string name="voicemail_speed_faster" msgid="4161478290979905481">"vinnige spoed"</string>
+    <string name="voicemail_speed_fastest" msgid="3373646875150544205">"vinnigste spoed"</string>
     <string name="call_log_item_count_and_date" msgid="7641933305703520787">"(<xliff:g id="COUNT">%1$d</xliff:g>)<xliff:g id="DATE">%2$s</xliff:g>"</string>
-    <!-- no translation found for group_name_hint (2659811836386413509) -->
-    <skip />
-    <!-- no translation found for nfc_vcard_file_name (2823095213265993609) -->
-    <skip />
-    <!-- no translation found for menu_show_voicemails_only (1898421289561435703) -->
-    <skip />
+    <string name="group_name_hint" msgid="2659811836386413509">"Groep se naam"</string>
+    <string name="nfc_vcard_file_name" msgid="2823095213265993609">"Kontak ontvang via NFC"</string>
+    <string name="menu_show_voicemails_only" msgid="1898421289561435703">"Wys net stemboodskappe"</string>
     <string name="menu_show_all_calls" msgid="7560347482073345885">"Wys alle oproepe"</string>
-    <!-- no translation found for status_available (5586870015822828392) -->
-    <skip />
-    <!-- no translation found for status_away (1838861100379804730) -->
-    <skip />
-    <!-- no translation found for status_busy (9147992455450257136) -->
-    <skip />
-    <!-- no translation found for description_call_log_call_button (8207201401459528442) -->
-    <skip />
-    <!-- no translation found for description_call_log_play_button (651182125650429846) -->
-    <skip />
-    <!-- no translation found for description_call_log_incoming_call (4485427487637250143) -->
-    <skip />
-    <!-- no translation found for description_call_log_outgoing_call (604831756853471658) -->
-    <skip />
-    <!-- no translation found for description_call_log_missed_call (2242805209983708825) -->
-    <skip />
-    <!-- no translation found for description_call_log_voicemail (4600798771975158948) -->
-    <skip />
+    <string name="status_available" msgid="5586870015822828392">"Beskikbaar"</string>
+    <string name="status_away" msgid="1838861100379804730">"Weg"</string>
+    <string name="status_busy" msgid="9147992455450257136">"Besig"</string>
+    <string name="description_call_log_call_button" msgid="8207201401459528442">"Bel nommer"</string>
+    <string name="description_call_log_play_button" msgid="651182125650429846">"Speel stemboodskap"</string>
+    <string name="description_call_log_incoming_call" msgid="4485427487637250143">"Inkomende oproep"</string>
+    <string name="description_call_log_outgoing_call" msgid="604831756853471658">"Uitgaande oproep"</string>
+    <string name="description_call_log_missed_call" msgid="2242805209983708825">"Gemiste oproep"</string>
+    <string name="description_call_log_voicemail" msgid="4600798771975158948">"Stemboodskap"</string>
     <string name="description_add_contact" msgid="3103414772502485851">"Voeg kontak by"</string>
     <string name="description_view_contact" msgid="5205669345700598415">"Bekyk kontak <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call" msgid="3443678121983852666">"Bel <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Stuur teksboodskap aan <xliff:g id="NAME">%1$s</xliff:g>"</string>
-    <!-- no translation found for description_call_log_unheard_voicemail (118101684236996786) -->
-    <skip />
-    <!-- no translation found for call_log_empty_gecode (5588904744812100846) -->
-    <skip />
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"EK"</string>
+    <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Ongeluisterde stemboodskap"</string>
+    <string name="description_send_message" msgid="6046623392322890962">"Stuur boodskap aan <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_dial_phone_number" msgid="8831647331642648637">"Skakel foon <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_quick_contact_for" msgid="6737516415168327789">"Vinnige kontak vir <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ek"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"My plaaslike profiel"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"My <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>profiel"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Vertoon alle kontakte"</string>
diff --git a/res/values-am/strings.xml b/res/values-am/strings.xml
index 908952e..568a058 100644
--- a/res/values-am/strings.xml
+++ b/res/values-am/strings.xml
@@ -17,52 +17,33 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="launcherDialer" msgid="8636288196618486553">"ስልክ"</string>
-    <!-- no translation found for people (1048457247435785074) -->
-    <skip />
-    <!-- no translation found for contactsList (8661624236494819731) -->
-    <skip />
-    <!-- no translation found for shortcutContact (749243779392912958) -->
-    <skip />
+    <string name="people" msgid="1048457247435785074">"ሰዎች"</string>
+    <string name="contactsList" msgid="8661624236494819731">"እውቅያዎች"</string>
+    <string name="shortcutContact" msgid="749243779392912958">"እውቅያ"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"ቀጥታ ደውል"</string>
     <string name="shortcutMessageContact" msgid="2460337253595976198">"ቀጥታ መልዕክት"</string>
     <string name="shortcutActivityTitle" msgid="6642877210643565436">"የዕውቂያአቋራጭ  ምረጥ"</string>
     <string name="callShortcutActivityTitle" msgid="6065749861423648991">"ለመደወል ቁጥር ምረጥ"</string>
     <string name="messageShortcutActivityTitle" msgid="3084542316620335911">"መልዕክትለመላክ ቁጥር ምረጥ"</string>
     <string name="contactPickerActivityTitle" msgid="6886592363525235031">"ዕውቂያ ምረጥ"</string>
-    <!-- no translation found for starredList (4817256136413959463) -->
-    <skip />
-    <!-- no translation found for frequentList (7154768136473953056) -->
-    <skip />
-    <!-- no translation found for strequentList (5640192862059373511) -->
-    <skip />
-    <!-- no translation found for viewContactTitle (7989394521836644384) -->
-    <skip />
-    <!-- no translation found for viewContactDesription (214186610887547860) -->
-    <skip />
-    <!-- no translation found for editContactDescription (2947202828256214947) -->
-    <skip />
-    <!-- no translation found for insertContactDescription (4709878105452681987) -->
-    <skip />
-    <!-- no translation found for editGroupDescription (6321161304201540561) -->
-    <skip />
-    <!-- no translation found for insertGroupDescription (5658512271662210139) -->
-    <skip />
-    <!-- no translation found for contactDetailAbout (5430408883907061400) -->
-    <skip />
-    <!-- no translation found for contactDetailUpdates (3780588624763446941) -->
-    <skip />
-    <!-- no translation found for searchHint (8482945356247760701) -->
-    <skip />
+    <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="viewContactDesription" msgid="214186610887547860">"ዕውቂያ ዕይ"</string>
+    <string name="editContactDescription" msgid="2947202828256214947">"ዕውቅያ አርትዕ"</string>
+    <string name="insertContactDescription" msgid="4709878105452681987">"ዕውቅያ ፍጠር"</string>
+    <string name="editGroupDescription" msgid="6321161304201540561">"ቡድን አርትዕ"</string>
+    <string name="insertGroupDescription" msgid="5658512271662210139">"ቡድን ፍጠር"</string>
+    <string name="contactDetailAbout" msgid="5430408883907061400">"ስለ"</string>
+    <string name="contactDetailUpdates" msgid="3780588624763446941">"ማዘመኛ"</string>
+    <string name="searchHint" msgid="8482945356247760701">"ዕውቅያዎችን ፈልግ"</string>
     <string name="menu_search" msgid="9147752853603483719">"ፍለጋ"</string>
-    <!-- no translation found for menu_newContact (1209922412763274638) -->
-    <skip />
-    <!-- no translation found for menu_viewContact (2795575601596468581) -->
-    <skip />
+    <string name="menu_newContact" msgid="1209922412763274638">"አዲስ ዕውቅያ"</string>
+    <string name="menu_viewContact" msgid="2795575601596468581">"ዕውቂያ ዕይ"</string>
     <string name="menu_callNumber" msgid="5142851348489387516">"ጥሪ <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for menu_addStar (2908478235715404876) -->
-    <skip />
-    <!-- no translation found for menu_removeStar (5844227078364227030) -->
-    <skip />
+    <string name="menu_addStar" msgid="2908478235715404876">"ወደ ተወዳጅ አክል"</string>
+    <string name="menu_removeStar" msgid="5844227078364227030">"ከተወዳጆች አስወግድ"</string>
     <string name="menu_editContact" msgid="9042415603857662633">"አርትዕ"</string>
     <string name="menu_deleteContact" msgid="6788644058868189393">"ሰርዝ"</string>
     <string name="menu_call" msgid="3992595586042260618">"የጥሪ ዕውቂያ"</string>
@@ -71,8 +52,7 @@
     <string name="menu_editGroup" msgid="5062005185370983720">"አርትዕ"</string>
     <string name="menu_deleteGroup" msgid="3486380004411482874">"ሰርዝ"</string>
     <string name="menu_new_contact_action_bar" msgid="8887818026717394343">"አዲስ"</string>
-    <!-- no translation found for menu_new_group_action_bar (5055346725617932394) -->
-    <skip />
+    <string name="menu_new_group_action_bar" msgid="5055346725617932394">"አዲስ"</string>
     <string name="splitConfirmation_title" msgid="2209511048593467012">"ዕውቂያ ለይ"</string>
     <string name="splitConfirmation" msgid="1067993957986345974">"እርግጠኛ ነዎት ይህን ነጠላ ዕውቂያ ወደ ብዙ ዕውቂያዎች ለመነጠል ይፈልጋሉ?"</string>
     <string name="menu_joinAggregate" msgid="5027981918265667970">"አገናኝ"</string>
@@ -82,81 +62,61 @@
     <string name="separatorJoinAggregateSuggestions" msgid="2831414448851313345">"አስተያየት የተሰጠባቸው እውቅያዎች"</string>
     <string name="separatorJoinAggregateAll" msgid="7939932265026181043">"ሁሉም እውቅያዎች"</string>
     <string name="contactsJoinedMessage" msgid="7208148163607047389">"ዕውቂያዎች ተገናኝተዋል"</string>
-    <!-- no translation found for deleteConfirmation_title (6394309508930335204) -->
-    <skip />
-    <!-- no translation found for menu_set_ring_tone (8728345772068064946) -->
-    <skip />
+    <string name="deleteConfirmation_title" msgid="6394309508930335204">"ሰርዝ"</string>
+    <string name="menu_set_ring_tone" msgid="8728345772068064946">"የጥሪ ድምፅ አዘጋጅ"</string>
     <string name="menu_redirect_calls_to_vm" msgid="4181789196416396656">"ሁሉንም ጥሪዎች ወደ ድምፅ መልዕክት"</string>
     <string name="readOnlyContactWarning" msgid="1390849295342594265">"ዕውቂያዎችን ከንባብ-ብቻ መለያዎች መሰረዝ አይችሉም፤ ነገር ግን በዕውቂያ ዝርዝሮችዎ ውስጥ መደበቅ ይችላሉ።"</string>
     <string name="readOnlyContactDeleteConfirmation" msgid="2137170726670196909">"ይህ ዕውቂያ ከብዙ መለያዎች መረጃ ይዟል።ከንባብ-ብቻ መለያዎች ውስጥ ያሉ ዕውቂያዎች ይደበቃሉ፣አይሰረዙም።"</string>
     <string name="multipleContactDeleteConfirmation" msgid="938900978442960800">"ይህን ዕውቂያ መሰረዝ ከብዙ መለያዎች ውስጥ መረጃ ይሰርዛል።"</string>
-    <!-- no translation found for deleteConfirmation (811706994761610640) -->
-    <skip />
+    <string name="deleteConfirmation" msgid="811706994761610640">"ይህ ማንቂያ ይሰረዛል።"</string>
     <string name="menu_done" msgid="796017761764190697">"ተከናውኗል"</string>
     <string name="menu_doNotSave" msgid="58593876893538465">"ይቅር"</string>
-    <!-- no translation found for menu_discard (6456087569315685632) -->
-    <skip />
-    <!-- no translation found for label_notes (8337354953278341042) -->
-    <skip />
+    <string name="menu_discard" msgid="6456087569315685632">"አስወግድ"</string>
+    <string name="label_notes" msgid="8337354953278341042">"ማስታወሻዎች"</string>
     <string name="label_sip_address" msgid="124073911714324974">"የበይነመረብ ጥሪ"</string>
-    <!-- no translation found for ghostData_company (5414421120553765775) -->
-    <skip />
+    <string name="ghostData_company" msgid="5414421120553765775">"ኩባንያ"</string>
     <string name="ghostData_title" msgid="7496735200318496110">"አርዕስት"</string>
-    <!-- no translation found for invalidContactMessage (5816991830260044593) -->
-    <skip />
-    <!-- no translation found for pickerNewContactHeader (7750705279843568147) -->
-    <skip />
-    <!-- no translation found for phoneLabelsGroup (6468091477851199285) -->
-    <skip />
-    <!-- no translation found for emailLabelsGroup (8389931313045344406) -->
-    <skip />
-    <!-- no translation found for imLabelsGroup (3898238486262614027) -->
-    <skip />
+    <string name="invalidContactMessage" msgid="5816991830260044593">"ትግበራው የለም።"</string>
+    <string name="pickerNewContactHeader" msgid="7750705279843568147">"አዲስ ዕውቂያ ፍጠር"</string>
+    <string name="phoneLabelsGroup" msgid="6468091477851199285">"ስልክ"</string>
+    <string name="emailLabelsGroup" msgid="8389931313045344406">"ኢሜይል"</string>
+    <string name="imLabelsGroup" msgid="3898238486262614027">"ፈጣን መልዕክቶች"</string>
     <string name="postalLabelsGroup" msgid="3487738141112589324">"አድራሻ"</string>
   <string-array name="otherLabels">
     <item msgid="8287841928119937597">"መስርያ ቤት"</item>
     <item msgid="7196592230748086755">"ማስታወሻ"</item>
   </string-array>
     <string name="photoPickerNotFoundText" product="tablet" msgid="6247290728908599701">"በጡባዊው ላይ ምንም ምስሎች የሉም።"</string>
-    <!-- outdated translation 6247290728908599701 -->     <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"በጡባዊው ላይ ምንም ምስሎች የሉም።"</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="send_to_voicemail_checkbox" msgid="9001686764070676353">"ጥሪዎችን በቀጥታ ወደ ድምፅ መልዕክት ላክ"</string>
     <string name="removePhoto" msgid="4898105274130284565">"ፎቶ አስወግድ"</string>
-    <!-- no translation found for noContacts (4955659076981974652) -->
-    <skip />
-    <!-- no translation found for noGroups (7315200974181864731) -->
-    <skip />
-    <!-- no translation found for noAccounts (4742609114153797268) -->
-    <skip />
+    <string name="noContacts" msgid="4955659076981974652">"እውቅያዎች የሉም"</string>
+    <string name="noGroups" msgid="7315200974181864731">"ምንም ቡድኖች የሉም"</string>
+    <string name="noAccounts" msgid="4742609114153797268">"ቡድኖች ለመፍጠር መለያ ያስፈልግዎታል"</string>
     <string name="noMatchingContacts" msgid="4266283206853990471">"ምንም ተዛማጅ ዕውቂያዎች አልተገኙም።"</string>
-    <!-- no translation found for noContactsWithPhoneNumbers (1605457050218824269) -->
-    <skip />
+    <string name="noContactsWithPhoneNumbers" msgid="1605457050218824269">"ከስልክ ቁጥር ጋርየሚታዩዕውቂያዎች የሉም።"</string>
     <string name="savingContact" msgid="4075751076741924939">"ዕውቂያ በማስቀመጥ ላይ..."</string>
     <string name="savingDisplayGroups" msgid="2133152192716475939">"ማሳያ አማራጮችን በማስቀመጥ ላይ..."</string>
     <string name="contactSavedToast" msgid="9171862279493213075">"ዕውቂያ ተቀምጧል"</string>
     <string name="contactSavedErrorToast" msgid="9189098776225004666">"ስህተት፣የዕውቂያለውጦችን ለማስቀመጥአልተቻለም።"</string>
     <string name="groupSavedToast" msgid="6675062559302493011">"ቡድን ተቀምጧል"</string>
-    <!-- no translation found for groupSavedErrorToast (6434135707953150875) -->
-    <skip />
+    <string name="groupSavedErrorToast" msgid="6434135707953150875">"ስህተት፣የቡድን ለውጦችን ለማስቀመጥ አልተቻለም።"</string>
   <plurals name="listTotalPhoneContacts">
     <item quantity="one" msgid="3015357862286673986">"1 ዕውቂያ ከስልክ ቁጥር ጋር"</item>
     <item quantity="other" msgid="3299954047880968205">"<xliff:g id="COUNT">%d</xliff:g> ዕውቂያዎች ከስልክ ቁጥሮች ጋር"</item>
   </plurals>
-    <!-- outdated translation 2756295259674938869 -->     <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"ከስልክ ቁጥር ጋር የሚታይ ዕውቂያዎች የሉም"</string>
+    <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"ከስልክ ቁጥር ጋር የሚታዩ ዕውቂያዎች የሉም"</string>
   <plurals name="listTotalAllContacts">
     <item quantity="one" msgid="3405747744700823280">"1 እውቅያ"</item>
     <item quantity="other" msgid="3578469907265375314">"<xliff:g id="COUNT">%d</xliff:g> እውቅያዎች"</item>
   </plurals>
-    <!-- outdated translation 6811347506748072822 -->     <string name="listTotalAllContactsZero" msgid="1889349925514589304">"ምንም የሚታይ ዕውቂያዎች የሉም"</string>
-    <!-- no translation found for listTotalAllContactsZeroCustom (4058252141420128998) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroStarred (1289318488170099285) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroGroup (5448979458248027615) -->
-    <skip />
-    <!-- no translation found for listAllContactsInAccount (7496143179265311758) -->
-    <skip />
+    <string name="listTotalAllContactsZero" msgid="1889349925514589304">"እውቅያዎች የሉም"</string>
+    <string name="listTotalAllContactsZeroCustom" msgid="4058252141420128998">"ምንም የሚታዩዕውቂያዎች የሉም"</string>
+    <string name="listTotalAllContactsZeroStarred" msgid="1289318488170099285">"ምንም ተመራጭ የለም"</string>
+    <string name="listTotalAllContactsZeroGroup" msgid="5448979458248027615">"በ<xliff:g id="NAME">%s</xliff:g> ውስጥ ምንም ዕውቂያዎች የሉም"</string>
+    <string name="listAllContactsInAccount" msgid="7496143179265311758">"በ<xliff:g id="NAME">%s</xliff:g> ውስጥ ያሉ ዕውቂያዎች"</string>
     <string name="listSingleContact" msgid="6067813698903535563">"ነጠላ እውቂያ"</string>
     <string name="listCustomView" msgid="6950713892532194050">"እውቂያዎች በብጁ እይታ"</string>
   <plurals name="listFoundAllContacts">
@@ -169,53 +129,36 @@
     <item quantity="one" msgid="4826918429708286628">"1 ተገኝቷል"</item>
     <item quantity="other" msgid="7988132539476575389">"<xliff:g id="COUNT">%d</xliff:g> ተገኝቷል"</item>
   </plurals>
-    <!-- no translation found for contactsAllLabel (6178225597569649305) -->
-    <skip />
-    <!-- no translation found for contactsGroupsLabel (2841971472518003524) -->
-    <skip />
-    <!-- no translation found for contactsFavoritesLabel (8417039765586853670) -->
-    <skip />
+    <string name="contactsAllLabel" msgid="6178225597569649305">"ሁሉም"</string>
+    <string name="contactsGroupsLabel" msgid="2841971472518003524">"ቡድኖች"</string>
+    <string name="contactsFavoritesLabel" msgid="8417039765586853670">"ተወዳጆች"</string>
     <string name="dialerIconLabel" msgid="6500826552823403796">"ስልክ"</string>
-    <!-- no translation found for recentCallsIconLabel (1419116422359067949) -->
-    <skip />
+    <string name="recentCallsIconLabel" msgid="1419116422359067949">"ምዝግብ ማስታወሻ"</string>
     <string name="liveFolderAll" msgid="4789010460767506206">"ሁሉም እውቅያዎች"</string>
     <string name="liveFolderFavorites" msgid="3100957542927222282">"ባለኮከብ ዕውቂያዎች"</string>
     <string name="liveFolderPhone" msgid="3739376066610926780">"ዕውቂያዎችከስልክ ቁጥሮች ጋር"</string>
     <string name="menu_sendTextMessage" msgid="6937343460284499306">"የፅሁፍ መልዕክት ላክ"</string>
     <string name="recentCalls_callNumber" msgid="1756372533999226126">"ጥሪ <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for recentCalls_editNumberBeforeCall (7756171675833267857) -->
-    <skip />
-    <!-- no translation found for recentCalls_addToContact (1429899535546487008) -->
-    <skip />
-    <!-- no translation found for recentCalls_removeFromRecentList (401662244636511330) -->
-    <skip />
-    <!-- no translation found for recentCalls_deleteAll (6352364392762163704) -->
-    <skip />
+    <string name="recentCalls_editNumberBeforeCall" msgid="7756171675833267857">"ከመደወል በፊል ቁጥር አርትዕ"</string>
+    <string name="recentCalls_addToContact" msgid="1429899535546487008">"ወደ ዕውቂያዎች አክል"</string>
+    <string name="recentCalls_removeFromRecentList" msgid="401662244636511330">"ከጥሪ ማስታወሻ አስወግድ"</string>
+    <string name="recentCalls_deleteAll" msgid="6352364392762163704">"የጥሪ ማስታወሻ አጥራ"</string>
     <string name="recentCalls_trashVoicemail" msgid="7604696960787435655">"የድምፅ መልዕክት ሰርዝ"</string>
     <string name="recentCalls_shareVoicemail" msgid="1416112847592942840">"የድምፅ መልዕክት አጋራ"</string>
-    <!-- no translation found for recentCalls_empty (247053222448663107) -->
-    <skip />
+    <string name="recentCalls_empty" msgid="247053222448663107">"ምዝግብ ማስታወሻባዶ ነው..."</string>
     <string name="clearCallLogConfirmation_title" msgid="718072843006222703">"የጥሪ ማስታወሻ አጥራ"</string>
     <string name="clearCallLogConfirmation" msgid="7625927669136267636">"የጥሪ ማስታወሻውን ለማጥራት በእርግጥ ይፈልጋሉ?"</string>
-    <!-- no translation found for clearCallLogProgress_title (6870412675015656948) -->
-    <skip />
-    <!-- no translation found for imei (3045126336951684285) -->
-    <skip />
+    <string name="clearCallLogProgress_title" msgid="6870412675015656948">"ምዝግብ ማስታወሻ ማጥራት"</string>
+    <string name="imei" msgid="3045126336951684285">"IMEI"</string>
     <string name="meid" msgid="6210568493746275750">"MEID"</string>
-    <!-- no translation found for voicemail (3851469869202611441) -->
-    <skip />
-    <!-- no translation found for unknown (740067747858270469) -->
-    <skip />
-    <!-- no translation found for private_num (6374339738119166953) -->
-    <skip />
+    <string name="voicemail" msgid="3851469869202611441">"የድምፅ መልዕክት"</string>
+    <string name="unknown" msgid="740067747858270469">"ያልታወቀ"</string>
+    <string name="private_num" msgid="6374339738119166953">"የግል ቁጥር"</string>
     <string name="payphone" msgid="4864313342828942922">"የክፍያ ስልክ"</string>
-    <!-- no translation found for dialerKeyboardHintText (5401660096579787344) -->
-    <skip />
+    <string name="dialerKeyboardHintText" msgid="5401660096579787344">"ለመደወል የሰሌዳ ቁልፍ ተጠቀም"</string>
     <string name="dialerDialpadHintText" msgid="5824490365898349041">"ጥሪ ለማከል ደውል"</string>
-    <!-- no translation found for simContacts_emptyLoading (6700035985448642408) -->
-    <skip />
-    <!-- no translation found for simContacts_title (27341688347689769) -->
-    <skip />
+    <string name="simContacts_emptyLoading" msgid="6700035985448642408">"ከSIM ካርድ ላይ በመጫን ላይ..."</string>
+    <string name="simContacts_title" msgid="27341688347689769">"የSIM ካርድ ዕውቂያዎች"</string>
     <string name="noContactsHelpTextWithSyncForCreateShortcut" msgid="801504710275614594">"ለማሳየት ምንም እውቂያዎች የልዎትም። (መለያ አሁን ገና ካከሉ፣ እውቂያዎችን ለማሳመር ትንሽ ደቂቃ ሊወስድ ይችላል።)"</string>
     <string name="noContactsHelpTextForCreateShortcut" msgid="3081286388667108335">" ለማሳየት ምንም እውቂያዎች የልዎትም።"</string>
     <string name="noContactsHelpText" product="tablet" msgid="6450346791169710787">"ለማሳየት ምንም ዕውቂያዎች የልዎትም።"\n\n"ዕውቂያዎች ለማከል፣"<font fgcolor="#ffffffff"><b>"ምናሌ ይጫኑ"</b></font>"እና"\n\n<li><font fgcolor="#ffffffff"><b>"መለያዎች"</b></font>"ለማከል ወይም መለያዎች ን ከዕውቂያዎች ጋርለማዋቀር ወደ ስልኩ ማሰመርይችላሉ፡ይንኩ።"\n</li>\n<li><font fgcolor="#ffffffff"><b>"አዲስ ዕውቂያ"</b></font>"አዲስ ዕውቂያ ከባዶ ለመፍጠር"\n</li>\n<li><font fgcolor="#ffffffff"><b>"አስገባ/ላክ"</b></font>"ከSIM ወይምSD ካርድዎ ዕውቂያዎች ለማስገባት"\n</li></string>
@@ -238,8 +181,7 @@
     <string name="type_incoming" msgid="6502076603836088532">"ገቢ ጥሪ"</string>
     <string name="type_outgoing" msgid="343108709599392641">"ወጪ ጥሪ"</string>
     <string name="type_missed" msgid="2720502601640509542">"ያመለጠ ጥሪ"</string>
-    <!-- no translation found for type_voicemail (5153139450668549908) -->
-    <skip />
+    <string name="type_voicemail" msgid="5153139450668549908">"የድምፅ መልዕክት"</string>
     <string name="actionIncomingCall" msgid="6028930669817038600">"ገቢ ጥሪዎች"</string>
     <string name="callBack" msgid="5498224409038809224">"የኋላ ጥሪ"</string>
     <string name="callAgain" msgid="3197312117049874778">"እንደገና ደውል"</string>
@@ -262,30 +204,27 @@
     <string name="description_image_button_zero" msgid="4133108949401820710">"ዜሮ"</string>
     <string name="description_image_button_pound" msgid="3039765597595889230">"ፓውንድ"</string>
     <string name="description_voicemail_button" msgid="3402506823655455591">"የድምፅ መልዕክት"</string>
-    <!-- no translation found for description_search_button (3660807558587384889) -->
-    <skip />
+    <string name="description_search_button" msgid="3660807558587384889">"ፈልግ"</string>
     <string name="description_dial_button" msgid="1274091017188142646">"ደውል"</string>
     <string name="description_delete_button" msgid="6263102114033407382">"የኋሊት ደምሳሽ"</string>
     <string name="description_digits_edittext" msgid="8760207516497016437">"ቁጥር ለመደወል"</string>
     <string name="description_contact_photo" msgid="3387458082667894062">"የዕውቂያ ፎቶ"</string>
     <string name="description_minus_button" msgid="387136707700230172">"ሲቀነስ"</string>
     <string name="description_plus_button" msgid="515164827856229880">"ተጨማሪ"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
-    <!-- outdated translation 5362631473262100989 -->     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"የUSB ማከማቻ የለም"</string>
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"ዕውቂያ ዕይ"</string>
+    <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"ማከማቻ አልተገኘም"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"ምንምSD ካርድ የለም"</string>
-    <!-- outdated translation 8045830739790534254 -->     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"ምንም  USB ማከማቻ አልተገኘም"</string>
+    <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"ምንም   ማከማቻ አልተገኘም"</string>
     <string name="no_sdcard_message" product="default" msgid="6019391476490445358">"ምንም SD ካርድ አልተገኘም"</string>
     <string name="searching_vcard_title" msgid="4970508055399376813">"vCard ፍለጋ"</string>
     <string name="import_from_sim" msgid="3859272228033941659">"ከSIM ካርድ አስመጣ"</string>
-    <!-- outdated translation 8294728696808674154 -->     <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"ከUSB ማከማቻ አስመጣ"</string>
-    <!-- outdated translation 7201274701382901259 -->     <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"ወደUSB ማከማቻ ላክ"</string>
+    <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"ከማከማቻ አስገባ"</string>
+    <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"ወደማከማቻ ላክ"</string>
     <string name="share_visible_contacts" msgid="890150378880783797">"የሚታዩ እውቂያዎችን አጋራ"</string>
     <string name="import_one_vcard_string" msgid="9059163467020328433">"አንድ vCard ፋይል አስመጣ"</string>
     <string name="import_multiple_vcard_string" msgid="3810226492811062392">"ብዙ vCard ፋይሎች አስመጣ"</string>
     <string name="import_all_vcard_string" msgid="5518136113853448474">"ሁሉም vCard ፋይሎችን አስገባ"</string>
-    <!-- outdated translation 8214795338181412751 -->     <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"የvCard ውሂብ በUSB ማከማቻ በመፈለግ ላይ"</string>
+    <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">" በማከማቻ ውስጥ የvCard ውሂብ በመፈለግ ላይ"</string>
     <string name="searching_vcard_message" product="default" msgid="6917522333561434546">"በSD ካርድ ላይ vCard ፍለጋ"</string>
     <string name="scanning_sdcard_failed_title" product="nosdcard" msgid="4944932641334764942">"ማከማቻን መቃኘት አልተቻለም"</string>
     <string name="scanning_sdcard_failed_title" product="default" msgid="6664940444476572612">"SD ካርድን መቃኘት አልተቻለም"</string>
@@ -296,7 +235,7 @@
     <string name="fail_reason_vcard_parse_error" msgid="4492947335972369711">"ባልተጠበቀ ምክንያት vCard መተንተን አልተቻለም"</string>
     <string name="fail_reason_not_supported" msgid="294499264620201243">"ቅርፀቱ አይታገዝም"</string>
     <string name="vcard_import_failed" msgid="8856125211629574066">"vCard ማስመጣት አልተቻለም"</string>
-    <!-- outdated translation 1730986357514922756 -->     <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"በSD ካርዱ ላይ ምንም SD ካርድ ፋይል አልተገኘም"</string>
+    <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"በvCard ፋይልላይ ምንም ማከማቻ ፋይል አልተገኘም"</string>
     <string name="import_failure_no_vcard_file" product="default" msgid="1730986357514922756">"በSD ካርዱ ላይ ምንም SD ካርድ ፋይል አልተገኘም"</string>
     <string name="fail_reason_failed_to_collect_vcard_meta_info" msgid="6427931733267328564">"በተሰጠው(ጡት) vCard ፋይል(ሎች) ሜታ መረጃ መሰብሰብ አልተቻለም፡፡"</string>
     <string name="fail_reason_failed_to_read_files" msgid="5823434810622484922">"አንድ ወይም ከዛ በላይ ፋይሎች ማስመጣት አልተቻለም (%s)፡፡"</string>
@@ -322,7 +261,7 @@
     <string name="exporting_contact_failed_title" msgid="2339788270863991417">"የእውቂያ ውሂብን ወደ ውጪ መላክ አልተቻለም፡፡"</string>
     <string name="exporting_contact_failed_message" msgid="2704925031146288635">"የእውቂያ ውሂብ ወደ ውጪ መላክ አልተቻለም፡፡"\n"ምክንያት፤ \"<xliff:g id="FAIL_REASON">%s</xliff:g>\""</string>
     <string name="fail_reason_no_exportable_contact" msgid="4919714086648344495">"ምንም መላክ የሚችል ዕውቂያ የለም"</string>
-    <!-- outdated translation 2638638826954895225 -->     <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"በጣም ብዙ vCard ፋይሎችበUSB ማከማቻ ውስጥ"</string>
+    <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"በጣም ብዙ vCard ፋይሎችበማከማቻ ውስጥ"</string>
     <string name="fail_reason_too_many_vcard" product="default" msgid="7084146295639672658">"በSD ካርድ ላይ በጣም ብዙ vCard ፋይሎች"</string>
     <string name="fail_reason_too_long_filename" msgid="1915716071321839166">"የተጠየቀው ፋይል ስም በጣም ረጅም ነው (\"<xliff:g id="FILENAME">%s</xliff:g>\")"</string>
     <string name="exporting_vcard_finished_title" msgid="4259736138838583213">"<xliff:g id="FILENAME">%s</xliff:g> መላክ ጨርሷል"</string>
@@ -352,8 +291,7 @@
     <string name="quickcontact_missing_app" msgid="4600366393134289038">"ይህን እርምጃ ለማስተናገድ ምንም ትግበራ አልተገኘም"</string>
     <string name="missing_name" msgid="7930716592850443705">"(ስም አልባ)"</string>
     <string name="menu_accounts" msgid="8499114602017077970">"መለያዎች"</string>
-    <!-- no translation found for menu_contacts_filter (2165153460860262501) -->
-    <skip />
+    <string name="menu_contacts_filter" msgid="2165153460860262501">"ዕውቂያዎች አሳይ"</string>
     <string name="menu_import_export" msgid="3765725645491577190">"አስመጣ/ላክ"</string>
     <string name="dialog_import_export" msgid="4771877268244096596">"ዕውቂያዎች አስመጣ/ላክ"</string>
     <string name="menu_share" msgid="943789700636542260">"መጋሪያ"</string>
@@ -373,8 +311,7 @@
     <string name="type_short_pager" msgid="2613818970827594238">"P"</string>
     <string name="type_short_other" msgid="5669407180177236769">"O"</string>
     <string name="dialog_new_contact_account" msgid="9044704073286262197">"በመለያ ስር ዕውቂያ ፍጠር"</string>
-    <!-- no translation found for dialog_new_group_account (2318032089273496830) -->
-    <skip />
+    <string name="dialog_new_group_account" msgid="2318032089273496830">"በመለያ ስር ቡድን ፍጠር"</string>
     <string name="menu_sync_remove" msgid="3266725887008450161">"የአሳምር ቡድን አስወግድ"</string>
     <string name="dialog_sync_add" msgid="8267045393119375803">"አሳምርቡድንአክል"</string>
     <string name="display_more_groups" msgid="2682547080423434170">"ተጨማሪቡድኖች..."</string>
@@ -461,20 +398,17 @@
     <string name="name_phonetic_given" msgid="6853570431394449191">"በድምፀ ልሳን የተሰጠ ስም"</string>
     <string name="name_phonetic_middle" msgid="8643721493320405200">"የድምፀ ልሳንመካከለኛ ስም"</string>
     <string name="name_phonetic_family" msgid="462095502140180305">"የድምፀ ልሳን ቤተሰብ ስም"</string>
-    <!-- no translation found for name_phonetic (4259595234312430484) -->
-    <skip />
+    <string name="name_phonetic" msgid="4259595234312430484">"የድምፀ ልሳን ስም"</string>
     <string name="connections" msgid="8098440723172028350">"ተያያዦች"</string>
     <string name="add_connection_button" msgid="4861308615789601727">"ተያያዥ አክል"</string>
-    <!-- no translation found for recent_updates (2062236709538790412) -->
-    <skip />
+    <string name="recent_updates" msgid="2062236709538790412">"የቅርብ ጊዜ"</string>
     <string name="account_type_format" msgid="718948015590343010">"<xliff:g id="SOURCE">%1$s</xliff:g> እውቅያ"</string>
     <!-- no translation found for from_account_format (4469138575127580203) -->
     <skip />
     <string name="use_photo_as_primary" msgid="8807110122951157246">"ይህን ፎቶ ተጠቀም"</string>
     <string name="contact_read_only" msgid="1856479476063888348">"ከዚህ ትግበራ አርትዕ የሚደረግ አይደለም"</string>
     <string name="no_contact_details" msgid="6754415338321837001">"ለዚህ ዕውቂያ ምንም ተጨማሪ መረጃ የለም"</string>
-    <!-- no translation found for group_read_only (7924922658394449477) -->
-    <skip />
+    <string name="group_read_only" msgid="7924922658394449477">"በዚህ መሣሪያ ላይ አርትዕ መደረግ የሚችል አይደለም።"</string>
     <string name="display_options_sort_list_by" msgid="6080091755852211076">"ዝርዝር በ  ለይ"</string>
     <string name="display_options_sort_by_given_name" msgid="184916793466387067">"መጠሪያ ስም"</string>
     <string name="display_options_sort_by_family_name" msgid="7857986975275712622">"የቤተሰብ ስም"</string>
@@ -498,8 +432,7 @@
     <string name="menu_select_none" msgid="7093222469852132345">"ሁሉንም አትምረጥ"</string>
     <string name="no_contacts_selected" msgid="5877803471037324613">"ምንም እውቂያዎች አልተመረጡም."</string>
     <string name="add_field" msgid="2384260056674995230">"ሌላ መስክ አክል"</string>
-    <!-- no translation found for add_new_entry_for_section (5223080690667565044) -->
-    <skip />
+    <string name="add_new_entry_for_section" msgid="5223080690667565044">"አዲስ አክል"</string>
     <string name="add_organization" msgid="7311893231158291197">"ድርጅት አክል"</string>
     <string name="event_edit_field_hint_text" msgid="5794424930242630477">"ቀን"</string>
     <string name="group_edit_field_hint_text" msgid="3966441850870457808">"የቡድን ስም"</string>
@@ -517,8 +450,7 @@
     <string name="aggregation_suggestion_edit_dialog_title" msgid="1064042382692091314">"የተመረጡ  ዕውቂያዎችን አርትዕ"</string>
     <string name="aggregation_suggestion_edit_dialog_message" msgid="6549585283910518095">"የተመረጠው ዕውቂያ ወደ አርትዕ ይቀየር? እስከ አሁን ያስገቡት መረጃ ይገለበጣል።"</string>
     <string name="menu_copyContact" msgid="4401683725471696686">"ወደ ዕውቂያዎቼ ቅዳ"</string>
-    <!-- no translation found for add_to_my_contacts (1068274916793627723) -->
-    <skip />
+    <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="directory_search_label" msgid="1887759056597975053">" ማውጫ"</string>
     <string name="local_search_label" msgid="2551177578246113614">"ሁሉም እውቅያዎች"</string>
@@ -531,8 +463,7 @@
     <string name="list_filter_single" msgid="5871400283515893087">"እውቅያ"</string>
     <string name="custom_list_filter" msgid="7836035257402013957">"ብጁ ዕይታ በይን"</string>
     <string name="activity_title_settings" msgid="5464130076132770781">"ቅንብሮች"</string>
-    <!-- no translation found for activity_title_contacts_filter (8275542497615516969) -->
-    <skip />
+    <string name="activity_title_contacts_filter" msgid="8275542497615516969">"ዕውቂያዎች አሳይ"</string>
     <string name="menu_settings" msgid="377929915873428211">"ቅንብሮች"</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>
@@ -551,100 +482,80 @@
     <string name="create_group_dialog_title" msgid="6874527142828424475">"አዲስ ቡድን ፍጠር"</string>
     <string name="create_group_item_label" msgid="5218022006186243310">"[አዲስ ቡድን ፍጠር]"</string>
     <string name="delete_group_dialog_title" msgid="7368429698398624427">"ቡድን ሰርዝ"</string>
-    <!-- no translation found for num_groups_in_account:one (2944819210288517794) -->
-    <!-- no translation found for num_groups_in_account:other (1276758425904917367) -->
+  <plurals name="num_groups_in_account">
+    <item quantity="one" msgid="2944819210288517794">"1 ቡድን"</item>
+    <item quantity="other" msgid="1276758425904917367">"<xliff:g id="COUNT">%0$d</xliff:g>ቡድኖች"</item>
+  </plurals>
     <string name="delete_group_dialog_message" msgid="295063284548750881">"\'<xliff:g id="GROUP_LABEL">%1$s</xliff:g>\' ቡድን ለመሰረዝ በእርግጥ ይፈልጋሉ? (ዕውቂያዎችራሳቸው አይሰረዙም።)"</string>
-    <!-- no translation found for num_contacts_in_group:one (1352418549951013448) -->
-    <!-- no translation found for num_contacts_in_group:other (8146027769011086349) -->
-    <!-- no translation found for group_list_num_contacts_in_group:one (3323065321661972446) -->
-    <!-- no translation found for group_list_num_contacts_in_group:other (6251996206137048525) -->
+  <plurals name="num_contacts_in_group">
+    <item quantity="one" msgid="1352418549951013448">"<xliff:g id="COUNT_0">%1$d</xliff:g>ሰው ከ<xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+    <item quantity="other" msgid="8146027769011086349">"<xliff:g id="COUNT_0">%1$d</xliff:g>ሰዎች ከ<xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+  </plurals>
+  <plurals name="group_list_num_contacts_in_group">
+    <item quantity="one" msgid="3323065321661972446">"<xliff:g id="COUNT">%1$d</xliff:g> ሰው"</item>
+    <item quantity="other" msgid="6251996206137048525">"<xliff:g id="COUNT">%1$d</xliff:g> ሰዎች"</item>
+  </plurals>
     <string name="toast_join_with_empty_contact" msgid="5015189525953438968">"እባክዎ ሌላ ዕውቂያ ከመቀላቀልዎ በፊት የዕውቂያ ስም ያስገቡ።"</string>
-    <!-- no translation found for copy_text (3257145021583508761) -->
-    <skip />
-    <!-- no translation found for set_default (4417505153468300351) -->
-    <skip />
-    <!-- no translation found for clear_default (7193185801596678067) -->
-    <skip />
+    <string name="copy_text" msgid="3257145021583508761">"ወደ ቅንጥብ ሰሌዳ ገልብጥ"</string>
+    <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_title" msgid="3950463632415908534">"ለውጦች አስወግድ"</string>
     <string name="cancel_confirmation_dialog_message" msgid="7021968394611740251">"ለውጦችዎን ማስወገድ ይፈልጋሉ?"</string>
-    <!-- no translation found for call_type_and_date (1766269584078149149) -->
-    <skip />
+    <string name="call_type_and_date" msgid="1766269584078149149">"<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>
-    <!-- no translation found for view_updates_from_group (1782685984905600034) -->
-    <skip />
-    <!-- no translation found for notification_voicemail_title:one (1746619685488504230) -->
-    <!-- no translation found for notification_voicemail_title:other (5513481419205061254) -->
-    <!-- no translation found for notification_voicemail_callers_list (1153954809339404149) -->
-    <skip />
-    <!-- no translation found for notification_new_voicemail_ticker (895342132049452081) -->
-    <skip />
+    <string name="view_updates_from_group" msgid="1782685984905600034">"አዘምኖችን ዕይ"</string>
+  <plurals name="notification_voicemail_title">
+    <item quantity="one" msgid="1746619685488504230">"የድምፅ መልዕክት"</item>
+    <item quantity="other" msgid="5513481419205061254">"<xliff:g id="COUNT">%1$d</xliff:g> የድምፅ መልዕክቶች"</item>
+  </plurals>
+    <string name="notification_voicemail_callers_list" msgid="1153954809339404149">"<xliff:g id="NEWER_CALLERS">%1$s</xliff:g>፤<xliff:g id="OLDER_CALLER">%2$s</xliff:g>"</string>
+    <string name="notification_new_voicemail_ticker" msgid="895342132049452081">"ከ<xliff:g id="CALLER">%1$s</xliff:g> አዲስ የድምፅመልዕክት"</string>
     <string name="voicemail_playback_error" msgid="1811242131549854624">"ድምፅ ደብዳቤን ማጫወት አልተቻለም፡፡"</string>
     <string name="voicemail_buffering" msgid="738287747618697097">"በማቋት ላይ???"</string>
     <string name="voicemail_fetching_content" msgid="877911315738258780">"ድምፅ ደብዳቤ ፈልጎ በማግኘት ላይ???"</string>
     <string name="voicemail_fetching_timout" msgid="6691792377574905201">"ድምፅ ደብዳቤን ፈልጎ ማግኘት አልተቻለም፡፡"</string>
-    <!-- no translation found for call_log_new_header (846546437517724715) -->
-    <skip />
-    <!-- no translation found for call_log_old_header (6262205894314263629) -->
-    <skip />
-    <!-- no translation found for voicemail_status_voicemail_not_available (3164200979671881947) -->
-    <skip />
-    <!-- no translation found for voicemail_status_messages_waiting (2970301042310727909) -->
-    <skip />
-    <!-- no translation found for voicemail_status_configure_voicemail (3940240432123700974) -->
-    <skip />
-    <!-- no translation found for voicemail_status_audio_not_available (3369618334553341626) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_configure (7008713959076506385) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_call_server (1824816252288551794) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slowest (6047030504814773029) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slower (7890393922358642543) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_normal (6030110237820243006) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_faster (4161478290979905481) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_fastest (3373646875150544205) -->
-    <skip />
+    <string name="call_log_new_header" msgid="846546437517724715">"አዲስ"</string>
+    <string name="call_log_old_header" msgid="6262205894314263629">"የድሮ"</string>
+    <string name="voicemail_status_voicemail_not_available" msgid="3164200979671881947">"ወደ ድምፅ መልዕክት አገልጋይ ለመገናኘት አልተቻለም።"</string>
+    <string name="voicemail_status_messages_waiting" msgid="2970301042310727909">"ወደ ድምፅ መልዕክት ለማያያዝ  አልተቻለም። አዲስ የድምፅ መልዕክቶች በመጠበቅ ላይ ።"</string>
+    <string name="voicemail_status_configure_voicemail" msgid="3940240432123700974">"የድምፅ መልዕክቶች አዋቅር።"</string>
+    <string name="voicemail_status_audio_not_available" msgid="3369618334553341626">"ኦዲዮ አልተገኘም።"</string>
+    <string name="voicemail_status_action_configure" msgid="7008713959076506385">"አዋቅር"</string>
+    <string name="voicemail_status_action_call_server" msgid="1824816252288551794">"የድምፅመልዕክት ደውል"</string>
+    <string name="voicemail_speed_slowest" msgid="6047030504814773029">"በጣም ቀርፋፋ ፍጥነት"</string>
+    <string name="voicemail_speed_slower" msgid="7890393922358642543">"ቀርፋፋ ፍጥነት"</string>
+    <string name="voicemail_speed_normal" msgid="6030110237820243006">"መደበኛ ፍጥነት"</string>
+    <string name="voicemail_speed_faster" msgid="4161478290979905481">"ፈጣን ፍጥነት"</string>
+    <string name="voicemail_speed_fastest" msgid="3373646875150544205">"በጣም ፈጣን ፍጥነት"</string>
     <string name="call_log_item_count_and_date" msgid="7641933305703520787">"(<xliff:g id="COUNT">%1$d</xliff:g>) <xliff:g id="DATE">%2$s</xliff:g>"</string>
-    <!-- no translation found for group_name_hint (2659811836386413509) -->
-    <skip />
-    <!-- no translation found for nfc_vcard_file_name (2823095213265993609) -->
-    <skip />
-    <!-- no translation found for menu_show_voicemails_only (1898421289561435703) -->
-    <skip />
+    <string name="group_name_hint" msgid="2659811836386413509">"የቡድኑ ስም"</string>
+    <string name="nfc_vcard_file_name" msgid="2823095213265993609">"በ NFC  የደረሱ ዕውቂያዎች"</string>
+    <string name="menu_show_voicemails_only" msgid="1898421289561435703">"የድምፅ መልዕክቶች ብቻ አሳይ"</string>
     <string name="menu_show_all_calls" msgid="7560347482073345885">"ሁሉንም ጥሪዎች አሳይ"</string>
-    <!-- no translation found for status_available (5586870015822828392) -->
-    <skip />
-    <!-- no translation found for status_away (1838861100379804730) -->
-    <skip />
-    <!-- no translation found for status_busy (9147992455450257136) -->
-    <skip />
-    <!-- no translation found for description_call_log_call_button (8207201401459528442) -->
-    <skip />
-    <!-- no translation found for description_call_log_play_button (651182125650429846) -->
-    <skip />
-    <!-- no translation found for description_call_log_incoming_call (4485427487637250143) -->
-    <skip />
-    <!-- no translation found for description_call_log_outgoing_call (604831756853471658) -->
-    <skip />
-    <!-- no translation found for description_call_log_missed_call (2242805209983708825) -->
-    <skip />
-    <!-- no translation found for description_call_log_voicemail (4600798771975158948) -->
-    <skip />
+    <string name="status_available" msgid="5586870015822828392">"የሚገኝ"</string>
+    <string name="status_away" msgid="1838861100379804730">"ወጣ ብሏል"</string>
+    <string name="status_busy" msgid="9147992455450257136">"ተይዟ ል"</string>
+    <string name="description_call_log_call_button" msgid="8207201401459528442">"ቁጥር ደውል።"</string>
+    <string name="description_call_log_play_button" msgid="651182125650429846">"የድምፅ መልዕክት አጫውት"</string>
+    <string name="description_call_log_incoming_call" msgid="4485427487637250143">"ገቢ ጥሪ"</string>
+    <string name="description_call_log_outgoing_call" msgid="604831756853471658">"ወጪ ጥሪ"</string>
+    <string name="description_call_log_missed_call" msgid="2242805209983708825">"ያመለጠ  ጥሪ"</string>
+    <string name="description_call_log_voicemail" msgid="4600798771975158948">"የድምፅ መልዕክት"</string>
     <string name="description_add_contact" msgid="3103414772502485851">"እውቅያዎች አክል"</string>
     <string name="description_view_contact" msgid="5205669345700598415">"ዕውቂያ <xliff:g id="NAME">%1$s</xliff:g> ዕይ"</string>
     <string name="description_call" msgid="3443678121983852666">"ጥሪ <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"የፅሁፍ መልዕክት ወደ <xliff:g id="NAME">%1$s</xliff:g> ላክ"</string>
-    <!-- no translation found for description_call_log_unheard_voicemail (118101684236996786) -->
+    <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"ያልተሰማ የድምፅመልዕክት"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
     <skip />
-    <!-- no translation found for call_log_empty_gecode (5588904744812100846) -->
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
     <skip />
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"እኔ"</string>
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
+    <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"እኔ"</string>
     <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>
diff --git a/res/values-ar/strings.xml b/res/values-ar/strings.xml
index 911f1df..300b8ae 100644
--- a/res/values-ar/strings.xml
+++ b/res/values-ar/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"صورة جهة الاتصال"</string>
     <string name="description_minus_button" msgid="387136707700230172">"علامة الطرح"</string>
     <string name="description_plus_button" msgid="515164827856229880">"علامة زائد"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"عرض جهة الاتصال"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"وحدة التخزين غير متوفرة."</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"لا بطاقة SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"لم يتم اكتشاف أية وحدة تخزين."</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"الاتصال بـ <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"إرسال رسالة نصية إلى <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"البريد الصوتي غير المسموع"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"أنا"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"أنا"</string>
     <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="7061052512446855192">"تعمل الأشخاص بشكل أفضل مع حساب Google."\n\n"• يمكنك الدخول من أي متصفح ويب."\n"• يمكنك نسخ جهات اتصالك احتياطيًا بشكل آمن."</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"يعمل تطبيق \"الأشخاص\" بشكل أفضل مع حساب Google.‏"\n\n"• يمكنك الدخول من أي متصفح ويب."\n"• يمكنك نسخ جهات اتصالك احتياطيًا بشكل آمن."</string>
 </resources>
diff --git a/res/values-bg/strings.xml b/res/values-bg/strings.xml
index 0d23995..e8dee67 100644
--- a/res/values-bg/strings.xml
+++ b/res/values-bg/strings.xml
@@ -550,11 +550,16 @@
     <string name="description_call" msgid="3443678121983852666">"Обаждане до <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Изпращане на SMS до <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Непрослушана гласова поща"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"–"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"АЗ"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Аз"</string>
     <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>
-    <!-- no translation found for no_account_prompt (7061052512446855192) -->
-    <skip />
+    <string name="no_account_prompt" msgid="7061052512446855192">"Приложението Хора работи по-добре с профил в Google."\n\n"• Осъществявайте достъп от всеки уеб браузър."\n"• Създавайте надеждни резервни копия на контактите си."</string>
 </resources>
diff --git a/res/values-ca/strings.xml b/res/values-ca/strings.xml
index 98cfa69..327c82b 100644
--- a/res/values-ca/strings.xml
+++ b/res/values-ca/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"foto del contacte"</string>
     <string name="description_minus_button" msgid="387136707700230172">"menys"</string>
     <string name="description_plus_button" msgid="515164827856229880">"més"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Mostra el contacte"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Emmagatzematge no dispon."</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"No hi ha cap targeta SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"No s\'ha detectat cap emmagatzematge"</string>
@@ -550,6 +548,9 @@
     <string name="description_call" msgid="3443678121983852666">"Truca a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Envia un missatge de text a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Missatge de veu no escoltat"</string>
+    <string name="description_send_message" msgid="6046623392322890962">"Envia un missatge a <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_dial_phone_number" msgid="8831647331642648637">"Marca el telèfon <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_quick_contact_for" msgid="6737516415168327789">"Contacte ràpid per a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Usuari"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"El meu perfil local"</string>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index 7c08c2c..dbf1956 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"fotografie kontaktu"</string>
     <string name="description_minus_button" msgid="387136707700230172">"mínus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Zobrazit kontakt"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Úložiště je nedostupné"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Žádná karta SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Nebylo nalezeno žádné úložiště"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Volat kontakt <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Odeslat textovou zprávu kontaktu <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nevyslechnutá hlasová zpráva"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"–"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JÁ"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Já"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Můj místní profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Můj profil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Zobrazují se všechny kontakty"</string>
diff --git a/res/values-da/strings.xml b/res/values-da/strings.xml
index 1806751..df80128 100644
--- a/res/values-da/strings.xml
+++ b/res/values-da/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"kontaktpersonfoto"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Vis kontaktperson"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Lager ikke tilgængeligt"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Der er intet SD-kort"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Intet lager fundet"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Ring til <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Send sms til <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Uaflyttet besked på telefonsvareren"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"MIG"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Mig"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Min lokale profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Min <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>-profil"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Viser alle kontaktpersoner"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index fd9aa70..2e90835 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -550,10 +550,16 @@
     <string name="description_call" msgid="3443678121983852666">"<xliff:g id="NAME">%1$s</xliff:g> anrufen"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"SMS an <xliff:g id="NAME">%1$s</xliff:g> senden"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nicht abgehörte Mailbox-Nachricht"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ich"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ich"</string>
     <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="7061052512446855192">"Die Personenfunktion funktioniert besser mit einem Google-Konto."\n\n"• Zugriff über einen beliebigen Webbrowser"\n"• Sichern von Kontakten mit Schutzfunktion"</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"Die Personenfunktion funktioniert besser mit einem Google-Konto."\n\n"• Zugriff über einen beliebigen Browser"\n"• Sichern von Kontakten mit Schutzfunktion"</string>
 </resources>
diff --git a/res/values-el/strings.xml b/res/values-el/strings.xml
index 4fac77d..2e36579 100644
--- a/res/values-el/strings.xml
+++ b/res/values-el/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"φωτογραφία επαφής"</string>
     <string name="description_minus_button" msgid="387136707700230172">"μείον"</string>
     <string name="description_plus_button" msgid="515164827856229880">"συν"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Προβολή επαφής"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Μη διαθέσιμος χώρος αποθ."</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Δεν υπάρχει κάρτα SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Δεν εντοπίστηκε χώρος αποθ."</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Κλήση του χρήστη <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Αποστολή μηνύματος κειμένου στον χρήστη <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Μηνύματα αυτόματου τηλεφωνητή που δεν έχετε ακούσει"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"ΕΓΩ"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Εγώ"</string>
     <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>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index 9d1624a..4751db2 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"contact photo"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"View contact"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Storage unavailable"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"No SD card"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"No storage detected"</string>
@@ -550,6 +548,9 @@
     <string name="description_call" msgid="3443678121983852666">"Call <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Send text message to <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Unheard voicemail"</string>
+    <string name="description_send_message" msgid="6046623392322890962">"Send message to <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_dial_phone_number" msgid="8831647331642648637">"Dial phone <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_quick_contact_for" msgid="6737516415168327789">"Quick contact for <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Me"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"My local profile"</string>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index e52d3ee..a769157 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -550,8 +550,14 @@
     <string name="description_call" msgid="3443678121983852666">"Llamar a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Enviar mensaje de texto a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Buzón de voz no escuchado"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"YO"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Yo"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mi perfil local"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Mi perfil de <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Mostrar todos los contactos"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index 66aea8d..e46e8fe 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"foto de contacto"</string>
     <string name="description_minus_button" msgid="387136707700230172">"menos"</string>
     <string name="description_plus_button" msgid="515164827856229880">"más"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Ver contacto"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Almacenamiento no disponible"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Falta la tarjeta SD."</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Sin almacenamiento detectado"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Llamar a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Enviar mensaje de texto a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Mensaje de voz sin oír"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"YO"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Yo"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mi perfil local"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Mi perfil de <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Mostrando todos los contactos"</string>
diff --git a/res/values-fa/strings.xml b/res/values-fa/strings.xml
index 8046e9c..b682780 100644
--- a/res/values-fa/strings.xml
+++ b/res/values-fa/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"عکس مخاطب"</string>
     <string name="description_minus_button" msgid="387136707700230172">"منها"</string>
     <string name="description_plus_button" msgid="515164827856229880">"به اضافه"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"مشاهده مخاطب"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"حافظه در دسترس نیست"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"کارت SD موجود نیست"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"حافظه ای شناسایی نشد"</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"تماس با <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"ارسال پیام متنی به <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"پست صوتی شنیده نشده"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"من"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"من"</string>
     <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="7061052512446855192">"People با یک حساب Google بهتر کار می‌کند."\n\n"• از هر مرورگر وب به آن دسترسی دارید"\n"• از رویدادهای خود به طور امن پشتیبان تهیه می‌کنید"</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"People با یک حساب Google بهتر کار می‌کند."\n\n"• از هر مرورگر وب به آن دسترسی دارید"\n"• از رویدادهای خود به طور امن پشتیبان تهیه کنید"</string>
 </resources>
diff --git a/res/values-fi/strings.xml b/res/values-fi/strings.xml
index 11c2fc5..985b34f 100644
--- a/res/values-fi/strings.xml
+++ b/res/values-fi/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"yhteystiedon valokuva"</string>
     <string name="description_minus_button" msgid="387136707700230172">"miinus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Näytä yhteystieto"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Tallennustila ei käytettävissä"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Ei SD-korttia"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Tallennustilaa ei havaittu"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Soita: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Lähetä tekstiviesti: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Kuuntelematon vastaajaviesti"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Minä"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Minä"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Oma paikallinen profiili"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Oma <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>-profiili"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Kaikki kontaktit"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index f75b44d..62fc8e3 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -161,12 +161,12 @@
     <string name="simContacts_title" msgid="27341688347689769">"Contacts de carte SIM"</string>
     <string name="noContactsHelpTextWithSyncForCreateShortcut" msgid="801504710275614594">"Vous n\'avez aucun contact à afficher. Si vous venez d\'ajouter un compte, la synchronisation des contacts peut prendre quelques minutes."</string>
     <string name="noContactsHelpTextForCreateShortcut" msgid="3081286388667108335">"Vous n\'avez aucun contact à afficher."</string>
-    <!-- syntax error in translation for noContactsHelpText (6450346791169710787) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:560 in java.io.StringReader@5495fd19)  -->
-    <!-- syntax error in translation for noContactsHelpText (7633826236417884130) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:567 in java.io.StringReader@431b9fb1)  -->
+    <!-- syntax error in translation for noContactsHelpText (6450346791169710787) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:560 in java.io.StringReader@761a626f)  -->
+    <!-- syntax error in translation for noContactsHelpText (7633826236417884130) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:567 in java.io.StringReader@3e34a1fc)  -->
     <string name="noContactsHelpTextWithSync" product="tablet" msgid="2364665535969139880">"Vous n\'avez aucun contact à afficher (si vous venez d\'ajouter un compte, la synchronisation des contacts peut prendre quelques minutes)."\n\n"Pour ajouter des contacts, appuyez sur "<font fgcolor="#ffffffff"><b>"Menu"</b></font>", puis sur :"\n" "\n<li><font fgcolor="#ffffffff"><b>"Comptes"</b></font>" pour ajouter ou configurer un compte dont vous pourrez synchroniser les contacts vers la tablette ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Options d\'affichage"</b></font>" pour modifier les paramètres de visibilité des contacts ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Nouveau contact"</b></font>" pour créer un contact ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importer/Exporter"</b></font>" pour importer des contacts depuis votre carte SIM ou SD."\n</li></string>
     <string name="noContactsHelpTextWithSync" product="default" msgid="3017521127042216243">"Vous n\'avez aucun contact à afficher (si vous venez d\'ajouter un compte, la synchronisation des contacts peut prendre quelques minutes)."\n\n"Pour ajouter des contacts, appuyez sur "<font fgcolor="#ffffffff"><b>"Menu"</b></font>" et sélectionnez :"\n" "\n<li><font fgcolor="#ffffffff"><b>"Comptes"</b></font>" pour ajouter ou configurer un compte dont vous pourrez synchroniser les contacts sur le téléphone ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Options d\'affichage"</b></font>" pour modifier le paramètre de visibilité des contacts ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Nouveau contact"</b></font>" pour créer un contact ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importer/Exporter"</b></font>" pour importer des contacts depuis votre carte SIM ou SD."\n</li></string>
-    <!-- syntax error in translation for noContactsNoSimHelpText (6031363021287849874) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:565 in java.io.StringReader@4a913fe2)  -->
-    <!-- syntax error in translation for noContactsNoSimHelpText (467658807711582876) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:571 in java.io.StringReader@5f934ad)  -->
+    <!-- syntax error in translation for noContactsNoSimHelpText (6031363021287849874) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:565 in java.io.StringReader@7176c74b)  -->
+    <!-- syntax error in translation for noContactsNoSimHelpText (467658807711582876) org.xmlpull.v1.XmlPullParserException: expected: /b read: font (position:END_TAG </font>@1:571 in java.io.StringReader@2d16471f)  -->
     <string name="noContactsNoSimHelpTextWithSync" product="tablet" msgid="6222739731808897565">"Vous n\'avez aucun contact à afficher (si vous venez d\'ajouter un compte, la synchronisation des contacts peut prendre quelques minutes)."\n\n"Pour ajouter des contacts, appuyez sur "<font fgcolor="#ffffffff"><b>"Menu"</b></font>", puis sur :"\n" "\n<li><font fgcolor="#ffffffff"><b>"Comptes"</b></font>" pour ajouter ou configurer un compte dont vous pourrez synchroniser les contacts vers la tablette ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Options d\'affichage"</b></font>" pour modifier les paramètres de visibilité des contacts ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Nouveau contact"</b></font>" pour créer un contact ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importer/Exporter"</b></font>" pour importer des contacts depuis votre carte SD."\n</li></string>
     <string name="noContactsNoSimHelpTextWithSync" product="default" msgid="9040060730467973050">"Vous n\'avez aucun contact à afficher (si vous venez d\'ajouter un compte, la synchronisation des contacts peut prendre quelques minutes)."\n\n"Pour ajouter des contacts, appuyez sur "<font fgcolor="#ffffffff"><b>"Menu"</b></font>" et sélectionnez :"\n" "\n<li><font fgcolor="#ffffffff"><b>"Comptes"</b></font>" pour ajouter ou configurer un compte dont vous pourrez synchroniser les contacts sur le téléphone ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Options d\'affichage"</b></font>" pour modifier le paramètre de visibilité des contacts ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Nouveau contact"</b></font>" pour créer un contact ;"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importer/Exporter"</b></font>" pour importer des contacts depuis votre carte SD."\n</li></string>
     <string name="noFavoritesHelpText" msgid="3744655776704833277">"Vous ne disposez d\'aucun favoris."\n\n"Pour ajouter un contact à la liste de favoris :"\n\n"        "<li>"Appuyez sur l\'onglet "<b>"Contacts"</b>"."\n</li>" "\n<li>"Appuyez sur le contact à ajouter à vos favoris."\n</li>" "\n<li>"Appuyez sur l\'étoile en regard du nom du contact."\n</li></string>
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"photo du contact"</string>
     <string name="description_minus_button" msgid="387136707700230172">"moins"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Afficher le contact"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Mémoire non disponible"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Aucune carte SD trouvée"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Aucune mémoire stockage détectée"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Appeler <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Envoyer un SMS à <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nouveau message vocal"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"MOI"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Moi"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mon profil local"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Mon profil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Affichage de tous les contacts"</string>
diff --git a/res/values-hr/strings.xml b/res/values-hr/strings.xml
index cd2f5b7..e510bf9 100644
--- a/res/values-hr/strings.xml
+++ b/res/values-hr/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"fotografija kontakta"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Prikaži kontakt"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Prostor za pohranu nedostupan"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Nema SD kartice"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Pohrana nije otkrivena"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Pozovi: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Slanje tekstualne poruke: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nepreslušana govorna pošta"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JA"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ja"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Moj lokalni profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Moj <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> profil"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Prikaz svih kontakata"</string>
diff --git a/res/values-hu/strings.xml b/res/values-hu/strings.xml
index afc003e..6e459e5 100644
--- a/res/values-hu/strings.xml
+++ b/res/values-hu/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"fotó a névjegyhez"</string>
     <string name="description_minus_button" msgid="387136707700230172">"mínusz"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plusz"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Névjegy megtekintése"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"A tárhely nem érhető el"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Hiányzó SD-kártya"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Nem észlelhető tárhely"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"<xliff:g id="NAME">%1$s</xliff:g> hívása"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"SMS küldése neki: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nem lejátszott hangüzenet"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"ÉN"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Én"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Helyi profilom"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"<xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> profilom"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Az összes névjegy megjelenítése"</string>
diff --git a/res/values-in/strings.xml b/res/values-in/strings.xml
index 9c51845..512dd1b 100644
--- a/res/values-in/strings.xml
+++ b/res/values-in/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"foto kenalan"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Lihat kenalan"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Penyimpanan tidak tersedia"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Tidak ada kartu SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Penyimpanan tidak terdeteksi"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Panggil <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Kirim SMS ke <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Pesan suara yang belum didengar"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"SAYA"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Saya"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Profil lokal saya"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Profil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> saya"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Menampilkan semua kenalan"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index ea9f73e..566428a 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"foto contatto"</string>
     <string name="description_minus_button" msgid="387136707700230172">"meno"</string>
     <string name="description_plus_button" msgid="515164827856229880">"più"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Visualizza contatto"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Archivio non disponibile"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Nessuna scheda SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Nessun archivio rilevato"</string>
@@ -550,6 +548,9 @@
     <string name="description_call" msgid="3443678121983852666">"Chiama <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Invia messaggio di testo a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Messaggio vocale non ascoltato"</string>
+    <string name="description_send_message" msgid="6046623392322890962">"Invia messaggio a <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_dial_phone_number" msgid="8831647331642648637">"Componi numero di telefono <xliff:g id="NAME">%1$s</xliff:g>"</string>
+    <string name="description_quick_contact_for" msgid="6737516415168327789">"Contatto rapido per <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Io"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Il mio profilo locale"</string>
diff --git a/res/values-iw/strings.xml b/res/values-iw/strings.xml
index 4de9cea..13a5ec5 100644
--- a/res/values-iw/strings.xml
+++ b/res/values-iw/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"תמונה של איש קשר"</string>
     <string name="description_minus_button" msgid="387136707700230172">"חיסור"</string>
     <string name="description_plus_button" msgid="515164827856229880">"חיבור"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"הצג איש קשר"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"אמצעי אחסון אינו זמין"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"אין כרטיס SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"לא זוהה אמצעי אחסון"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"התקשר אל <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"שלח הודעת טקסט אל <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"דואר קולי שעדיין לא נשמע"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"אני"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"אני"</string>
     <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>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index 2853f8d..06babc6 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -550,11 +550,16 @@
     <string name="description_call" msgid="3443678121983852666">"<xliff:g id="NAME">%1$s</xliff:g>に発信"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"<xliff:g id="NAME">%1$s</xliff:g>にテキストメッセージを送信"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"未再生のボイスメール"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"自分"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"自分"</string>
     <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>
-    <!-- no translation found for no_account_prompt (7061052512446855192) -->
-    <skip />
+    <string name="no_account_prompt" msgid="7061052512446855192">"Googleアカウントがあればユーザーアプリをもっと活用できます。"\n\n"• どのウェブブラウザからもアクセスできます。"\n"• 連絡先を安全にバックアップできます。"</string>
 </resources>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index 2931b9a..77ae99d 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"주소록 사진"</string>
     <string name="description_minus_button" msgid="387136707700230172">"빼기"</string>
     <string name="description_plus_button" msgid="515164827856229880">"더하기"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"연락처 보기"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"저장장치 없음"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"SD 카드 없음"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"저장장치가 없습니다."</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"<xliff:g id="NAME">%1$s</xliff:g>님에게 전화걸기"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"<xliff:g id="NAME">%1$s</xliff:g>님에게 문자 메시지 보내기"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"듣지 않은 음성사서함"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"나"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"나"</string>
     <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="7061052512446855192">"Google 계정이 있으면 업무 효율이 높아집니다."\n\n"• 어떤 웹 브라우저에서든 액세스하세요."\n"• 주소록을 안전하게 백업하세요."</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"인물 앱은 Google 계정에서 사용할 때 더 효과적입니다."\n\n"• 어떤 웹 브라우저에서든 액세스하세요."\n"• 주소록을 안전하게 백업하세요."</string>
 </resources>
diff --git a/res/values-lt/strings.xml b/res/values-lt/strings.xml
index 5ff315e..f3f4193 100644
--- a/res/values-lt/strings.xml
+++ b/res/values-lt/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"adresato nuotrauka"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plius"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Peržiūrėti kontaktą"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Saugykla neprieinama"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Nėra SD kortelės"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Neaptikta jokių saugyklų"</string>
@@ -550,6 +548,12 @@
     <string name="description_call" msgid="3443678121983852666">"Skambinti <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Siųsti teksto pranešimą <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Neklausytas balso pašto pranešimas"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Aš"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mano vietos profilis"</string>
diff --git a/res/values-lv/strings.xml b/res/values-lv/strings.xml
index bf1ae9b..21aad59 100644
--- a/res/values-lv/strings.xml
+++ b/res/values-lv/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"kontaktpersonas fotoattēls"</string>
     <string name="description_minus_button" msgid="387136707700230172">"mīnuss"</string>
     <string name="description_plus_button" msgid="515164827856229880">"pluss"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Skatīt kontaktpersonu"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"USB atmiņa nav pieejama"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Nav SD kartes"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Nav atrasta neviena USB. atm."</string>
@@ -550,6 +548,12 @@
     <string name="description_call" msgid="3443678121983852666">"Zvanīt šim: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Sūtīt īsziņu šim: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nenoklausīti balss pasta ziņojumi"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Es"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mans vietējais profils"</string>
diff --git a/res/values-ms/strings.xml b/res/values-ms/strings.xml
index a68471c..401f635 100644
--- a/res/values-ms/strings.xml
+++ b/res/values-ms/strings.xml
@@ -552,8 +552,14 @@
     <string name="description_call" msgid="3443678121983852666">"Panggil <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Hantar mesej teks kepada <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Mel suara belum didengar"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"SAYA"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Saya"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Profil setempat saya"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Profil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> saya"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Memaparkan semua kenalan"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index 3ca8a63..5cc3148 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -161,12 +161,12 @@
     <string name="simContacts_title" msgid="27341688347689769">"Kontakter på SIM-kort"</string>
     <string name="noContactsHelpTextWithSyncForCreateShortcut" msgid="801504710275614594">"Du har ingen kontakter å vise. (Hvis du nettopp har lagt til en konto, kan det ta noen minutter å synkronisere kontaktene.)"</string>
     <string name="noContactsHelpTextForCreateShortcut" msgid="3081286388667108335">"Du har ingen kontakter å vise."</string>
-    <!-- syntax error in translation for noContactsHelpText (6450346791169710787) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:292 in java.io.StringReader@67ee3914)  -->
-    <!-- syntax error in translation for noContactsHelpText (7633826236417884130) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:293 in java.io.StringReader@48e5855a)  -->
+    <!-- syntax error in translation for noContactsHelpText (6450346791169710787) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:292 in java.io.StringReader@11975b59)  -->
+    <!-- syntax error in translation for noContactsHelpText (7633826236417884130) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:293 in java.io.StringReader@67ee3914)  -->
     <string name="noContactsHelpTextWithSync" product="tablet" msgid="2364665535969139880">"Du har ingen kontakter å vise. (Hvis du nylig la til en konto, kan det ta noen minutter å synkronisere kontaktene.)"\n\n"Slik legger du til kontakter: Trykk på "<font fgcolor="#ffffffff"><b>"Meny"</b></font>", og trykk deretter på:"\n" "\n<li><font fgcolor="#ffffffff"><b>"Kontoer"</b></font>" for å legge til eller konfigurere en konto med kontakter som kan synkroniseres til nettbrettet"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Visningsalternativer"</b></font>" for å endre hvilke kontakter som vises"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Ny kontakt"</b></font>" for å opprette en ny kontakt fra grunnen av"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importer/Eksporter"</b></font>" for å importere kontakter fra SIM- eller SD-kort"\n</li></string>
     <string name="noContactsHelpTextWithSync" product="default" msgid="3017521127042216243">"Du har ingen kontakter å vise. (Hvis du nylig la til en konto, kan det ta noen minutter å synkronisere kontaktene.)"\n\n"Slik legger du til kontakter: Trykk på "<font fgcolor="#ffffffff"><b>"Meny"</b></font>" og trykk deretter på: "\n" "\n<li><font fgcolor="#ffffffff"><b>"Kontoer "</b></font>" for å legge til eller konfigurere en konto med kontakter som kan synkroniseres til telefonen"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Visningsalternativer"</b></font>" for å endre hvilke kontakter som vises"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Ny kontakt"</b></font>" for å opprette en ny kontakt"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importér/Eksportér"</b></font>" for å importere kontakter fra SIM- eller SD-kort"\n</li></string>
-    <!-- syntax error in translation for noContactsNoSimHelpText (6031363021287849874) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:297 in java.io.StringReader@5495fd19)  -->
-    <!-- syntax error in translation for noContactsNoSimHelpText (467658807711582876) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:297 in java.io.StringReader@431b9fb1)  -->
+    <!-- syntax error in translation for noContactsNoSimHelpText (6031363021287849874) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:297 in java.io.StringReader@48e5855a)  -->
+    <!-- syntax error in translation for noContactsNoSimHelpText (467658807711582876) org.xmlpull.v1.XmlPullParserException: expected: /li read: font (position:END_TAG </font>@1:297 in java.io.StringReader@5495fd19)  -->
     <string name="noContactsNoSimHelpTextWithSync" product="tablet" msgid="6222739731808897565">"Du har ingen kontakter å vise. (Hvis du nylig la til en konto, kan det ta noen minutter å synkronisere kontaktene.)"\n\n"Slik legger du til kontakter: Trykk på "<font fgcolor="#ffffffff"><b>"Meny"</b></font>", og trykk deretter på: "\n" "\n<li><font fgcolor="#ffffffff"><b>"Kontoer"</b></font>" for å legge til eller konfigurere en konto med kontakter som kan synkroniseres til nettbrettet"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Visningsalternativer"</b></font>" for å endre hvilke kontakter som vises"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Ny kontakt"</b></font>" for å opprette en ny kontakt fra grunnen av"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importer/eksporter"</b></font>" for å importere kontakter fra SD-kortet"\n</li></string>
     <string name="noContactsNoSimHelpTextWithSync" product="default" msgid="9040060730467973050">"Du har ingen kontakter å vise. (Hvis du nylig la til en konto, kan det ta noen minutter å synkronisere kontaktene.)"\n\n"Slik legger du til kontakter: Trykk på "<font fgcolor="#ffffffff"><b>"Meny"</b></font>" og trykk deretter på: "\n" "\n<li><font fgcolor="#ffffffff"><b>"Kontoer "</b></font>" for å legge til eller konfigurere en konto med kontakter som kan synkroniseres til telefonen"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Visningsalternativer"</b></font>" for å endre hvilke kontakter som vises"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Ny kontakt"</b></font>" for å opprette en ny kontakt"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Importér/eksportér"</b></font>" for å importere kontakter fra SD-kortet"\n</li></string>
     <string name="noFavoritesHelpText" msgid="3744655776704833277">"Du har ingen favoritter."\n\n"Slik legger du til en kontakt i favorittlisten:"\n\n" "<li>"Trykk på fanen "<b>"Kontakter"</b>" "\n</li>" "\n<li>"Trykk på kontakten du vil legge til i favoritter"\n</li>" "\n<li>"Trykk på stjernen ved siden av kontaktnavnet"\n</li></string>
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"kontaktens bilde"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minusknapp"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plussknapp"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Se kontakt"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Lagring utilgjengelig"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Mangler minnekort"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Ingen lagring oppdaget"</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"Ring til <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Send tekstmelding til <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Ikke avspilt talepost"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"–"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JEG"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Meg"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Min lokale profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Min profil for <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Viser alle kontakter"</string>
-    <string name="no_account_prompt" msgid="7061052512446855192">"People fungerer bedre med en Google-konto."\n\n"• Tilgang fra hvilken som helst nettleser."\n"• Sikkerhetskopier kontaktene sikkert."</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"People fungerer bedre med en Google-konto."\n\n"• Tilgang fra hvilken som helst nettleser."\n"• Ta trygge sikkerhetskopier av kontaktene dine."</string>
 </resources>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 88dbecb..49cdc1f 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -550,8 +550,14 @@
     <string name="description_call" msgid="3443678121983852666">"<xliff:g id="NAME">%1$s</xliff:g> bellen"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Sms verzenden naar <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Niet-beluisterde voicemail"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"IK"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ik"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mijn lokale profiel"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Mijn <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>-profiel"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Alle contacten worden weergegeven"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index c5f39ad..a21d08b 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"zdjęcie kontaktu"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Wyświetl kontakt"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Nośnik nie jest dostępny"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Brak karty SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Nie wykryto nośnika"</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"Połącz z: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Wyślij SMS do: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nieodsłuchana poczta głosowa"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"–"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JA"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ja"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Mój profil lokalny"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Mój profil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Wyświetlanie wszystkich kontaktów"</string>
-    <string name="no_account_prompt" msgid="7061052512446855192">"Aplikacja Ludzie działa lepiej z kontem Google."\n\n"• Używaj jej w dowolnej przeglądarce."\n"• Bezpiecznie twórz kopie zapasowe kontaktów."</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"Aplikacja Ludzie działa lepiej z kontem Google."\n\n"• Używaj jej w dowolnej przeglądarce."\n"• Twórz kopie zapasowe kontaktów."</string>
 </resources>
diff --git a/res/values-pt-rPT/strings.xml b/res/values-pt-rPT/strings.xml
index cc85608..0b44874 100644
--- a/res/values-pt-rPT/strings.xml
+++ b/res/values-pt-rPT/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"fotografia do contacto"</string>
     <string name="description_minus_button" msgid="387136707700230172">"menos"</string>
     <string name="description_plus_button" msgid="515164827856229880">"mais"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Ver contacto"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Armazen. indisponível"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Nenhum cartão SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Não há armazenamento detectado"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Ligar a <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Enviar mensagem de texto para <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Mensagem de correio de voz ainda não ouvida"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"EU"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Eu"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"O meu perfil local"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"O meu perfil do <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"A apresentar todos os contactos"</string>
diff --git a/res/values-pt/strings.xml b/res/values-pt/strings.xml
index c20ae96..f5c6d26 100644
--- a/res/values-pt/strings.xml
+++ b/res/values-pt/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"foto do contato"</string>
     <string name="description_minus_button" msgid="387136707700230172">"menos"</string>
     <string name="description_plus_button" msgid="515164827856229880">"mais"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Visualizar contato"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Armazenamento não disponível"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Nenhum cartão SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Nenhum armazenamento detectado"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Ligar para <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Enviar mensagem de texto para <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nova mensagem de voz"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"EU"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Eu"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Meu perfil local"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Meu perfil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Exibindo todos os contatos"</string>
diff --git a/res/values-rm/strings.xml b/res/values-rm/strings.xml
index a185eef..b16e50a 100644
--- a/res/values-rm/strings.xml
+++ b/res/values-rm/strings.xml
@@ -710,6 +710,12 @@
     <skip />
     <!-- no translation found for description_call_log_unheard_voicemail (118101684236996786) -->
     <skip />
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <!-- no translation found for call_log_empty_gecode (5588904744812100846) -->
     <skip />
     <!-- no translation found for user_profile_contacts_list_header (5582421742835006940) -->
diff --git a/res/values-ro/strings.xml b/res/values-ro/strings.xml
index 5bba77d..0933c87 100644
--- a/res/values-ro/strings.xml
+++ b/res/values-ro/strings.xml
@@ -550,11 +550,16 @@
     <string name="description_call" msgid="3443678121983852666">"Apelaţi pe <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Trimiteţi un mesaj text către <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Mesaje vocale neascultate"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"EU"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Eu"</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>
-    <!-- no translation found for no_account_prompt (7061052512446855192) -->
-    <skip />
+    <string name="no_account_prompt" msgid="7061052512446855192">"Aplicaţia Persoane funcţionează mai bine cu un Cont Google."\n\n"• Accesaţi aplicaţia din orice browser web."\n"• Creaţi în siguranţă copii de rezervă pentru agendă."</string>
 </resources>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index 172d422..a33d03b 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -118,7 +118,7 @@
     <string name="listTotalAllContactsZeroGroup" msgid="5448979458248027615">"Нет контактов в: <xliff:g id="NAME">%s</xliff:g>"</string>
     <string name="listAllContactsInAccount" msgid="7496143179265311758">"Контакты в <xliff:g id="NAME">%s</xliff:g>"</string>
     <string name="listSingleContact" msgid="6067813698903535563">"1 контакт"</string>
-    <string name="listCustomView" msgid="6950713892532194050">"Контакты в пользовательском представлении"</string>
+    <string name="listCustomView" msgid="6950713892532194050">"Пользовательский фильтр"</string>
   <plurals name="listFoundAllContacts">
     <item quantity="one" msgid="5517063038754171134">"Найдено: 1"</item>
     <item quantity="other" msgid="3852668542926965042">"Найдено: <xliff:g id="COUNT">%d</xliff:g>"</item>
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"фотография контакта"</string>
     <string name="description_minus_button" msgid="387136707700230172">"минус"</string>
     <string name="description_plus_button" msgid="515164827856229880">"плюс"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Просмотреть контакт"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Накопитель недоступен"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Нет SD-карты"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Накопитель не найден"</string>
@@ -550,6 +548,12 @@
     <string name="description_call" msgid="3443678121983852666">"Позвонить абоненту: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Отправить текстовое сообщение контакту: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Непрослушанные сообщения голосовой почты"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Я"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Мой локальный профиль"</string>
diff --git a/res/values-sk/strings.xml b/res/values-sk/strings.xml
index 1475225..59302e3 100644
--- a/res/values-sk/strings.xml
+++ b/res/values-sk/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"fotografia kontaktu"</string>
     <string name="description_minus_button" msgid="387136707700230172">"mínus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Zobraziť kontakt"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Uklad. pr. je nedostupný"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Žiadna karta SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Ukladací priestor sa nenašiel"</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"Volať kontakt <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Poslať textovú správu kontaktu <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Nevypočutá hlasová správa"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JA"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ja"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Môj miestny profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Môj profil <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Zobrazenie všetkých kontaktov"</string>
-    <string name="no_account_prompt" msgid="7061052512446855192">"Aplikácia Ľudia funguje lepšie s účtom Google."\n\n"• Môžete k nej pristupovať z akéhokoľvek webového prehliadača"\n"• Bezpečne zálohujte svoje udalosti."</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"Aplikácia Ľudia funguje lepšie s účtom Google."\n\n"• Môžete k nej pristupovať z akéhokoľvek webového prehliadača"\n"• Bezpečne zálohujte svoje kontakty."</string>
 </resources>
diff --git a/res/values-sl/strings.xml b/res/values-sl/strings.xml
index 2754c1c..3d589b1 100644
--- a/res/values-sl/strings.xml
+++ b/res/values-sl/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"fotografija stika"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Ogled stika"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Pomnilnik ni na voljo"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Ni kartice SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Ni pomnilnika"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Klicanje osebe <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Pošlji SMS osebi <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Neodprta glasovna pošta"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JAZ"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Jaz"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Moj lokalni profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Moj profil za <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Prikaz vseh stikov"</string>
diff --git a/res/values-sr/strings.xml b/res/values-sr/strings.xml
index 27012d7..5782828 100644
--- a/res/values-sr/strings.xml
+++ b/res/values-sr/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"фотографија контакта"</string>
     <string name="description_minus_button" msgid="387136707700230172">"минус"</string>
     <string name="description_plus_button" msgid="515164827856229880">"плус"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Прикажи контакт"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Меморија је недоступна"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Нема SD картице"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Није откривена меморија"</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"Позови корисника <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Слање текстуалне поруке контакту <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Непреслушана говорна пошта"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"ЈА"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ја"</string>
     <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="7061052512446855192">"Апликација Особе боље функционише са Google налогом."\n\n"• Приступајте из било ког веб прегледача."\n"• Безбедно направите резервне копије контаката."</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"Апликација Људи боље функционише са Google налогом."\n\n"• Приступајте из било ког веб прегледача."\n"• Безбедно направите резервне копије контаката."</string>
 </resources>
diff --git a/res/values-sv/strings.xml b/res/values-sv/strings.xml
index 0461d11..b9a325a 100644
--- a/res/values-sv/strings.xml
+++ b/res/values-sv/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"kontaktbild"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Visa kontakt"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Lagring otillgänglig"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Inget SD-kort"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Ingen lagringsenhet hittades"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Ring <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Skicka SMS till <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Ej hört röstmeddelande"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"JAG"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Jag"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Min lokala profil"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Min <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>-profil"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Visar alla kontakter"</string>
diff --git a/res/values-sw/strings.xml b/res/values-sw/strings.xml
index 4cc690a..79f1287 100644
--- a/res/values-sw/strings.xml
+++ b/res/values-sw/strings.xml
@@ -17,52 +17,33 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="launcherDialer" msgid="8636288196618486553">"Simu"</string>
-    <!-- no translation found for people (1048457247435785074) -->
-    <skip />
-    <!-- no translation found for contactsList (8661624236494819731) -->
-    <skip />
-    <!-- no translation found for shortcutContact (749243779392912958) -->
-    <skip />
+    <string name="people" msgid="1048457247435785074">"Watu"</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>
     <string name="shortcutMessageContact" msgid="2460337253595976198">"Ujumbe wa moja kwa moja"</string>
     <string name="shortcutActivityTitle" msgid="6642877210643565436">"Chagua njia ya mkato ya anwani"</string>
     <string name="callShortcutActivityTitle" msgid="6065749861423648991">"Chagua nambari ya kupiga"</string>
     <string name="messageShortcutActivityTitle" msgid="3084542316620335911">"Chagua nambari ya kutumia ujumbe"</string>
     <string name="contactPickerActivityTitle" msgid="6886592363525235031">"Chagua anwani"</string>
-    <!-- no translation found for starredList (4817256136413959463) -->
-    <skip />
-    <!-- no translation found for frequentList (7154768136473953056) -->
-    <skip />
-    <!-- no translation found for strequentList (5640192862059373511) -->
-    <skip />
-    <!-- no translation found for viewContactTitle (7989394521836644384) -->
-    <skip />
-    <!-- no translation found for viewContactDesription (214186610887547860) -->
-    <skip />
-    <!-- no translation found for editContactDescription (2947202828256214947) -->
-    <skip />
-    <!-- no translation found for insertContactDescription (4709878105452681987) -->
-    <skip />
-    <!-- no translation found for editGroupDescription (6321161304201540561) -->
-    <skip />
-    <!-- no translation found for insertGroupDescription (5658512271662210139) -->
-    <skip />
-    <!-- no translation found for contactDetailAbout (5430408883907061400) -->
-    <skip />
-    <!-- no translation found for contactDetailUpdates (3780588624763446941) -->
-    <skip />
-    <!-- no translation found for searchHint (8482945356247760701) -->
-    <skip />
+    <string name="starredList" msgid="4817256136413959463">"Zenye nyota"</string>
+    <string name="frequentList" msgid="7154768136473953056">"Mara kwa mara"</string>
+    <string name="strequentList" msgid="5640192862059373511">"Vipendwa"</string>
+    <string name="viewContactTitle" msgid="7989394521836644384">"Maelezo ya anwani"</string>
+    <string name="viewContactDesription" msgid="214186610887547860">"Angalia anwani"</string>
+    <string name="editContactDescription" msgid="2947202828256214947">"Hariri anwani"</string>
+    <string name="insertContactDescription" msgid="4709878105452681987">"Unda anwani"</string>
+    <string name="editGroupDescription" msgid="6321161304201540561">"Hariri kikundi"</string>
+    <string name="insertGroupDescription" msgid="5658512271662210139">"Unda kikundi"</string>
+    <string name="contactDetailAbout" msgid="5430408883907061400">"Kuhusu"</string>
+    <string name="contactDetailUpdates" msgid="3780588624763446941">"Visasisho"</string>
+    <string name="searchHint" msgid="8482945356247760701">"Tafuta anwani"</string>
     <string name="menu_search" msgid="9147752853603483719">"Tafuta"</string>
-    <!-- no translation found for menu_newContact (1209922412763274638) -->
-    <skip />
-    <!-- no translation found for menu_viewContact (2795575601596468581) -->
-    <skip />
+    <string name="menu_newContact" msgid="1209922412763274638">"Anwani mpya"</string>
+    <string name="menu_viewContact" msgid="2795575601596468581">"Angalia anwani"</string>
     <string name="menu_callNumber" msgid="5142851348489387516">"Piga simu <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for menu_addStar (2908478235715404876) -->
-    <skip />
-    <!-- no translation found for menu_removeStar (5844227078364227030) -->
-    <skip />
+    <string name="menu_addStar" msgid="2908478235715404876">"Ongeza kwa vipendwa"</string>
+    <string name="menu_removeStar" msgid="5844227078364227030">"Toa kutoka kwa vipendwa vyako"</string>
     <string name="menu_editContact" msgid="9042415603857662633">"Hariri"</string>
     <string name="menu_deleteContact" msgid="6788644058868189393">"Futa"</string>
     <string name="menu_call" msgid="3992595586042260618">"Mpigie"</string>
@@ -71,8 +52,7 @@
     <string name="menu_editGroup" msgid="5062005185370983720">"Hariri"</string>
     <string name="menu_deleteGroup" msgid="3486380004411482874">"Futa"</string>
     <string name="menu_new_contact_action_bar" msgid="8887818026717394343">"Mpya"</string>
-    <!-- no translation found for menu_new_group_action_bar (5055346725617932394) -->
-    <skip />
+    <string name="menu_new_group_action_bar" msgid="5055346725617932394">"Mpya"</string>
     <string name="splitConfirmation_title" msgid="2209511048593467012">"Tenganisha anwani"</string>
     <string name="splitConfirmation" msgid="1067993957986345974">"Una uhakika unataka kutenganisha anwani hii moja katika anwani anuwai?"</string>
     <string name="menu_joinAggregate" msgid="5027981918265667970">"Jiunge"</string>
@@ -82,81 +62,61 @@
     <string name="separatorJoinAggregateSuggestions" msgid="2831414448851313345">"Anwani zilizopendekezwa"</string>
     <string name="separatorJoinAggregateAll" msgid="7939932265026181043">"Anwani zote"</string>
     <string name="contactsJoinedMessage" msgid="7208148163607047389">"Anwani zimeunganishwa"</string>
-    <!-- no translation found for deleteConfirmation_title (6394309508930335204) -->
-    <skip />
-    <!-- no translation found for menu_set_ring_tone (8728345772068064946) -->
-    <skip />
+    <string name="deleteConfirmation_title" msgid="6394309508930335204">"Futa"</string>
+    <string name="menu_set_ring_tone" msgid="8728345772068064946">"Weka mlio wa simu"</string>
     <string name="menu_redirect_calls_to_vm" msgid="4181789196416396656">"Simu zote kwa barua ya sauti"</string>
     <string name="readOnlyContactWarning" msgid="1390849295342594265">"Huwezi kufuta anwani kutoka kwa akaunti zinazoweza kusomwa tu, lakini unaweza kuzificha katika orodha yako ya anwani."</string>
     <string name="readOnlyContactDeleteConfirmation" msgid="2137170726670196909">"Anwani hii ina maelezo kutoka kwa akaunti nyingi. Maelezo kutoka kwa akaunti za soma-tu zitafichwa katika orodha zako za anwani, sio kufutwa."</string>
     <string name="multipleContactDeleteConfirmation" msgid="938900978442960800">"Kufuta anwani hii kutafuta maelezo kutoka kwa akaunti nyingi."</string>
-    <!-- no translation found for deleteConfirmation (811706994761610640) -->
-    <skip />
+    <string name="deleteConfirmation" msgid="811706994761610640">"Kengele hii itafutwa."</string>
     <string name="menu_done" msgid="796017761764190697">"Kwisha"</string>
     <string name="menu_doNotSave" msgid="58593876893538465">"Ghairi"</string>
-    <!-- no translation found for menu_discard (6456087569315685632) -->
-    <skip />
-    <!-- no translation found for label_notes (8337354953278341042) -->
-    <skip />
+    <string name="menu_discard" msgid="6456087569315685632">"Tupa"</string>
+    <string name="label_notes" msgid="8337354953278341042">"Hati"</string>
     <string name="label_sip_address" msgid="124073911714324974">"Simu ya wavuti"</string>
-    <!-- no translation found for ghostData_company (5414421120553765775) -->
-    <skip />
+    <string name="ghostData_company" msgid="5414421120553765775">"Kampuni"</string>
     <string name="ghostData_title" msgid="7496735200318496110">"Jina la heshima"</string>
-    <!-- no translation found for invalidContactMessage (5816991830260044593) -->
-    <skip />
-    <!-- no translation found for pickerNewContactHeader (7750705279843568147) -->
-    <skip />
-    <!-- no translation found for phoneLabelsGroup (6468091477851199285) -->
-    <skip />
-    <!-- no translation found for emailLabelsGroup (8389931313045344406) -->
-    <skip />
-    <!-- no translation found for imLabelsGroup (3898238486262614027) -->
-    <skip />
+    <string name="invalidContactMessage" msgid="5816991830260044593">"Programu halipo."</string>
+    <string name="pickerNewContactHeader" msgid="7750705279843568147">"Unda akaunti mpya"</string>
+    <string name="phoneLabelsGroup" msgid="6468091477851199285">"Simu"</string>
+    <string name="emailLabelsGroup" msgid="8389931313045344406">"Barua pepe"</string>
+    <string name="imLabelsGroup" msgid="3898238486262614027">"Ujumbe wa Papo Hapo"</string>
     <string name="postalLabelsGroup" msgid="3487738141112589324">"Anwani"</string>
   <string-array name="otherLabels">
     <item msgid="8287841928119937597">"Shirika"</item>
     <item msgid="7196592230748086755">"Hati"</item>
   </string-array>
     <string name="photoPickerNotFoundText" product="tablet" msgid="6247290728908599701">"Hakuna picha inayopatikana kwenye kompyuta ndogo."</string>
-    <!-- outdated translation 6247290728908599701 -->     <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Hakuna picha inayopatikana kwenye kompyuta ndogo."</string>
+    <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Hakuna picha zinazopatikana kwenye simu."</string>
     <string name="attach_photo_dialog_title" msgid="5599827035558557169">"Picha ya anwani"</string>
     <string name="customLabelPickerTitle" msgid="1081475101983255212">"Jina maalum la lebo"</string>
     <string name="send_to_voicemail_checkbox" msgid="9001686764070676353">"Tuma simu moja kwa moja kwa barua ya sauti"</string>
     <string name="removePhoto" msgid="4898105274130284565">"Ondoa picha"</string>
-    <!-- no translation found for noContacts (4955659076981974652) -->
-    <skip />
-    <!-- no translation found for noGroups (7315200974181864731) -->
-    <skip />
-    <!-- no translation found for noAccounts (4742609114153797268) -->
-    <skip />
+    <string name="noContacts" msgid="4955659076981974652">"Hakuna anwani"</string>
+    <string name="noGroups" msgid="7315200974181864731">"Hakuna vikundi"</string>
+    <string name="noAccounts" msgid="4742609114153797268">"Ili kuunda vikundi unahitaji akaunti"</string>
     <string name="noMatchingContacts" msgid="4266283206853990471">"Hakuna anwani zinazolingana zilizopatikana."</string>
-    <!-- no translation found for noContactsWithPhoneNumbers (1605457050218824269) -->
-    <skip />
+    <string name="noContactsWithPhoneNumbers" msgid="1605457050218824269">"Hakuna anwani  zenye nambari za simu."</string>
     <string name="savingContact" msgid="4075751076741924939">"Inahifadhi anwani..."</string>
     <string name="savingDisplayGroups" msgid="2133152192716475939">"Inahifadhi chaguo za mwonyesho.."</string>
     <string name="contactSavedToast" msgid="9171862279493213075">"Anwani imehifadhiwa"</string>
     <string name="contactSavedErrorToast" msgid="9189098776225004666">"Hitilafu, haiwezi kuhifadhi mabadiliko ya anwani."</string>
     <string name="groupSavedToast" msgid="6675062559302493011">"Kikundi kimehifadhiwa"</string>
-    <!-- no translation found for groupSavedErrorToast (6434135707953150875) -->
-    <skip />
+    <string name="groupSavedErrorToast" msgid="6434135707953150875">"Hitilafu, haiwezi kuhifadhi mabadiliko ya kikundi."</string>
   <plurals name="listTotalPhoneContacts">
     <item quantity="one" msgid="3015357862286673986">"Anwani 1 yenye namba ya simu"</item>
     <item quantity="other" msgid="3299954047880968205">"Anwani <xliff:g id="COUNT">%d</xliff:g> zilizo na nambari ya simu"</item>
   </plurals>
-    <!-- outdated translation 2756295259674938869 -->     <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"Hakuna anwani zinazoonekana zenye nambari za simu"</string>
+    <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"Hakuna anwani zenye nambari za simu"</string>
   <plurals name="listTotalAllContacts">
     <item quantity="one" msgid="3405747744700823280">"Anwani 1"</item>
     <item quantity="other" msgid="3578469907265375314">"Anwani <xliff:g id="COUNT">%d</xliff:g>"</item>
   </plurals>
-    <!-- outdated translation 6811347506748072822 -->     <string name="listTotalAllContactsZero" msgid="1889349925514589304">"Hakuna anwani zinazoonekana"</string>
-    <!-- no translation found for listTotalAllContactsZeroCustom (4058252141420128998) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroStarred (1289318488170099285) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroGroup (5448979458248027615) -->
-    <skip />
-    <!-- no translation found for listAllContactsInAccount (7496143179265311758) -->
-    <skip />
+    <string name="listTotalAllContactsZero" msgid="1889349925514589304">"Hakuna anwani"</string>
+    <string name="listTotalAllContactsZeroCustom" msgid="4058252141420128998">"Hakuna anwani zinazoonekana"</string>
+    <string name="listTotalAllContactsZeroStarred" msgid="1289318488170099285">"Hakuna Vipendwa"</string>
+    <string name="listTotalAllContactsZeroGroup" msgid="5448979458248027615">"Hakuna anwani kwenye <xliff:g id="NAME">%s</xliff:g>"</string>
+    <string name="listAllContactsInAccount" msgid="7496143179265311758">"Anwani kwenye <xliff:g id="NAME">%s</xliff:g>"</string>
     <string name="listSingleContact" msgid="6067813698903535563">"Mhusika mmoja"</string>
     <string name="listCustomView" msgid="6950713892532194050">"Mawasiliano katika mwoneko maalum"</string>
   <plurals name="listFoundAllContacts">
@@ -169,53 +129,36 @@
     <item quantity="one" msgid="4826918429708286628">"Patikana 1"</item>
     <item quantity="other" msgid="7988132539476575389">"<xliff:g id="COUNT">%d</xliff:g> zimepatikana"</item>
   </plurals>
-    <!-- no translation found for contactsAllLabel (6178225597569649305) -->
-    <skip />
-    <!-- no translation found for contactsGroupsLabel (2841971472518003524) -->
-    <skip />
-    <!-- no translation found for contactsFavoritesLabel (8417039765586853670) -->
-    <skip />
+    <string name="contactsAllLabel" msgid="6178225597569649305">"Zote"</string>
+    <string name="contactsGroupsLabel" msgid="2841971472518003524">"Vikundi"</string>
+    <string name="contactsFavoritesLabel" msgid="8417039765586853670">"Vipendwa"</string>
     <string name="dialerIconLabel" msgid="6500826552823403796">"Simu"</string>
-    <!-- no translation found for recentCallsIconLabel (1419116422359067949) -->
-    <skip />
+    <string name="recentCallsIconLabel" msgid="1419116422359067949">"Logi ya kupiga simu"</string>
     <string name="liveFolderAll" msgid="4789010460767506206">"Anwani zote"</string>
     <string name="liveFolderFavorites" msgid="3100957542927222282">"Anwani zenye nyota"</string>
     <string name="liveFolderPhone" msgid="3739376066610926780">"Anwani zenye nambari za simu"</string>
     <string name="menu_sendTextMessage" msgid="6937343460284499306">"Tuma ujumbe wa maandishi"</string>
     <string name="recentCalls_callNumber" msgid="1756372533999226126">"Pigia <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for recentCalls_editNumberBeforeCall (7756171675833267857) -->
-    <skip />
-    <!-- no translation found for recentCalls_addToContact (1429899535546487008) -->
-    <skip />
-    <!-- no translation found for recentCalls_removeFromRecentList (401662244636511330) -->
-    <skip />
-    <!-- no translation found for recentCalls_deleteAll (6352364392762163704) -->
-    <skip />
+    <string name="recentCalls_editNumberBeforeCall" msgid="7756171675833267857">"Hariri nambari kabla ya kupiga"</string>
+    <string name="recentCalls_addToContact" msgid="1429899535546487008">"Ongeza kwa anwani"</string>
+    <string name="recentCalls_removeFromRecentList" msgid="401662244636511330">"Toa kwa simu zilizopigwa"</string>
+    <string name="recentCalls_deleteAll" msgid="6352364392762163704">"Futa kumbukumbu ya upigaji simu"</string>
     <string name="recentCalls_trashVoicemail" msgid="7604696960787435655">"Futa barua ya sauti"</string>
     <string name="recentCalls_shareVoicemail" msgid="1416112847592942840">"Shiriki barua ya sauti"</string>
-    <!-- no translation found for recentCalls_empty (247053222448663107) -->
-    <skip />
+    <string name="recentCalls_empty" msgid="247053222448663107">"Logi ya kupiga simu ni tupu."</string>
     <string name="clearCallLogConfirmation_title" msgid="718072843006222703">"Futa kumbukumbu la upigaji simu"</string>
     <string name="clearCallLogConfirmation" msgid="7625927669136267636">"Je, una uhakika kuwa unataka kufuta kumbukumbu ya upigaji simu?"</string>
-    <!-- no translation found for clearCallLogProgress_title (6870412675015656948) -->
-    <skip />
-    <!-- no translation found for imei (3045126336951684285) -->
-    <skip />
+    <string name="clearCallLogProgress_title" msgid="6870412675015656948">"Inafuta logi ya kupiga simu"</string>
+    <string name="imei" msgid="3045126336951684285">"IMEI"</string>
     <string name="meid" msgid="6210568493746275750">"MEID"</string>
-    <!-- no translation found for voicemail (3851469869202611441) -->
-    <skip />
-    <!-- no translation found for unknown (740067747858270469) -->
-    <skip />
-    <!-- no translation found for private_num (6374339738119166953) -->
-    <skip />
+    <string name="voicemail" msgid="3851469869202611441">"Barua ya sauti"</string>
+    <string name="unknown" msgid="740067747858270469">"Haijulikani"</string>
+    <string name="private_num" msgid="6374339738119166953">" Number isiyojulikana"</string>
     <string name="payphone" msgid="4864313342828942922">"Simu ya kulipia"</string>
-    <!-- no translation found for dialerKeyboardHintText (5401660096579787344) -->
-    <skip />
+    <string name="dialerKeyboardHintText" msgid="5401660096579787344">"Tumia kichapishi kubonyeza"</string>
     <string name="dialerDialpadHintText" msgid="5824490365898349041">"Piga ili kuongeza simu"</string>
-    <!-- no translation found for simContacts_emptyLoading (6700035985448642408) -->
-    <skip />
-    <!-- no translation found for simContacts_title (27341688347689769) -->
-    <skip />
+    <string name="simContacts_emptyLoading" msgid="6700035985448642408">"Inapakia kutoka kadi ya SIM..."</string>
+    <string name="simContacts_title" msgid="27341688347689769">"Anwani za kadi ya SIM"</string>
     <string name="noContactsHelpTextWithSyncForCreateShortcut" msgid="801504710275614594">"Huna anwani zozote ya kuonyesha. (Ikiwa umeongeza tu akaunti, inaweza kuchukua dakika chache ili kusawazisha anwani.)"</string>
     <string name="noContactsHelpTextForCreateShortcut" msgid="3081286388667108335">"Hauna anwani zozote za kuonyesha."</string>
     <string name="noContactsHelpText" product="tablet" msgid="6450346791169710787">"Huna anwani zozote za kuonyesha."\n\n"Ili kuongeza anwani, bonyeza "<font fgcolor="#ffffffff"><b>"Menyu"</b></font>" na uguse:"\n" "\n<li><font fgcolor="#ffffffff"><b>"Akaunti"</b></font>" ili kuongeza au kusanidi akaunti na anwani unazoweza kusawazisha kwenye kompyuta ndogo"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Anwani mpya"</b></font>" ili kuunda anwani mpya kuanzia mwanzo"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Leta/Hamisha"</b></font>" ili kuleta anwani kutoka kwa kadi yako ya SD"\n</li></string>
@@ -226,7 +169,7 @@
     <string name="noContactsNoSimHelpText" product="default" msgid="467658807711582876">"Huna anwani zozote za kuonyesha."\n\n"Ili kuongeza anwani, bonyeza "<font fgcolor="#ffffffff"><b>"Menyu"</b></font>" na gusa:"\n" "\n<li><font fgcolor="#ffffffff"><b>"Akaunti"</b></font>" ili kuongeza au kusanidi akaunti ya anwani unaweza kupatanisha katika simu"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Mawasiliano mapya"</b></font>" ili kuunda anwani mpya kuanzia mwanzo"</li>" "\n\n<li><font fgcolor="#ffffffff"><b>"Leta/Hamisha"</b></font>"ili kuleta anwani kutoka kwa kadi yako ya SD"\n</li></string>
     <string name="noContactsNoSimHelpTextWithSync" product="tablet" msgid="6222739731808897565">"Huna anwani zozote za kuonyesha. (Kama uliongeza akaunti, inaweza kuchukua dakika chache kusawazisha anwani.)"\n\n"Kuongeza anwani, bonyeza "<font fgcolor="#ffffffff"><b>"Menyu"</b></font>" na uguse:"\n" "\n<li><font fgcolor="#ffffffff"><b>"Akaunti"</b></font>" ili kuongeza au kusanidi akaunti na anwani unazoweza kusawazisha kwenye kompyuta ndogo"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Chaguo za onyesha"</b></font>" ili kubadilisha ni anwani gani zinazoonekana"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Anwani mpya"</b></font>" ili kuunda anwani mpya kutoka mwanzo"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Leta/Hamisha"</b></font>" ili kuleta anwani kutoka kwa kadi yako ya SD"\n</li></string>
     <string name="noContactsNoSimHelpTextWithSync" product="default" msgid="9040060730467973050">"Hauna anwani zozote za kuonyesha. (Kama umeongeza tu akaunti, inaweza kuchukua dadika chache ili kupatanisha anwani.)"\n\n"Ili kuongeza anwani, bonyeza "<font fgcolor="#ffffffff"><b>"Menyu"</b></font>" na gusa:"\n" "\n<li><font fgcolor="#ffffffff"><b>"Akaunti"</b></font>" ili kuongeza au kusanidi anwani unayoweza kupatanisha katika simu"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Onyesha Machaguo"</b></font>"ili kubadilisha anwani zinazoonekana"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Anwani mpya"</b></font>" ili kuunda anwani mpya kuanzia mwanzo"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Leta/Hamisha"</b></font>"ili kuleta anwani kutoka kwa kadi yako ya SD"\n</li></string>
-    <!-- syntax error in translation for noFavoritesHelpText (3744655776704833277) org.xmlpull.v1.XmlPullParserException: expected: /string read: b (position:END_TAG </b>@1:167 in java.io.StringReader@3e34a1fc)  -->
+    <!-- syntax error in translation for noFavoritesHelpText (3744655776704833277) org.xmlpull.v1.XmlPullParserException: expected: /string read: b (position:END_TAG </b>@1:167 in java.io.StringReader@57c39a2d)  -->
     <string name="liveFolder_all_label" msgid="5961411940473276616">"Anwani zote"</string>
     <string name="liveFolder_favorites_label" msgid="2674341514070517105">"Yenye nyota"</string>
     <string name="liveFolder_phones_label" msgid="1709786878793436245">"Simu"</string>
@@ -238,8 +181,7 @@
     <string name="type_incoming" msgid="6502076603836088532">"Simu inayoingia"</string>
     <string name="type_outgoing" msgid="343108709599392641">"Simu inayotoka"</string>
     <string name="type_missed" msgid="2720502601640509542">"Simu isiyojibiwa"</string>
-    <!-- no translation found for type_voicemail (5153139450668549908) -->
-    <skip />
+    <string name="type_voicemail" msgid="5153139450668549908">"Barua za sauti"</string>
     <string name="actionIncomingCall" msgid="6028930669817038600">"Simu zinazoingia"</string>
     <string name="callBack" msgid="5498224409038809224">"Mpigie"</string>
     <string name="callAgain" msgid="3197312117049874778">"Piga simu tena"</string>
@@ -262,30 +204,27 @@
     <string name="description_image_button_zero" msgid="4133108949401820710">"sufuri"</string>
     <string name="description_image_button_pound" msgid="3039765597595889230">"Pauni"</string>
     <string name="description_voicemail_button" msgid="3402506823655455591">"Barua ya sauti"</string>
-    <!-- no translation found for description_search_button (3660807558587384889) -->
-    <skip />
+    <string name="description_search_button" msgid="3660807558587384889">"tafuta"</string>
     <string name="description_dial_button" msgid="1274091017188142646">"piga simu"</string>
     <string name="description_delete_button" msgid="6263102114033407382">"futa"</string>
     <string name="description_digits_edittext" msgid="8760207516497016437">"nambari ya kupiga"</string>
     <string name="description_contact_photo" msgid="3387458082667894062">"picha ya anwani"</string>
     <string name="description_minus_button" msgid="387136707700230172">"kutoa"</string>
     <string name="description_plus_button" msgid="515164827856229880">"jumlisha"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
-    <!-- outdated translation 5362631473262100989 -->     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Hifadhi ya USB haipatikani"</string>
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Angalia anwani"</string>
+    <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Hifadhi ya haipatikani"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Hakuna kadi ya SD"</string>
-    <!-- outdated translation 8045830739790534254 -->     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Hakuna hifadhi ya USB iliyogunduliwa"</string>
+    <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Hakuna hifadhi ya iliyogunduliwa"</string>
     <string name="no_sdcard_message" product="default" msgid="6019391476490445358">"Hakuna kadi ya SD iliyogunduliwa"</string>
     <string name="searching_vcard_title" msgid="4970508055399376813">"Inatafuta vCard"</string>
     <string name="import_from_sim" msgid="3859272228033941659">"Ingiza kutoka kwa SIM kadi"</string>
-    <!-- outdated translation 8294728696808674154 -->     <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"Leta kutoka kwa hifadhi ya USB"</string>
-    <!-- outdated translation 7201274701382901259 -->     <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"Hamisha kwa hifadhi ya USB"</string>
+    <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"Leta kutoka kwa hifadhi"</string>
+    <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"Hamisha kwa hifadhi"</string>
     <string name="share_visible_contacts" msgid="890150378880783797">"Shiriki anwani zinazoonekana"</string>
     <string name="import_one_vcard_string" msgid="9059163467020328433">"Ingiza faili moja ya vKadi"</string>
     <string name="import_multiple_vcard_string" msgid="3810226492811062392">"Ingiza faili anuwai za vCard"</string>
     <string name="import_all_vcard_string" msgid="5518136113853448474">"Ingiza faili zote za vKadi"</string>
-    <!-- outdated translation 8214795338181412751 -->     <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"Inatafuta data ya vCard katika hifadhi ya USB"</string>
+    <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"Inatafuta data ya vCard katika hifadhi ya"</string>
     <string name="searching_vcard_message" product="default" msgid="6917522333561434546">"Inatafuta data ya vKadi kwenye kadi ya SD"</string>
     <string name="scanning_sdcard_failed_title" product="nosdcard" msgid="4944932641334764942">"Haikuweza kusafisha hifadhi"</string>
     <string name="scanning_sdcard_failed_title" product="default" msgid="6664940444476572612">"Haikuweza kusafisha kadi ya SD"</string>
@@ -296,7 +235,7 @@
     <string name="fail_reason_vcard_parse_error" msgid="4492947335972369711">"Haikuweza kupasi vKadi kwa sababu isiyotarajiwa"</string>
     <string name="fail_reason_not_supported" msgid="294499264620201243">"Fomati haihamiliwi."</string>
     <string name="vcard_import_failed" msgid="8856125211629574066">"Haikuweza kuleta vCard"</string>
-    <!-- outdated translation 1730986357514922756 -->     <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"Hakuna faili ya vCard iliyopatikana kwenye kadi ya SD"</string>
+    <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"Hakuna faili ya vCard iliyopatikana katika hifadhi ya"</string>
     <string name="import_failure_no_vcard_file" product="default" msgid="1730986357514922756">"Hakuna faili ya vCard iliyopatikana kwenye kadi ya SD"</string>
     <string name="fail_reason_failed_to_collect_vcard_meta_info" msgid="6427931733267328564">"Haikuweza kukusanya maelezo meta ya faili zilizopeanwa za vCard."</string>
     <!-- String.format failed for translation -->
@@ -324,7 +263,7 @@
     <string name="exporting_contact_failed_title" msgid="2339788270863991417">"Haikuweza kuhamisha data ya anwani"</string>
     <string name="exporting_contact_failed_message" msgid="2704925031146288635">"Haikuweza kuhamisha anwani ya data. "\n" Sababu: \" <xliff:g id="FAIL_REASON">%s</xliff:g> \""</string>
     <string name="fail_reason_no_exportable_contact" msgid="4919714086648344495">"Hakuna anwani inayoweza kuhamishwa"</string>
-    <!-- outdated translation 2638638826954895225 -->     <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"Kuna faili nyingi sana za vCard katika hifadhi ya USB"</string>
+    <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"Kuna faili nyingi sana za vCard katika hifadhi ya"</string>
     <string name="fail_reason_too_many_vcard" product="default" msgid="7084146295639672658">"Kuna faili nyingi sana za vCard kwenye kadi ya SD"</string>
     <string name="fail_reason_too_long_filename" msgid="1915716071321839166">"Jina la faili linalohitajika ni refu sana (\"<xliff:g id="FILENAME">%s</xliff:g>\")"</string>
     <string name="exporting_vcard_finished_title" msgid="4259736138838583213">"Imemaliza kuhamisha <xliff:g id="FILENAME">%s</xliff:g>"</string>
@@ -354,8 +293,7 @@
     <string name="quickcontact_missing_app" msgid="4600366393134289038">"Hakuna programu iliyopatikana ili kushughulikia kitendo hiki"</string>
     <string name="missing_name" msgid="7930716592850443705">"( hakuna jina )"</string>
     <string name="menu_accounts" msgid="8499114602017077970">"Akaunti"</string>
-    <!-- no translation found for menu_contacts_filter (2165153460860262501) -->
-    <skip />
+    <string name="menu_contacts_filter" msgid="2165153460860262501">"Anwani za kuonyesha"</string>
     <string name="menu_import_export" msgid="3765725645491577190">"Ingiza/Hamisha"</string>
     <string name="dialog_import_export" msgid="4771877268244096596">"Ingiza/Hamisha anwani"</string>
     <string name="menu_share" msgid="943789700636542260">"Shiriki"</string>
@@ -375,8 +313,7 @@
     <string name="type_short_pager" msgid="2613818970827594238">"P"</string>
     <string name="type_short_other" msgid="5669407180177236769">"O"</string>
     <string name="dialog_new_contact_account" msgid="9044704073286262197">"Unda anwani chini ya akaunti"</string>
-    <!-- no translation found for dialog_new_group_account (2318032089273496830) -->
-    <skip />
+    <string name="dialog_new_group_account" msgid="2318032089273496830">"Unda kikundi chini ya akaunti"</string>
     <string name="menu_sync_remove" msgid="3266725887008450161">"Ondoa kikundi cha usawazishaji"</string>
     <string name="dialog_sync_add" msgid="8267045393119375803">"Ongeza kikundi cha usawazishaji"</string>
     <string name="display_more_groups" msgid="2682547080423434170">"Vikundi zaidi..."</string>
@@ -463,20 +400,17 @@
     <string name="name_phonetic_given" msgid="6853570431394449191">"Jina lililotolewa la fonetiki"</string>
     <string name="name_phonetic_middle" msgid="8643721493320405200">"Jina la katikati la kifonetiki"</string>
     <string name="name_phonetic_family" msgid="462095502140180305">"Jina la kifonetiki la familia"</string>
-    <!-- no translation found for name_phonetic (4259595234312430484) -->
-    <skip />
+    <string name="name_phonetic" msgid="4259595234312430484">"Jina la kifonetiki"</string>
     <string name="connections" msgid="8098440723172028350">"Miunganisho"</string>
     <string name="add_connection_button" msgid="4861308615789601727">"Ongeza muunganisho"</string>
-    <!-- no translation found for recent_updates (2062236709538790412) -->
-    <skip />
+    <string name="recent_updates" msgid="2062236709538790412">"Za hivi karibuni"</string>
     <string name="account_type_format" msgid="718948015590343010">"Anwani <xliff:g id="SOURCE">%1$s</xliff:g>"</string>
     <!-- no translation found for from_account_format (4469138575127580203) -->
     <skip />
     <string name="use_photo_as_primary" msgid="8807110122951157246">"Tumia picha hii"</string>
     <string name="contact_read_only" msgid="1856479476063888348">"Haiwezi kuhaririwa kutoka kwa programu hii"</string>
     <string name="no_contact_details" msgid="6754415338321837001">"Hakuna maelezo ya ziada ya anwani hii"</string>
-    <!-- no translation found for group_read_only (7924922658394449477) -->
-    <skip />
+    <string name="group_read_only" msgid="7924922658394449477">"haiwezi kuhaririwa kwenye kifaa hiki"</string>
     <string name="display_options_sort_list_by" msgid="6080091755852211076">"Panga orodha kwa"</string>
     <string name="display_options_sort_by_given_name" msgid="184916793466387067">"Jina la kwanza"</string>
     <string name="display_options_sort_by_family_name" msgid="7857986975275712622">"Jila la familia"</string>
@@ -500,8 +434,7 @@
     <string name="menu_select_none" msgid="7093222469852132345">"Usichague zote"</string>
     <string name="no_contacts_selected" msgid="5877803471037324613">"Hakuna anwani zilizochaguliwa."</string>
     <string name="add_field" msgid="2384260056674995230">"Ongeza uga nyingine"</string>
-    <!-- no translation found for add_new_entry_for_section (5223080690667565044) -->
-    <skip />
+    <string name="add_new_entry_for_section" msgid="5223080690667565044">"Ongeza mpya"</string>
     <string name="add_organization" msgid="7311893231158291197">"Ongeza shirikisho"</string>
     <string name="event_edit_field_hint_text" msgid="5794424930242630477">"Tarehe"</string>
     <string name="group_edit_field_hint_text" msgid="3966441850870457808">"Jina la kikundi"</string>
@@ -519,8 +452,7 @@
     <string name="aggregation_suggestion_edit_dialog_title" msgid="1064042382692091314">"Hariri majina yaliyochaguliwa"</string>
     <string name="aggregation_suggestion_edit_dialog_message" msgid="6549585283910518095">"Badilisha kwa hariri anwani iliyochaguliwa? Maelezo uliyoyaingiza hadi sasa yatanakiliwa."</string>
     <string name="menu_copyContact" msgid="4401683725471696686">"Nakili kwa anwani zangu"</string>
-    <!-- no translation found for add_to_my_contacts (1068274916793627723) -->
-    <skip />
+    <string name="add_to_my_contacts" msgid="1068274916793627723">"Ongeza kwa  Anwani Zangu"</string>
     <string name="contact_directory_description" msgid="683398073603909119">"Saraka <xliff:g id="TYPE">%1$s</xliff:g>"</string>
     <string name="directory_search_label" msgid="1887759056597975053">"Saraka"</string>
     <string name="local_search_label" msgid="2551177578246113614">"Anwani zote"</string>
@@ -533,8 +465,7 @@
     <string name="list_filter_single" msgid="5871400283515893087">"Anwani"</string>
     <string name="custom_list_filter" msgid="7836035257402013957">"Bainisha mwonekano maalum"</string>
     <string name="activity_title_settings" msgid="5464130076132770781">"Mipangilio"</string>
-    <!-- no translation found for activity_title_contacts_filter (8275542497615516969) -->
-    <skip />
+    <string name="activity_title_contacts_filter" msgid="8275542497615516969">"Anwani za uonyesha"</string>
     <string name="menu_settings" msgid="377929915873428211">"Mipangilio"</string>
     <string name="preference_displayOptions" msgid="1341720270148252393">"Onyesha machaguo"</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>
@@ -553,100 +484,80 @@
     <string name="create_group_dialog_title" msgid="6874527142828424475">"Unda kikundi kipya"</string>
     <string name="create_group_item_label" msgid="5218022006186243310">"[Unda kikundi kipya]"</string>
     <string name="delete_group_dialog_title" msgid="7368429698398624427">"Futa kikundi"</string>
-    <!-- no translation found for num_groups_in_account:one (2944819210288517794) -->
-    <!-- no translation found for num_groups_in_account:other (1276758425904917367) -->
+  <plurals name="num_groups_in_account">
+    <item quantity="one" msgid="2944819210288517794">"Kikundi 1"</item>
+    <item quantity="other" msgid="1276758425904917367">"<xliff:g id="COUNT">%0$d</xliff:g> vikundi"</item>
+  </plurals>
     <string name="delete_group_dialog_message" msgid="295063284548750881">"Una uhakika unataka kufuta kikundi \'<xliff:g id="GROUP_LABEL">%1$s</xliff:g>\'? (Anwani zenyewe hazitafutwa.)"</string>
-    <!-- no translation found for num_contacts_in_group:one (1352418549951013448) -->
-    <!-- no translation found for num_contacts_in_group:other (8146027769011086349) -->
-    <!-- no translation found for group_list_num_contacts_in_group:one (3323065321661972446) -->
-    <!-- no translation found for group_list_num_contacts_in_group:other (6251996206137048525) -->
+  <plurals name="num_contacts_in_group">
+    <item quantity="one" msgid="1352418549951013448">"Mtu<xliff:g id="COUNT_0">%1$d</xliff:g> kutoka <xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+    <item quantity="other" msgid="8146027769011086349">"Watu <xliff:g id="COUNT_0">%1$d</xliff:g>  kutoka<xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+  </plurals>
+  <plurals name="group_list_num_contacts_in_group">
+    <item quantity="one" msgid="3323065321661972446">"Mtu <xliff:g id="COUNT">%1$d</xliff:g>"</item>
+    <item quantity="other" msgid="6251996206137048525">"Watu <xliff:g id="COUNT">%1$d</xliff:g>"</item>
+  </plurals>
     <string name="toast_join_with_empty_contact" msgid="5015189525953438968">"Tafadhali ingiza jina la anwani kabla ya kujiunga na anwani nyingine."</string>
-    <!-- no translation found for copy_text (3257145021583508761) -->
-    <skip />
-    <!-- no translation found for set_default (4417505153468300351) -->
-    <skip />
-    <!-- no translation found for clear_default (7193185801596678067) -->
-    <skip />
+    <string name="copy_text" msgid="3257145021583508761">"Nakili kwenye ubao wa klipu"</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_title" msgid="3950463632415908534">"Tupa mabadiliko"</string>
     <string name="cancel_confirmation_dialog_message" msgid="7021968394611740251">"Je, unataka kutupa mabadiliko yako?"</string>
-    <!-- no translation found for call_type_and_date (1766269584078149149) -->
-    <skip />
+    <string name="call_type_and_date" msgid="1766269584078149149">"Kishika nafasi <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">"Sanidi maelezo yangu mafupi"</string>
     <string name="enter_contact_name" msgid="1738391320566349924">"Charaza jina la mtu"</string>
-    <!-- no translation found for view_updates_from_group (1782685984905600034) -->
-    <skip />
-    <!-- no translation found for notification_voicemail_title:one (1746619685488504230) -->
-    <!-- no translation found for notification_voicemail_title:other (5513481419205061254) -->
-    <!-- no translation found for notification_voicemail_callers_list (1153954809339404149) -->
-    <skip />
-    <!-- no translation found for notification_new_voicemail_ticker (895342132049452081) -->
-    <skip />
+    <string name="view_updates_from_group" msgid="1782685984905600034">"Tazama visasisho"</string>
+  <plurals name="notification_voicemail_title">
+    <item quantity="one" msgid="1746619685488504230">"Barua ya sauti"</item>
+    <item quantity="other" msgid="5513481419205061254">"<xliff:g id="COUNT">%1$d</xliff:g> Barua za sauti"</item>
+  </plurals>
+    <string name="notification_voicemail_callers_list" msgid="1153954809339404149">"<xliff:g id="NEWER_CALLERS">%1$s</xliff:g>, <xliff:g id="OLDER_CALLER">%2$s</xliff:g>"</string>
+    <string name="notification_new_voicemail_ticker" msgid="895342132049452081">"Barua mpya ya sauti kutoka <xliff:g id="CALLER">%1$s</xliff:g>"</string>
     <string name="voicemail_playback_error" msgid="1811242131549854624">"Haikuweza kucheza barua ya sauti."</string>
     <string name="voicemail_buffering" msgid="738287747618697097">"Inaakibisha???"</string>
     <string name="voicemail_fetching_content" msgid="877911315738258780">"Inaleta barua ya sauti???"</string>
     <string name="voicemail_fetching_timout" msgid="6691792377574905201">"Haikuweza kuleta barua ya sauti."</string>
-    <!-- no translation found for call_log_new_header (846546437517724715) -->
-    <skip />
-    <!-- no translation found for call_log_old_header (6262205894314263629) -->
-    <skip />
-    <!-- no translation found for voicemail_status_voicemail_not_available (3164200979671881947) -->
-    <skip />
-    <!-- no translation found for voicemail_status_messages_waiting (2970301042310727909) -->
-    <skip />
-    <!-- no translation found for voicemail_status_configure_voicemail (3940240432123700974) -->
-    <skip />
-    <!-- no translation found for voicemail_status_audio_not_available (3369618334553341626) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_configure (7008713959076506385) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_call_server (1824816252288551794) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slowest (6047030504814773029) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slower (7890393922358642543) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_normal (6030110237820243006) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_faster (4161478290979905481) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_fastest (3373646875150544205) -->
-    <skip />
+    <string name="call_log_new_header" msgid="846546437517724715">"Mpya"</string>
+    <string name="call_log_old_header" msgid="6262205894314263629">"Nzee zaidi"</string>
+    <string name="voicemail_status_voicemail_not_available" msgid="3164200979671881947">"Haiwezi kuunganisha kwa seva ya barua ya sauti."</string>
+    <string name="voicemail_status_messages_waiting" msgid="2970301042310727909">"Haiwezi kuunganishwa kwenye seva ya barua ya sauti. Barua mpya za sauti zinasubiri."</string>
+    <string name="voicemail_status_configure_voicemail" msgid="3940240432123700974">"Weka mipangilio ya barua zako za sauti"</string>
+    <string name="voicemail_status_audio_not_available" msgid="3369618334553341626">"Sauti haipatikani."</string>
+    <string name="voicemail_status_action_configure" msgid="7008713959076506385">"Sanidi"</string>
+    <string name="voicemail_status_action_call_server" msgid="1824816252288551794">"Pigia barua sauti"</string>
+    <string name="voicemail_speed_slowest" msgid="6047030504814773029">"kasi ya taratibu zaidi"</string>
+    <string name="voicemail_speed_slower" msgid="7890393922358642543">"kasi ya taratibu"</string>
+    <string name="voicemail_speed_normal" msgid="6030110237820243006">"kasi ya kawaida"</string>
+    <string name="voicemail_speed_faster" msgid="4161478290979905481">"kasi ya haraka"</string>
+    <string name="voicemail_speed_fastest" msgid="3373646875150544205">"Kasi ya haraka zaidi"</string>
     <string name="call_log_item_count_and_date" msgid="7641933305703520787">"( <xliff:g id="COUNT">%1$d</xliff:g> ) <xliff:g id="DATE">%2$s</xliff:g>"</string>
-    <!-- no translation found for group_name_hint (2659811836386413509) -->
-    <skip />
-    <!-- no translation found for nfc_vcard_file_name (2823095213265993609) -->
-    <skip />
-    <!-- no translation found for menu_show_voicemails_only (1898421289561435703) -->
-    <skip />
+    <string name="group_name_hint" msgid="2659811836386413509">"Jina la Kikundi"</string>
+    <string name="nfc_vcard_file_name" msgid="2823095213265993609">"Anwani imepokewa kupitia NFC"</string>
+    <string name="menu_show_voicemails_only" msgid="1898421289561435703">"Onyesha barua za sauti pekee"</string>
     <string name="menu_show_all_calls" msgid="7560347482073345885">"Onyesha simu zote"</string>
-    <!-- no translation found for status_available (5586870015822828392) -->
-    <skip />
-    <!-- no translation found for status_away (1838861100379804730) -->
-    <skip />
-    <!-- no translation found for status_busy (9147992455450257136) -->
-    <skip />
-    <!-- no translation found for description_call_log_call_button (8207201401459528442) -->
-    <skip />
-    <!-- no translation found for description_call_log_play_button (651182125650429846) -->
-    <skip />
-    <!-- no translation found for description_call_log_incoming_call (4485427487637250143) -->
-    <skip />
-    <!-- no translation found for description_call_log_outgoing_call (604831756853471658) -->
-    <skip />
-    <!-- no translation found for description_call_log_missed_call (2242805209983708825) -->
-    <skip />
-    <!-- no translation found for description_call_log_voicemail (4600798771975158948) -->
-    <skip />
+    <string name="status_available" msgid="5586870015822828392">"Anapatikana"</string>
+    <string name="status_away" msgid="1838861100379804730">"Mbali"</string>
+    <string name="status_busy" msgid="9147992455450257136">"Ana shughuli"</string>
+    <string name="description_call_log_call_button" msgid="8207201401459528442">"Pigia nambari"</string>
+    <string name="description_call_log_play_button" msgid="651182125650429846">"Chezesha barua ya sauti"</string>
+    <string name="description_call_log_incoming_call" msgid="4485427487637250143">"Simu inayoingia"</string>
+    <string name="description_call_log_outgoing_call" msgid="604831756853471658">"Simu inayotoka"</string>
+    <string name="description_call_log_missed_call" msgid="2242805209983708825">"Simu isiyojibiwa"</string>
+    <string name="description_call_log_voicemail" msgid="4600798771975158948">"Barua za sauti"</string>
     <string name="description_add_contact" msgid="3103414772502485851">"Ongeza anwani"</string>
     <string name="description_view_contact" msgid="5205669345700598415">"Angalia anwani <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call" msgid="3443678121983852666">"Piga <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Tuma ujumbe wa maandishi kwa <xliff:g id="NAME">%1$s</xliff:g>"</string>
-    <!-- no translation found for description_call_log_unheard_voicemail (118101684236996786) -->
+    <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Barua ya sauti isiyosikika"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
     <skip />
-    <!-- no translation found for call_log_empty_gecode (5588904744812100846) -->
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
     <skip />
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"MIMI"</string>
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
+    <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Mimi"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Maelezo yangu mafupi ya ndani."</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Maelezo yangu mafupi ya <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g>"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Inaonyesha anwani zote"</string>
diff --git a/res/values-th/strings.xml b/res/values-th/strings.xml
index 17f08bd..63fcc88 100644
--- a/res/values-th/strings.xml
+++ b/res/values-th/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"ภาพของรายชื่อ"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"ดูรายชื่อติดต่อ"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"ไม่มีที่เก็บข้อมูล"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"ไม่มีการ์ด SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"ไม่พบที่เก็บข้อมูล"</string>
@@ -550,10 +548,16 @@
     <string name="description_call" msgid="3443678121983852666">"โทรหา <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"ส่งข้อความไปที่ <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"ข้อความเสียงที่ยังไม่ได้ฟัง"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"ฉัน"</string>
     <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="7061052512446855192">"People ทำงานได้ดีกว่าหากมีบัญชี Google"\n\n"•เข้าถึงจากเว็บเบราว์เซอร์ใดๆ ก็ได้"\n"•สำรองข้อมูลสมุดโทรศัพท์ของคุณอย่างปลอดภัย"</string>
+    <string name="no_account_prompt" msgid="7061052512446855192">"People ทำงานได้ดีกว่าหากมีบัญชี Google"\n\n"•เข้าถึงจากทุกเว็บเบราว์เซอร์"\n"•สำรองข้อมูลสมุดโทรศัพท์ของคุณอย่างปลอดภัย"</string>
 </resources>
diff --git a/res/values-tl/strings.xml b/res/values-tl/strings.xml
index cbc3e59..08590f8 100644
--- a/res/values-tl/strings.xml
+++ b/res/values-tl/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"larawan ng contact"</string>
     <string name="description_minus_button" msgid="387136707700230172">"minus"</string>
     <string name="description_plus_button" msgid="515164827856229880">"plus"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Tingnan ang contact"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Hindi available ang imbakan"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Walang SD card"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Walang natukoy na imbakan"</string>
@@ -550,6 +548,12 @@
     <string name="description_call" msgid="3443678121983852666">"Tawagan si <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Ipadala ang text message kay <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Hindi pa naririnig na voicemail"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ako"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Aking lokal na profile"</string>
diff --git a/res/values-tr/strings.xml b/res/values-tr/strings.xml
index dd907f9..b3fe85b 100644
--- a/res/values-tr/strings.xml
+++ b/res/values-tr/strings.xml
@@ -515,8 +515,8 @@
     <string name="notification_voicemail_callers_list" msgid="1153954809339404149">"<xliff:g id="NEWER_CALLERS">%1$s</xliff:g>, <xliff:g id="OLDER_CALLER">%2$s</xliff:g>"</string>
     <string name="notification_new_voicemail_ticker" msgid="895342132049452081">"Yeni sesli mesj gönderen: <xliff:g id="CALLER">%1$s</xliff:g>"</string>
     <string name="voicemail_playback_error" msgid="1811242131549854624">"Sesli mesaj yürütülemedi."</string>
-    <string name="voicemail_buffering" msgid="738287747618697097">"Arabelleğe alınıyor???"</string>
-    <string name="voicemail_fetching_content" msgid="877911315738258780">"Sesli mesaj getiriliyor???"</string>
+    <string name="voicemail_buffering" msgid="738287747618697097">"Arabelleğe alınıyor..."</string>
+    <string name="voicemail_fetching_content" msgid="877911315738258780">"Sesli mesaj getiriliyor..."</string>
     <string name="voicemail_fetching_timout" msgid="6691792377574905201">"Sesli mesaj getirilemedi."</string>
     <string name="call_log_new_header" msgid="846546437517724715">"Yeni"</string>
     <string name="call_log_old_header" msgid="6262205894314263629">"Daha eski"</string>
@@ -550,11 +550,16 @@
     <string name="description_call" msgid="3443678121983852666">"Sesli arama yap: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Şu kişiye kısa mesaj gönder: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Dinlenilmemiş sesli mesaj"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"BEN"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Ben"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Yerel profilim"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"<xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> profilim"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Tüm içerik görüntüleniyor"</string>
-    <!-- no translation found for no_account_prompt (7061052512446855192) -->
-    <skip />
+    <string name="no_account_prompt" msgid="7061052512446855192">"Kişi Arama bir Google Account hesabıyla daha iyi çalışır."\n\n"• Kişi Arama\'ya Herhangi bir tarayıcıdan erişin."\n"• Kişilerinizi güvenli bir şekilde yedekleyin."</string>
 </resources>
diff --git a/res/values-uk/strings.xml b/res/values-uk/strings.xml
index 6eb8615..df56690 100644
--- a/res/values-uk/strings.xml
+++ b/res/values-uk/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"фото контакту"</string>
     <string name="description_minus_button" msgid="387136707700230172">"мінус"</string>
     <string name="description_plus_button" msgid="515164827856229880">"плюс"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Переглянути контакт"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Пам’ять недоступна"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Нема карти SD"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Пам’яті не виявлено"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Дзвонити: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Надіслати текстове повідомлення: <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Непрослухана голосова пошта"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"–"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Я"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Я"</string>
     <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>
diff --git a/res/values-vi/strings.xml b/res/values-vi/strings.xml
index 30dbb04..dccfb5e 100644
--- a/res/values-vi/strings.xml
+++ b/res/values-vi/strings.xml
@@ -211,9 +211,7 @@
     <string name="description_contact_photo" msgid="3387458082667894062">"ảnh của liên hệ"</string>
     <string name="description_minus_button" msgid="387136707700230172">"trừ"</string>
     <string name="description_plus_button" msgid="515164827856229880">"cộng"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Xem địa chỉ liên hệ"</string>
     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Bộ nhớ không khả dụng"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Không có thẻ SD nào"</string>
     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Không phát hiện bộ nhớ nào"</string>
@@ -550,8 +548,14 @@
     <string name="description_call" msgid="3443678121983852666">"Gọi <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Gửi tin nhắn văn bản tới <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"Thư thoại chưa nghe"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"TÔI"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Tôi"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"T.sử cục bộ của tôi"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Tiểu sử <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> của tôi"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Đang hiển thị tất cả liên hệ"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index cdc71a4..566dbef 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -550,8 +550,14 @@
     <string name="description_call" msgid="3443678121983852666">"呼叫<xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"向<xliff:g id="NAME">%1$s</xliff:g>发送短信"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"未收听的语音邮件"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"我"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"我"</string>
     <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>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index bd3851c..66c271c 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -550,8 +550,14 @@
     <string name="description_call" msgid="3443678121983852666">"打電話給<xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"傳送簡訊給<xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"未聽取的語音留言"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
+    <skip />
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
+    <skip />
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
     <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"我"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"我自己"</string>
     <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>
diff --git a/res/values-zu/strings.xml b/res/values-zu/strings.xml
index 60c69c9..5e420c4 100644
--- a/res/values-zu/strings.xml
+++ b/res/values-zu/strings.xml
@@ -17,52 +17,33 @@
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
     <string name="launcherDialer" msgid="8636288196618486553">"Ifoni"</string>
-    <!-- no translation found for people (1048457247435785074) -->
-    <skip />
-    <!-- no translation found for contactsList (8661624236494819731) -->
-    <skip />
-    <!-- no translation found for shortcutContact (749243779392912958) -->
-    <skip />
+    <string name="people" msgid="1048457247435785074">"Abantu"</string>
+    <string name="contactsList" msgid="8661624236494819731">"Othi tana nabo"</string>
+    <string name="shortcutContact" msgid="749243779392912958">"Thintana"</string>
     <string name="shortcutDialContact" msgid="746622101599186779">"Ukudayela okuqondile"</string>
     <string name="shortcutMessageContact" msgid="2460337253595976198">"Umyalezo oqondile"</string>
     <string name="shortcutActivityTitle" msgid="6642877210643565436">"Khetha isinqamuleli sothintana naye"</string>
     <string name="callShortcutActivityTitle" msgid="6065749861423648991">"Khetha inombolo ozoyishayela"</string>
     <string name="messageShortcutActivityTitle" msgid="3084542316620335911">"Khetha inombolo kumyalezo"</string>
     <string name="contactPickerActivityTitle" msgid="6886592363525235031">"Khetha othintana naye"</string>
-    <!-- no translation found for starredList (4817256136413959463) -->
-    <skip />
-    <!-- no translation found for frequentList (7154768136473953056) -->
-    <skip />
-    <!-- no translation found for strequentList (5640192862059373511) -->
-    <skip />
-    <!-- no translation found for viewContactTitle (7989394521836644384) -->
-    <skip />
-    <!-- no translation found for viewContactDesription (214186610887547860) -->
-    <skip />
-    <!-- no translation found for editContactDescription (2947202828256214947) -->
-    <skip />
-    <!-- no translation found for insertContactDescription (4709878105452681987) -->
-    <skip />
-    <!-- no translation found for editGroupDescription (6321161304201540561) -->
-    <skip />
-    <!-- no translation found for insertGroupDescription (5658512271662210139) -->
-    <skip />
-    <!-- no translation found for contactDetailAbout (5430408883907061400) -->
-    <skip />
-    <!-- no translation found for contactDetailUpdates (3780588624763446941) -->
-    <skip />
-    <!-- no translation found for searchHint (8482945356247760701) -->
-    <skip />
+    <string name="starredList" msgid="4817256136413959463">"Okunenkanyezi"</string>
+    <string name="frequentList" msgid="7154768136473953056">"Okuvamile"</string>
+    <string name="strequentList" msgid="5640192862059373511">"Izintandokazi"</string>
+    <string name="viewContactTitle" msgid="7989394521836644384">"Imininingwane yothintana naye"</string>
+    <string name="viewContactDesription" msgid="214186610887547860">"Buka othintana naye"</string>
+    <string name="editContactDescription" msgid="2947202828256214947">"Hlela othintana naye"</string>
+    <string name="insertContactDescription" msgid="4709878105452681987">"Yenza othintana naye"</string>
+    <string name="editGroupDescription" msgid="6321161304201540561">"Hlela isigcawu"</string>
+    <string name="insertGroupDescription" msgid="5658512271662210139">"Dala isigcawu"</string>
+    <string name="contactDetailAbout" msgid="5430408883907061400">"Mayelana"</string>
+    <string name="contactDetailUpdates" msgid="3780588624763446941">"Izibuyekezo"</string>
+    <string name="searchHint" msgid="8482945356247760701">"Sesha othintana nabo"</string>
     <string name="menu_search" msgid="9147752853603483719">"Sesha"</string>
-    <!-- no translation found for menu_newContact (1209922412763274638) -->
-    <skip />
-    <!-- no translation found for menu_viewContact (2795575601596468581) -->
-    <skip />
+    <string name="menu_newContact" msgid="1209922412763274638">"Othintana naye omusha"</string>
+    <string name="menu_viewContact" msgid="2795575601596468581">"Buka othintana naye"</string>
     <string name="menu_callNumber" msgid="5142851348489387516">"Shayela <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for menu_addStar (2908478235715404876) -->
-    <skip />
-    <!-- no translation found for menu_removeStar (5844227078364227030) -->
-    <skip />
+    <string name="menu_addStar" msgid="2908478235715404876">"Engeza ezintandokazini"</string>
+    <string name="menu_removeStar" msgid="5844227078364227030">"Susa ezintandokazini"</string>
     <string name="menu_editContact" msgid="9042415603857662633">"Hlela"</string>
     <string name="menu_deleteContact" msgid="6788644058868189393">"Susa"</string>
     <string name="menu_call" msgid="3992595586042260618">"Shayela othintana naye"</string>
@@ -71,8 +52,7 @@
     <string name="menu_editGroup" msgid="5062005185370983720">"Hlela"</string>
     <string name="menu_deleteGroup" msgid="3486380004411482874">"Susa"</string>
     <string name="menu_new_contact_action_bar" msgid="8887818026717394343">"Okusha"</string>
-    <!-- no translation found for menu_new_group_action_bar (5055346725617932394) -->
-    <skip />
+    <string name="menu_new_group_action_bar" msgid="5055346725617932394">"Okusha"</string>
     <string name="splitConfirmation_title" msgid="2209511048593467012">"Oxhumana naye oseceleni"</string>
     <string name="splitConfirmation" msgid="1067993957986345974">"Uqinisekile ukuthi ufuna ukuhlukanisa lo oyedwa oxhumana naye abe oxhumana nabo abaningi?"</string>
     <string name="menu_joinAggregate" msgid="5027981918265667970">"Hlanganisa"</string>
@@ -82,81 +62,61 @@
     <string name="separatorJoinAggregateSuggestions" msgid="2831414448851313345">"Othintana nabo abasikiselwayo"</string>
     <string name="separatorJoinAggregateAll" msgid="7939932265026181043">"Bonke othintana nabo"</string>
     <string name="contactsJoinedMessage" msgid="7208148163607047389">"Othintana nabo abahlanganisiwe"</string>
-    <!-- no translation found for deleteConfirmation_title (6394309508930335204) -->
-    <skip />
-    <!-- no translation found for menu_set_ring_tone (8728345772068064946) -->
-    <skip />
+    <string name="deleteConfirmation_title" msgid="6394309508930335204">"Susa"</string>
+    <string name="menu_set_ring_tone" msgid="8728345772068064946">"Hlela iringithoni"</string>
     <string name="menu_redirect_calls_to_vm" msgid="4181789196416396656">"Wonke amakholi aya kwimeyili yezwi"</string>
     <string name="readOnlyContactWarning" msgid="1390849295342594265">"Awukwazi ukususa othintana nabo ema-akhawuntini okufunda kuphela, kodwa unabafihla ohlwini lwakho lothintana nabo."</string>
     <string name="readOnlyContactDeleteConfirmation" msgid="2137170726670196909">"Lona othintana naye uqukethe ulwazi olusuka ema-akhawuntini amaningi. Ukwaziswa okusuka ema-akhawuntini okufunda kuphela kuzofihlwa ohlwini lwakho lothintana nabo, ngeke kususwe."</string>
     <string name="multipleContactDeleteConfirmation" msgid="938900978442960800">"Ukususa lona othintana naye kuzosusa ukwaziswa kusuka ema-akhawuntini amaningi."</string>
-    <!-- no translation found for deleteConfirmation (811706994761610640) -->
-    <skip />
+    <string name="deleteConfirmation" msgid="811706994761610640">"Lo na othintana naye uzosuswa."</string>
     <string name="menu_done" msgid="796017761764190697">"Kwenziwe"</string>
     <string name="menu_doNotSave" msgid="58593876893538465">"Khansela"</string>
-    <!-- no translation found for menu_discard (6456087569315685632) -->
-    <skip />
-    <!-- no translation found for label_notes (8337354953278341042) -->
-    <skip />
+    <string name="menu_discard" msgid="6456087569315685632">"Lahla"</string>
+    <string name="label_notes" msgid="8337354953278341042">"Imibhalo"</string>
     <string name="label_sip_address" msgid="124073911714324974">"Ikholi le-Inthanethi"</string>
-    <!-- no translation found for ghostData_company (5414421120553765775) -->
-    <skip />
+    <string name="ghostData_company" msgid="5414421120553765775">"Inkampani"</string>
     <string name="ghostData_title" msgid="7496735200318496110">"Isihloko"</string>
-    <!-- no translation found for invalidContactMessage (5816991830260044593) -->
-    <skip />
-    <!-- no translation found for pickerNewContactHeader (7750705279843568147) -->
-    <skip />
-    <!-- no translation found for phoneLabelsGroup (6468091477851199285) -->
-    <skip />
-    <!-- no translation found for emailLabelsGroup (8389931313045344406) -->
-    <skip />
-    <!-- no translation found for imLabelsGroup (3898238486262614027) -->
-    <skip />
+    <string name="invalidContactMessage" msgid="5816991830260044593">"Othintana naye akekho."</string>
+    <string name="pickerNewContactHeader" msgid="7750705279843568147">"Yenza othintana naye omusha"</string>
+    <string name="phoneLabelsGroup" msgid="6468091477851199285">"Ifoni"</string>
+    <string name="emailLabelsGroup" msgid="8389931313045344406">"I-imeyli"</string>
+    <string name="imLabelsGroup" msgid="3898238486262614027">"I-IM"</string>
     <string name="postalLabelsGroup" msgid="3487738141112589324">"Ikheli"</string>
   <string-array name="otherLabels">
     <item msgid="8287841928119937597">"Inhlangano"</item>
     <item msgid="7196592230748086755">"Yazi"</item>
   </string-array>
     <string name="photoPickerNotFoundText" product="tablet" msgid="6247290728908599701">"Azikho izithombe ezitholakalayo kwithebhulethi."</string>
-    <!-- outdated translation 6247290728908599701 -->     <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Azikho izithombe ezitholakalayo kwithebhulethi."</string>
+    <string name="photoPickerNotFoundText" product="default" msgid="431331662154342581">"Azikho izithombe ezitholakalayo kwifoni."</string>
     <string name="attach_photo_dialog_title" msgid="5599827035558557169">"Isithombe sothintana naye"</string>
     <string name="customLabelPickerTitle" msgid="1081475101983255212">"Igama lelebula efiswayo"</string>
     <string name="send_to_voicemail_checkbox" msgid="9001686764070676353">"Thumela ngokuqondile amakholi emyalezwini wezwi"</string>
     <string name="removePhoto" msgid="4898105274130284565">"Khipha isithombe"</string>
-    <!-- no translation found for noContacts (4955659076981974652) -->
-    <skip />
-    <!-- no translation found for noGroups (7315200974181864731) -->
-    <skip />
-    <!-- no translation found for noAccounts (4742609114153797268) -->
-    <skip />
+    <string name="noContacts" msgid="4955659076981974652">"Abekho othintana nabo"</string>
+    <string name="noGroups" msgid="7315200974181864731">"Awekho Amaqembu"</string>
+    <string name="noAccounts" msgid="4742609114153797268">"Ukuze wakhe iqembu udinga i-akhawunti"</string>
     <string name="noMatchingContacts" msgid="4266283206853990471">"Abekho othintana nabo abafanayo abatholakele."</string>
-    <!-- no translation found for noContactsWithPhoneNumbers (1605457050218824269) -->
-    <skip />
+    <string name="noContactsWithPhoneNumbers" msgid="1605457050218824269">"Abekho othintana nabo abanezinombolo zocingo."</string>
     <string name="savingContact" msgid="4075751076741924939">"Igcina othintana naye..."</string>
     <string name="savingDisplayGroups" msgid="2133152192716475939">"Igcina okukhethwa kukho kokubonisa"</string>
     <string name="contactSavedToast" msgid="9171862279493213075">"Oxhumana naye olondoloziwe"</string>
     <string name="contactSavedErrorToast" msgid="9189098776225004666">"Iphutha, ayikwazi ukugcina izinguquko zothintana naye."</string>
     <string name="groupSavedToast" msgid="6675062559302493011">"Iqembu elilondoloziwe"</string>
-    <!-- no translation found for groupSavedErrorToast (6434135707953150875) -->
-    <skip />
+    <string name="groupSavedErrorToast" msgid="6434135707953150875">"Iphutha, ayikwazi ukugcina izinguquko zesigcawu."</string>
   <plurals name="listTotalPhoneContacts">
     <item quantity="one" msgid="3015357862286673986">"othintana naye ongu-1 onenombolo yocingo"</item>
     <item quantity="other" msgid="3299954047880968205">"<xliff:g id="COUNT">%d</xliff:g> Othintana nabo abanezinombolo zocingo"</item>
   </plurals>
-    <!-- outdated translation 2756295259674938869 -->     <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"Abekho othintana nabo ababonakalayo abanezinombolo zocingo"</string>
+    <string name="listTotalPhoneContactsZero" msgid="6968813857632984319">"Abekho othintana nabo abanezinombolo zocingo"</string>
   <plurals name="listTotalAllContacts">
     <item quantity="one" msgid="3405747744700823280">"Othintana naye ongu-1"</item>
     <item quantity="other" msgid="3578469907265375314">"<xliff:g id="COUNT">%d</xliff:g> Othintana nabo"</item>
   </plurals>
-    <!-- outdated translation 6811347506748072822 -->     <string name="listTotalAllContactsZero" msgid="1889349925514589304">"Abekho othintana nabo ababonakalayo"</string>
-    <!-- no translation found for listTotalAllContactsZeroCustom (4058252141420128998) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroStarred (1289318488170099285) -->
-    <skip />
-    <!-- no translation found for listTotalAllContactsZeroGroup (5448979458248027615) -->
-    <skip />
-    <!-- no translation found for listAllContactsInAccount (7496143179265311758) -->
-    <skip />
+    <string name="listTotalAllContactsZero" msgid="1889349925514589304">"Abekho othintana nabo"</string>
+    <string name="listTotalAllContactsZeroCustom" msgid="4058252141420128998">"Abekho othintana nabo ababonakalayo"</string>
+    <string name="listTotalAllContactsZeroStarred" msgid="1289318488170099285">"Azikho izintandokazi"</string>
+    <string name="listTotalAllContactsZeroGroup" msgid="5448979458248027615">"Abekho othintana nabo ku <xliff:g id="NAME">%s</xliff:g>"</string>
+    <string name="listAllContactsInAccount" msgid="7496143179265311758">"Oxhumana nabo kwi <xliff:g id="NAME">%s</xliff:g>"</string>
     <string name="listSingleContact" msgid="6067813698903535563">"Oxhumana naye oyedwa"</string>
     <string name="listCustomView" msgid="6950713892532194050">"Ohlu loxhumana nabo olubukwa kokulungiselwe lokhu"</string>
   <plurals name="listFoundAllContacts">
@@ -169,53 +129,36 @@
     <item quantity="one" msgid="4826918429708286628">"otholakele ongu-1"</item>
     <item quantity="other" msgid="7988132539476575389">"<xliff:g id="COUNT">%d</xliff:g> tholakele"</item>
   </plurals>
-    <!-- no translation found for contactsAllLabel (6178225597569649305) -->
-    <skip />
-    <!-- no translation found for contactsGroupsLabel (2841971472518003524) -->
-    <skip />
-    <!-- no translation found for contactsFavoritesLabel (8417039765586853670) -->
-    <skip />
+    <string name="contactsAllLabel" msgid="6178225597569649305">"Konke"</string>
+    <string name="contactsGroupsLabel" msgid="2841971472518003524">"Amaqembu"</string>
+    <string name="contactsFavoritesLabel" msgid="8417039765586853670">"Izintandokazi"</string>
     <string name="dialerIconLabel" msgid="6500826552823403796">"Ifoni"</string>
-    <!-- no translation found for recentCallsIconLabel (1419116422359067949) -->
-    <skip />
+    <string name="recentCallsIconLabel" msgid="1419116422359067949">"Ifayela lokungena locingo"</string>
     <string name="liveFolderAll" msgid="4789010460767506206">"Bonke othintana nabo"</string>
     <string name="liveFolderFavorites" msgid="3100957542927222282">"Othintana nabo abanezinkanyezi"</string>
     <string name="liveFolderPhone" msgid="3739376066610926780">"Othintana nabo abanezinombolo zocingo"</string>
     <string name="menu_sendTextMessage" msgid="6937343460284499306">"Thumela umyalezo wombhalo"</string>
     <string name="recentCalls_callNumber" msgid="1756372533999226126">"Shayela <xliff:g id="NAME">%s</xliff:g>"</string>
-    <!-- no translation found for recentCalls_editNumberBeforeCall (7756171675833267857) -->
-    <skip />
-    <!-- no translation found for recentCalls_addToContact (1429899535546487008) -->
-    <skip />
-    <!-- no translation found for recentCalls_removeFromRecentList (401662244636511330) -->
-    <skip />
-    <!-- no translation found for recentCalls_deleteAll (6352364392762163704) -->
-    <skip />
+    <string name="recentCalls_editNumberBeforeCall" msgid="7756171675833267857">"Hlela inombolo ngaphambi kokushaya ucingo"</string>
+    <string name="recentCalls_addToContact" msgid="1429899535546487008">"Engeza kothintana nabo"</string>
+    <string name="recentCalls_removeFromRecentList" msgid="401662244636511330">"Khipha kwifayela yokungena"</string>
+    <string name="recentCalls_deleteAll" msgid="6352364392762163704">"Sula ifayela lokungena"</string>
     <string name="recentCalls_trashVoicemail" msgid="7604696960787435655">"Susa imeyili yezwi"</string>
     <string name="recentCalls_shareVoicemail" msgid="1416112847592942840">"Abelana nemeyili yezwi"</string>
-    <!-- no translation found for recentCalls_empty (247053222448663107) -->
-    <skip />
+    <string name="recentCalls_empty" msgid="247053222448663107">"Ifayela lokungena locingo alinalutho."</string>
     <string name="clearCallLogConfirmation_title" msgid="718072843006222703">"Sula ifayela lokungena"</string>
     <string name="clearCallLogConfirmation" msgid="7625927669136267636">"Uqinisekile ukuthi ufuna ukusula ifayela lokungena?"</string>
-    <!-- no translation found for clearCallLogProgress_title (6870412675015656948) -->
-    <skip />
-    <!-- no translation found for imei (3045126336951684285) -->
-    <skip />
+    <string name="clearCallLogProgress_title" msgid="6870412675015656948">"Isula lonke ifayela lokungena laboshayelayo"</string>
+    <string name="imei" msgid="3045126336951684285">"I-MEI"</string>
     <string name="meid" msgid="6210568493746275750">"I-MEID"</string>
-    <!-- no translation found for voicemail (3851469869202611441) -->
-    <skip />
-    <!-- no translation found for unknown (740067747858270469) -->
-    <skip />
-    <!-- no translation found for private_num (6374339738119166953) -->
-    <skip />
+    <string name="voicemail" msgid="3851469869202611441">"Imeyli yezwi"</string>
+    <string name="unknown" msgid="740067747858270469">"Akwaziwa"</string>
+    <string name="private_num" msgid="6374339738119166953">"Inombolo yangasese"</string>
     <string name="payphone" msgid="4864313342828942922">"Ifoni ekhokhelwayo"</string>
-    <!-- no translation found for dialerKeyboardHintText (5401660096579787344) -->
-    <skip />
+    <string name="dialerKeyboardHintText" msgid="5401660096579787344">"Sebenzisa ikhibhodi ukudayela"</string>
     <string name="dialerDialpadHintText" msgid="5824490365898349041">"Dayela ukwengeza ikholi"</string>
-    <!-- no translation found for simContacts_emptyLoading (6700035985448642408) -->
-    <skip />
-    <!-- no translation found for simContacts_title (27341688347689769) -->
-    <skip />
+    <string name="simContacts_emptyLoading" msgid="6700035985448642408">"Ilayisha kusuka ekhadini le-SIM..."</string>
+    <string name="simContacts_title" msgid="27341688347689769">"Othintana nabo bekhadi le-SIM"</string>
     <string name="noContactsHelpTextWithSyncForCreateShortcut" msgid="801504710275614594">"Awunabo othintana nabo ongababonisa. (Uma usanda kufaka i-akhawunti, kungase kuthathe imizuzu embalwa ukuvumelanisa othintana nabo.)"</string>
     <string name="noContactsHelpTextForCreateShortcut" msgid="3081286388667108335">"Awunabo othintana nabo ongababonisa."</string>
     <string name="noContactsHelpText" product="tablet" msgid="6450346791169710787">"Awunabo othintana nabo ongababonisa."\n\n"Ukufaka othintana nabo, cindezela "<font fgcolor="#ffffffff"><b>"Menyu"</b></font>" bese uthinta:"\n" "\n<li><font fgcolor="#ffffffff"><b>"ama-Akhawunti"</b></font>" ukufaka noma ukumisa i-akhawunti nothintana nabo ongabavumelanisa kwithebhulethi"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Othintana naye omusha"</b></font>"ukwenza othintana naye omusha kusukela ekuqaleni"\n</li>" "\n<li><font fgcolor="#ffffffff"><b>"Ngenisa/Thekelisa"</b></font>"ukungenisa othintana nabo kwi-SIM noma ekhadini lakho le-SD"\n</li></string>
@@ -238,8 +181,7 @@
     <string name="type_incoming" msgid="6502076603836088532">"Ikholi engenayo"</string>
     <string name="type_outgoing" msgid="343108709599392641">"Ikholi oluphumayo"</string>
     <string name="type_missed" msgid="2720502601640509542">"Ikholi elahlekeli"</string>
-    <!-- no translation found for type_voicemail (5153139450668549908) -->
-    <skip />
+    <string name="type_voicemail" msgid="5153139450668549908">"Ivoyisimeyili"</string>
     <string name="actionIncomingCall" msgid="6028930669817038600">"Amakholi angenayo"</string>
     <string name="callBack" msgid="5498224409038809224">"Phinda ushayele"</string>
     <string name="callAgain" msgid="3197312117049874778">"Shayela futhi"</string>
@@ -262,30 +204,27 @@
     <string name="description_image_button_zero" msgid="4133108949401820710">"lutho"</string>
     <string name="description_image_button_pound" msgid="3039765597595889230">"iphawundi"</string>
     <string name="description_voicemail_button" msgid="3402506823655455591">"Umyalezo wezwi"</string>
-    <!-- no translation found for description_search_button (3660807558587384889) -->
-    <skip />
+    <string name="description_search_button" msgid="3660807558587384889">"sesha"</string>
     <string name="description_dial_button" msgid="1274091017188142646">"dayela"</string>
     <string name="description_delete_button" msgid="6263102114033407382">"i-backspace"</string>
     <string name="description_digits_edittext" msgid="8760207516497016437">"inombolo okumele uyidayele"</string>
     <string name="description_contact_photo" msgid="3387458082667894062">"isithombe sothintana naye"</string>
     <string name="description_minus_button" msgid="387136707700230172">"susa"</string>
     <string name="description_plus_button" msgid="515164827856229880">"kuhlanganise"</string>
-    <!-- no translation found for description_view_contact_detail (9133251213656414807) -->
-    <!-- no translation found for description_view_contact_detail (2795575601596468581) -->
-    <skip />
-    <!-- outdated translation 5362631473262100989 -->     <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Isitoreji se-USB asitholakali"</string>
+    <string name="description_view_contact_detail" msgid="9133251213656414807">"Buka othintana naye"</string>
+    <string name="no_sdcard_title" product="nosdcard" msgid="8543619259870877473">"Ukugcina akutholakali"</string>
     <string name="no_sdcard_title" product="default" msgid="5911758680339949273">"Alikho ikhadi le-SD"</string>
-    <!-- outdated translation 8045830739790534254 -->     <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Asikho isitoreji se-USB esitholiwe"</string>
+    <string name="no_sdcard_message" product="nosdcard" msgid="1334170151822669976">"Akukho ukugcina okutholiwe"</string>
     <string name="no_sdcard_message" product="default" msgid="6019391476490445358">"Alikho ikhadi le-SD"</string>
     <string name="searching_vcard_title" msgid="4970508055399376813">"Iseshela i-vCArd"</string>
     <string name="import_from_sim" msgid="3859272228033941659">"Ngenisa kusuka kwikhadi le-SIM"</string>
-    <!-- outdated translation 8294728696808674154 -->     <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"Ngenisa kwisitoreji se-USB"</string>
-    <!-- outdated translation 7201274701382901259 -->     <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"Thumela kwisitoreji se-USB"</string>
+    <string name="import_from_sdcard" product="default" msgid="8668347930577565175">"Ngenisa kusuka esigcineni"</string>
+    <string name="export_to_sdcard" product="default" msgid="6092815580965201089">"Thekelisa kusigcini"</string>
     <string name="share_visible_contacts" msgid="890150378880783797">"Yabelana nothintana nabo ababonakalayo"</string>
     <string name="import_one_vcard_string" msgid="9059163467020328433">"Ngenisa ifayela eyodwa ye-vCard"</string>
     <string name="import_multiple_vcard_string" msgid="3810226492811062392">"Ngenisa amafayela amaningi e-vCard"</string>
     <string name="import_all_vcard_string" msgid="5518136113853448474">"Ngenisa wonke amafayela e-vCard"</string>
-    <!-- outdated translation 8214795338181412751 -->     <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"Isesha idatha ye-vCard kwisitoreji se-USB"</string>
+    <string name="searching_vcard_message" product="nosdcard" msgid="996170203695743981">"Isesha idatha ye-vCard kusigcini"</string>
     <string name="searching_vcard_message" product="default" msgid="6917522333561434546">"Iseshela idatha ye-vCard ekhadini le-SD"</string>
     <string name="scanning_sdcard_failed_title" product="nosdcard" msgid="4944932641334764942">"Yehlulekile ukufinyelela kwindawo yokugcina i-USB"</string>
     <string name="scanning_sdcard_failed_title" product="default" msgid="6664940444476572612">"Yehlulekile ukuthwebula i-SD card"</string>
@@ -296,7 +235,7 @@
     <string name="fail_reason_vcard_parse_error" msgid="4492947335972369711">"Yehlulekile ukuhlwaya i-vCard ngenxa yesizathu esithile esingalindelekile"</string>
     <string name="fail_reason_not_supported" msgid="294499264620201243">"Ifomethi ayisekelwe."</string>
     <string name="vcard_import_failed" msgid="8856125211629574066">"Yehlulekile ukulanda i-vCard"</string>
-    <!-- outdated translation 1730986357514922756 -->     <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"Ayikho ifayela ye-vCard etholakele ekhadini le-SD"</string>
+    <string name="import_failure_no_vcard_file" product="nosdcard" msgid="6339234836196984924">"Ayikho ifayela ye-vCard etholakele kusigcini"</string>
     <string name="import_failure_no_vcard_file" product="default" msgid="1730986357514922756">"Ayikho ifayela ye-vCard etholakele ekhadini le-SD"</string>
     <string name="fail_reason_failed_to_collect_vcard_meta_info" msgid="6427931733267328564">"Yehlulekile ukuqoqa ulwazi lwemetha lwefayela noma amafayela e-vCard."</string>
     <string name="fail_reason_failed_to_read_files" msgid="5823434810622484922">"Ifayela elilodwa noma amafayela angaphezulu ehlulekile ukungenisa (%s)."</string>
@@ -322,7 +261,7 @@
     <string name="exporting_contact_failed_title" msgid="2339788270863991417">"Yehlulekile ukuthekelisa imininingo yothintana naye"</string>
     <string name="exporting_contact_failed_message" msgid="2704925031146288635">"Yehlulekile ukuthekelisa imininingo yothintana naye."\n"Isizathu: \"<xliff:g id="FAIL_REASON">%s</xliff:g>\""</string>
     <string name="fail_reason_no_exportable_contact" msgid="4919714086648344495">"Akekho othintana naye othelekisekayo"</string>
-    <!-- outdated translation 2638638826954895225 -->     <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"Kunamafayela e-vCard amaniningi kwisitoreji se-USB"</string>
+    <string name="fail_reason_too_many_vcard" product="nosdcard" msgid="3745507837635270265">"Kunamafayela e-vCard amaniningi kakhulu kusigcini"</string>
     <string name="fail_reason_too_many_vcard" product="default" msgid="7084146295639672658">"Kunamafayela aminingi kakhulu e-vCard kwikhadi le-SD"</string>
     <string name="fail_reason_too_long_filename" msgid="1915716071321839166">"Igama lefayela elidingekayo lide kakhulu (\" <xliff:g id="FILENAME">%s</xliff:g>\")"</string>
     <string name="exporting_vcard_finished_title" msgid="4259736138838583213">"Iqedile ukuthekelisa <xliff:g id="FILENAME">%s</xliff:g>"</string>
@@ -352,8 +291,7 @@
     <string name="quickcontact_missing_app" msgid="4600366393134289038">"Alukho uhlobo lokusebenza olutholakele lokuphatha lesenzo"</string>
     <string name="missing_name" msgid="7930716592850443705">"(alikho igama)"</string>
     <string name="menu_accounts" msgid="8499114602017077970">"Ama-akhawunti"</string>
-    <!-- no translation found for menu_contacts_filter (2165153460860262501) -->
-    <skip />
+    <string name="menu_contacts_filter" msgid="2165153460860262501">"Othintana nabo abazoboniswa"</string>
     <string name="menu_import_export" msgid="3765725645491577190">"Ngenisa/Thekelisa"</string>
     <string name="dialog_import_export" msgid="4771877268244096596">"Ngenisa/Thekelisa othintana nabo"</string>
     <string name="menu_share" msgid="943789700636542260">"Yabelana"</string>
@@ -373,8 +311,7 @@
     <string name="type_short_pager" msgid="2613818970827594238">"P"</string>
     <string name="type_short_other" msgid="5669407180177236769">"O"</string>
     <string name="dialog_new_contact_account" msgid="9044704073286262197">"Yenza othintana naye ngaphansi kwe-akhawunti"</string>
-    <!-- no translation found for dialog_new_group_account (2318032089273496830) -->
-    <skip />
+    <string name="dialog_new_group_account" msgid="2318032089273496830">"Yenza isigcawu ngaphansi kwe-akhawunti"</string>
     <string name="menu_sync_remove" msgid="3266725887008450161">"Khipha iqembu lokuvumelanisa"</string>
     <string name="dialog_sync_add" msgid="8267045393119375803">"Ngeza iqembu lokuvumelanisa"</string>
     <string name="display_more_groups" msgid="2682547080423434170">"Amanye amaqembu..."</string>
@@ -461,20 +398,17 @@
     <string name="name_phonetic_given" msgid="6853570431394449191">"Igama elinikeziwe lefonethikhi"</string>
     <string name="name_phonetic_middle" msgid="8643721493320405200">"Igama lefonethikhi"</string>
     <string name="name_phonetic_family" msgid="462095502140180305">"Igama lomkhaya wefonethikhi"</string>
-    <!-- no translation found for name_phonetic (4259595234312430484) -->
-    <skip />
+    <string name="name_phonetic" msgid="4259595234312430484">"Igama leFonethikhi"</string>
     <string name="connections" msgid="8098440723172028350">"Oxhumana nabo"</string>
     <string name="add_connection_button" msgid="4861308615789601727">"Yengeza oxhumana nabo"</string>
-    <!-- no translation found for recent_updates (2062236709538790412) -->
-    <skip />
+    <string name="recent_updates" msgid="2062236709538790412">"Okwakamuva"</string>
     <string name="account_type_format" msgid="718948015590343010">"Othintana naye nge-<xliff:g id="SOURCE">%1$s</xliff:g>"</string>
     <!-- no translation found for from_account_format (4469138575127580203) -->
     <skip />
     <string name="use_photo_as_primary" msgid="8807110122951157246">"Sebenzisa lesi sithombe"</string>
     <string name="contact_read_only" msgid="1856479476063888348">"Ayihleleki kabusha kusuka kulolu hlobo lokusebenza"</string>
     <string name="no_contact_details" msgid="6754415338321837001">"Alukho ulwazi olwengeziwe lwalona othintana naye"</string>
-    <!-- no translation found for group_read_only (7924922658394449477) -->
-    <skip />
+    <string name="group_read_only" msgid="7924922658394449477">"Ayihleleki kuledivayisi"</string>
     <string name="display_options_sort_list_by" msgid="6080091755852211076">"Hlunga uhlu nge"</string>
     <string name="display_options_sort_by_given_name" msgid="184916793466387067">"Igama elinikeziwe"</string>
     <string name="display_options_sort_by_family_name" msgid="7857986975275712622">"Igama lomkhaya"</string>
@@ -498,8 +432,7 @@
     <string name="menu_select_none" msgid="7093222469852132345">"Ungakhethi konke"</string>
     <string name="no_contacts_selected" msgid="5877803471037324613">"Abekho othintana nabo abakhethiwe."</string>
     <string name="add_field" msgid="2384260056674995230">"Yengeza enye inkambu"</string>
-    <!-- no translation found for add_new_entry_for_section (5223080690667565044) -->
-    <skip />
+    <string name="add_new_entry_for_section" msgid="5223080690667565044">"Faka okusha"</string>
     <string name="add_organization" msgid="7311893231158291197">"Ngeza inhlangano"</string>
     <string name="event_edit_field_hint_text" msgid="5794424930242630477">"Usuku"</string>
     <string name="group_edit_field_hint_text" msgid="3966441850870457808">"Igama leqembu"</string>
@@ -517,8 +450,7 @@
     <string name="aggregation_suggestion_edit_dialog_title" msgid="1064042382692091314">"Hlela ama-akhawunti akhethiwe"</string>
     <string name="aggregation_suggestion_edit_dialog_message" msgid="6549585283910518095">"Shintshela ekuhleleni othintana naye okhethiwe? Ukwaziswa okufakile kuze kube manje kuzokopishwa."</string>
     <string name="menu_copyContact" msgid="4401683725471696686">"Kopisha kwengithintana nabo"</string>
-    <!-- no translation found for add_to_my_contacts (1068274916793627723) -->
-    <skip />
+    <string name="add_to_my_contacts" msgid="1068274916793627723">"Faka Kothintana Nabo"</string>
     <string name="contact_directory_description" msgid="683398073603909119">"Uhla lwemibhalo <xliff:g id="TYPE">%1$s</xliff:g>"</string>
     <string name="directory_search_label" msgid="1887759056597975053">"Uhla lwemibhalo"</string>
     <string name="local_search_label" msgid="2551177578246113614">"Bonke oxhumana nabo"</string>
@@ -531,8 +463,7 @@
     <string name="list_filter_single" msgid="5871400283515893087">"Othintana nabo"</string>
     <string name="custom_list_filter" msgid="7836035257402013957">"Cacisa ukubuka ngokwezifisio"</string>
     <string name="activity_title_settings" msgid="5464130076132770781">"Izilungiselelo"</string>
-    <!-- no translation found for activity_title_contacts_filter (8275542497615516969) -->
-    <skip />
+    <string name="activity_title_contacts_filter" msgid="8275542497615516969">"Othintana nabo abazoboniswa"</string>
     <string name="menu_settings" msgid="377929915873428211">"Izilungiselelo"</string>
     <string name="preference_displayOptions" msgid="1341720270148252393">"Bonisa okukhethwa kukho"</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>
@@ -551,100 +482,80 @@
     <string name="create_group_dialog_title" msgid="6874527142828424475">"Dala iqembu elisha"</string>
     <string name="create_group_item_label" msgid="5218022006186243310">"[Yenza iqembu elisha]"</string>
     <string name="delete_group_dialog_title" msgid="7368429698398624427">"Susa iqembu"</string>
-    <!-- no translation found for num_groups_in_account:one (2944819210288517794) -->
-    <!-- no translation found for num_groups_in_account:other (1276758425904917367) -->
+  <plurals name="num_groups_in_account">
+    <item quantity="one" msgid="2944819210288517794">"1 isigcawu"</item>
+    <item quantity="other" msgid="1276758425904917367">"<xliff:g id="COUNT">%0$d</xliff:g> Amaqembu"</item>
+  </plurals>
     <string name="delete_group_dialog_message" msgid="295063284548750881">"Uqinisekile ukuthi ufuna ukususa iqembu \'<xliff:g id="GROUP_LABEL">%1$s</xliff:g>\'? (Othintana nabo ngokwabo ngeke basuseke.)"</string>
-    <!-- no translation found for num_contacts_in_group:one (1352418549951013448) -->
-    <!-- no translation found for num_contacts_in_group:other (8146027769011086349) -->
-    <!-- no translation found for group_list_num_contacts_in_group:one (3323065321661972446) -->
-    <!-- no translation found for group_list_num_contacts_in_group:other (6251996206137048525) -->
+  <plurals name="num_contacts_in_group">
+    <item quantity="one" msgid="1352418549951013448">"<xliff:g id="COUNT_0">%1$d</xliff:g> umuntu kusuka ku-<xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+    <item quantity="other" msgid="8146027769011086349">"<xliff:g id="COUNT_0">%1$d</xliff:g> abantu abasuka ku- <xliff:g id="ACCOUNT_TYPE">%2$s</xliff:g>"</item>
+  </plurals>
+  <plurals name="group_list_num_contacts_in_group">
+    <item quantity="one" msgid="3323065321661972446">"<xliff:g id="COUNT">%1$d</xliff:g> umuntu"</item>
+    <item quantity="other" msgid="6251996206137048525">"<xliff:g id="COUNT">%1$d</xliff:g> abantu"</item>
+  </plurals>
     <string name="toast_join_with_empty_contact" msgid="5015189525953438968">"Sicela ufake igama lothintana naye ngaphambi kokujoyina nomunye othintana naye."</string>
-    <!-- no translation found for copy_text (3257145021583508761) -->
-    <skip />
-    <!-- no translation found for set_default (4417505153468300351) -->
-    <skip />
-    <!-- no translation found for clear_default (7193185801596678067) -->
-    <skip />
+    <string name="copy_text" msgid="3257145021583508761">"Kopisha ku-clipboard"</string>
+    <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_title" msgid="3950463632415908534">"Lahla izinguquko"</string>
     <string name="cancel_confirmation_dialog_message" msgid="7021968394611740251">"Ingabe ufuna ukulahla izinguquko zakho?"</string>
-    <!-- no translation found for call_type_and_date (1766269584078149149) -->
-    <skip />
+    <string name="call_type_and_date" msgid="1766269584078149149">"<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>
-    <!-- no translation found for view_updates_from_group (1782685984905600034) -->
-    <skip />
-    <!-- no translation found for notification_voicemail_title:one (1746619685488504230) -->
-    <!-- no translation found for notification_voicemail_title:other (5513481419205061254) -->
-    <!-- no translation found for notification_voicemail_callers_list (1153954809339404149) -->
-    <skip />
-    <!-- no translation found for notification_new_voicemail_ticker (895342132049452081) -->
-    <skip />
+    <string name="view_updates_from_group" msgid="1782685984905600034">"Buka Okwenziwe Kabusha"</string>
+  <plurals name="notification_voicemail_title">
+    <item quantity="one" msgid="1746619685488504230">"Ivoyisimeyili"</item>
+    <item quantity="other" msgid="5513481419205061254">"<xliff:g id="COUNT">%1$d</xliff:g> ama-meyli ezwi"</item>
+  </plurals>
+    <string name="notification_voicemail_callers_list" msgid="1153954809339404149">"<xliff:g id="NEWER_CALLERS">%1$s</xliff:g>, <xliff:g id="OLDER_CALLER">%2$s</xliff:g>"</string>
+    <string name="notification_new_voicemail_ticker" msgid="895342132049452081">"I-imeyli entsha esuka ku <xliff:g id="CALLER">%1$s</xliff:g>"</string>
     <string name="voicemail_playback_error" msgid="1811242131549854624">"Yehlulekile ukudlala i-voicemail."</string>
     <string name="voicemail_buffering" msgid="738287747618697097">"Ukugcina kumthamo"</string>
     <string name="voicemail_fetching_content" msgid="877911315738258780">"ilanda i-voicemail..."</string>
     <string name="voicemail_fetching_timout" msgid="6691792377574905201">"Yehlulekile ukulanda i-voicemail."</string>
-    <!-- no translation found for call_log_new_header (846546437517724715) -->
-    <skip />
-    <!-- no translation found for call_log_old_header (6262205894314263629) -->
-    <skip />
-    <!-- no translation found for voicemail_status_voicemail_not_available (3164200979671881947) -->
-    <skip />
-    <!-- no translation found for voicemail_status_messages_waiting (2970301042310727909) -->
-    <skip />
-    <!-- no translation found for voicemail_status_configure_voicemail (3940240432123700974) -->
-    <skip />
-    <!-- no translation found for voicemail_status_audio_not_available (3369618334553341626) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_configure (7008713959076506385) -->
-    <skip />
-    <!-- no translation found for voicemail_status_action_call_server (1824816252288551794) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slowest (6047030504814773029) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_slower (7890393922358642543) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_normal (6030110237820243006) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_faster (4161478290979905481) -->
-    <skip />
-    <!-- no translation found for voicemail_speed_fastest (3373646875150544205) -->
-    <skip />
+    <string name="call_log_new_header" msgid="846546437517724715">"Okusha"</string>
+    <string name="call_log_old_header" msgid="6262205894314263629">"Okudadlana"</string>
+    <string name="voicemail_status_voicemail_not_available" msgid="3164200979671881947">"Ayikwazi ukuxhuma kusiphakeli se-imeyli yezwi."</string>
+    <string name="voicemail_status_messages_waiting" msgid="2970301042310727909">"Ayikwazi ukuxhumana nesiphakeli semeyli yezwi. Ama-imeyli ezwi amasha alindile"</string>
+    <string name="voicemail_status_configure_voicemail" msgid="3940240432123700974">"Misa ivoyisimeyili yakho"</string>
+    <string name="voicemail_status_audio_not_available" msgid="3369618334553341626">"Umsindo awutholakali"</string>
+    <string name="voicemail_status_action_configure" msgid="7008713959076506385">"Misa"</string>
+    <string name="voicemail_status_action_call_server" msgid="1824816252288551794">"Shayela ivoyisimeyili"</string>
+    <string name="voicemail_speed_slowest" msgid="6047030504814773029">"ijubane elincane kakhulu"</string>
+    <string name="voicemail_speed_slower" msgid="7890393922358642543">"ijubane elinensayo"</string>
+    <string name="voicemail_speed_normal" msgid="6030110237820243006">"ijubane elijwayelekile"</string>
+    <string name="voicemail_speed_faster" msgid="4161478290979905481">"ijubane elisheshayo"</string>
+    <string name="voicemail_speed_fastest" msgid="3373646875150544205">"Ijubane eliphezulu kakhudlwane"</string>
     <string name="call_log_item_count_and_date" msgid="7641933305703520787">"(<xliff:g id="COUNT">%1$d</xliff:g>) <xliff:g id="DATE">%2$s</xliff:g>"</string>
-    <!-- no translation found for group_name_hint (2659811836386413509) -->
-    <skip />
-    <!-- no translation found for nfc_vcard_file_name (2823095213265993609) -->
-    <skip />
-    <!-- no translation found for menu_show_voicemails_only (1898421289561435703) -->
-    <skip />
+    <string name="group_name_hint" msgid="2659811836386413509">"Igama leqemnbu"</string>
+    <string name="nfc_vcard_file_name" msgid="2823095213265993609">"Othintana naye utholakale nge-NFC"</string>
+    <string name="menu_show_voicemails_only" msgid="1898421289561435703">"Bonisa ama-imeyli ezwi kuphela"</string>
     <string name="menu_show_all_calls" msgid="7560347482073345885">"Bonisa zonke izingcingo ezenziwe"</string>
-    <!-- no translation found for status_available (5586870015822828392) -->
-    <skip />
-    <!-- no translation found for status_away (1838861100379804730) -->
-    <skip />
-    <!-- no translation found for status_busy (9147992455450257136) -->
-    <skip />
-    <!-- no translation found for description_call_log_call_button (8207201401459528442) -->
-    <skip />
-    <!-- no translation found for description_call_log_play_button (651182125650429846) -->
-    <skip />
-    <!-- no translation found for description_call_log_incoming_call (4485427487637250143) -->
-    <skip />
-    <!-- no translation found for description_call_log_outgoing_call (604831756853471658) -->
-    <skip />
-    <!-- no translation found for description_call_log_missed_call (2242805209983708825) -->
-    <skip />
-    <!-- no translation found for description_call_log_voicemail (4600798771975158948) -->
-    <skip />
+    <string name="status_available" msgid="5586870015822828392">"Yatholakala"</string>
+    <string name="status_away" msgid="1838861100379804730">"Akekho"</string>
+    <string name="status_busy" msgid="9147992455450257136">"Matasa"</string>
+    <string name="description_call_log_call_button" msgid="8207201401459528442">"Shayela inombolo"</string>
+    <string name="description_call_log_play_button" msgid="651182125650429846">"Dlala i-imeyli yezwi"</string>
+    <string name="description_call_log_incoming_call" msgid="4485427487637250143">"Ikholi engenayo"</string>
+    <string name="description_call_log_outgoing_call" msgid="604831756853471658">"Ikholi eliphumayo"</string>
+    <string name="description_call_log_missed_call" msgid="2242805209983708825">"Ikholi ekulahlekele"</string>
+    <string name="description_call_log_voicemail" msgid="4600798771975158948">"Ivoyisimeyili"</string>
     <string name="description_add_contact" msgid="3103414772502485851">"Faka oxhumana naye"</string>
     <string name="description_view_contact" msgid="5205669345700598415">"Bheka oxhumana naye <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_call" msgid="3443678121983852666">"Fonela <xliff:g id="NAME">%1$s</xliff:g>"</string>
     <string name="description_send_text_message" msgid="7803126439934046891">"Hambisa umyalezo ku <xliff:g id="NAME">%1$s</xliff:g>"</string>
-    <!-- no translation found for description_call_log_unheard_voicemail (118101684236996786) -->
+    <string name="description_call_log_unheard_voicemail" msgid="118101684236996786">"I-imeyli yezwi engazwakalanga"</string>
+    <!-- no translation found for description_send_message (6046623392322890962) -->
     <skip />
-    <!-- no translation found for call_log_empty_gecode (5588904744812100846) -->
+    <!-- no translation found for description_dial_phone_number (8831647331642648637) -->
     <skip />
-    <!-- outdated translation 9154761216179882405 -->     <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"MINA"</string>
+    <!-- no translation found for description_quick_contact_for (6737516415168327789) -->
+    <skip />
+    <string name="call_log_empty_gecode" msgid="5588904744812100846">"-"</string>
+    <string name="user_profile_contacts_list_header" msgid="5582421742835006940">"Mina"</string>
     <string name="local_profile_title" msgid="2021416826991393684">"Imininingwane yami yakuleli"</string>
     <string name="external_profile_title" msgid="8034998767621359438">"Imininingwane <xliff:g id="EXTERNAL_SOURCE">%1$s</xliff:g> yami"</string>
     <string name="toast_displaying_all_contacts" msgid="2737388783898593875">"Ibonisa bonke abathintwayo"</string>
diff --git a/res/values/colors.xml b/res/values/colors.xml
index 561eefc..2fa7005 100644
--- a/res/values/colors.xml
+++ b/res/values/colors.xml
@@ -74,4 +74,6 @@
     <!--  Color of the vertical stripe that goes on the left of a block quote inside a stream item -->
     <color name="stream_item_stripe_color">#CCCCCC</color>
 
+    <!-- Color of image view placeholder. -->
+    <color name="image_placeholder">#DDDDDD</color>
 </resources>
diff --git a/res/values/donottranslate_config.xml b/res/values/donottranslate_config.xml
index 0da6485..79a2b29 100644
--- a/res/values/donottranslate_config.xml
+++ b/res/values/donottranslate_config.xml
@@ -120,4 +120,8 @@
     <!-- Height of the tab carousel as a percentage of the current screen width on the
          contact detail page -->
     <item name="tab_height_screen_width_percentage" type="fraction">50%</item>
+
+    <!-- Regular expression for prohibiting certain phone numbers in dialpad.
+         Ignored if empty. -->
+    <string name="config_prohibited_phone_number_regexp"></string>
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 075cbea..aa99d21 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -1799,4 +1799,26 @@
 
     <!-- Message in the standard "no account" prompt that encourages the user to add a Google account before continuing to use the People app [CHAR LIMIT=NONE] -->
     <string name="no_account_prompt">People works better with a Google Account.\n\n\u2022 Access from any web browser.\n\u2022 Back up your contacts securely.</string>
+
+    <!-- Message in the contact editor prompt that notifies the user that the newly created contact will not be saved to any account, and prompts addition of an account [CHAR LIMIT=NONE] -->
+    <string name="contact_editor_prompt_zero_accounts">Your new contact won\'t be backed up. Add an account that backs up contacts online?</string>
+
+    <!-- Message in the contact editor prompt that asks the user if it's okay to save the newly created contact to the account shown. [CHAR LIMIT=NONE] -->
+    <string name="contact_editor_prompt_one_account">Your new contact will be synchronized with <xliff:g id="account_name">%1$s</xliff:g>.</string>
+
+    <!-- Message in the contact editor prompt that asks the user which account they want to save the newly created contact to. [CHAR LIMIT=NONE] -->
+    <string name="contact_editor_prompt_multiple_accounts">You can synchronize your new contact with one of the following accounts. Which do you want to use?</string>
+
+    <!-- Button label to indicate that the user wants to save the newly created contact locally (instead of backing it up online) [CHAR LIMIT=20] -->
+    <string name="keep_local">Keep local</string>
+
+    <!-- Button label to prompt the user to add an account (when there are 0 existing accounts on the device) [CHAR LIMIT=30] -->
+    <string name="add_account">Add account</string>
+
+    <!-- Button label to prompt the user to add another account (when there are already existing accounts on the device) [CHAR LIMIT=30] -->
+    <string name="add_new_account">Add new account</string>
+
+    <!-- Dialog message which is shown when the user tries to make a phone call
+         to prohibited phone numbers [CHAR LIMIT=NONE] -->
+    <string name="phone_call_prohibited" msgid="4313552620858880999">Call not sent.</string>
 </resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
index 24822c0..6a64dfd 100644
--- a/res/values/styles.xml
+++ b/res/values/styles.xml
@@ -142,7 +142,7 @@
         <item name="list_item_profile_photo_size">70dip</item>
         <item name="list_item_prefix_highlight_color">#99cc00</item>
         <item name="list_item_header_text_color">@color/people_app_theme_color</item>
-        <item name="list_item_header_text_size">14dip</item>
+        <item name="list_item_header_text_size">14sp</item>
         <item name="list_item_header_height">26dip</item>
         <item name="list_item_header_underline_height">1dip</item>
         <item name="list_item_header_underline_color">@color/people_app_theme_color</item>
diff --git a/src/com/android/contacts/CallDetailActivity.java b/src/com/android/contacts/CallDetailActivity.java
index b7ccffc..8d7561a 100644
--- a/src/com/android/contacts/CallDetailActivity.java
+++ b/src/com/android/contacts/CallDetailActivity.java
@@ -507,7 +507,8 @@
                 ListView historyList = (ListView) findViewById(R.id.history);
                 historyList.setAdapter(
                         new CallDetailHistoryAdapter(CallDetailActivity.this, mInflater,
-                                mCallTypeHelper, details, hasVoicemail(), canPlaceCallsTo));
+                                mCallTypeHelper, details, hasVoicemail(), canPlaceCallsTo,
+                                findViewById(R.id.controls)));
                 BackScrollManager.bind(
                         new ScrollableHeader() {
                             private View controls = findViewById(R.id.controls);
diff --git a/src/com/android/contacts/ContactPhotoManager.java b/src/com/android/contacts/ContactPhotoManager.java
index b2ceffa..e04a07a 100644
--- a/src/com/android/contacts/ContactPhotoManager.java
+++ b/src/com/android/contacts/ContactPhotoManager.java
@@ -28,6 +28,8 @@
 import android.database.Cursor;
 import android.graphics.Bitmap;
 import android.graphics.BitmapFactory;
+import android.graphics.drawable.ColorDrawable;
+import android.graphics.drawable.Drawable;
 import android.net.Uri;
 import android.os.Handler;
 import android.os.Handler.Callback;
@@ -67,6 +69,35 @@
         return R.drawable.ic_contact_picture_holo_light;
     }
 
+    public static abstract class DefaultImageProvider {
+        public abstract void applyDefaultImage(ImageView view, boolean hires, boolean darkTheme);
+    }
+
+    private static class AvatarDefaultImageProvider extends DefaultImageProvider {
+        @Override
+        public void applyDefaultImage(ImageView view, boolean hires, boolean darkTheme) {
+            view.setImageResource(getDefaultAvatarResId(hires, darkTheme));
+        }
+    }
+
+    private static class BlankDefaultImageProvider extends DefaultImageProvider {
+        private static Drawable sDrawable;
+
+        @Override
+        public void applyDefaultImage(ImageView view, boolean hires, boolean darkTheme) {
+            if (sDrawable == null) {
+                Context context = view.getContext();
+                sDrawable = new ColorDrawable(context.getResources().getColor(
+                        R.color.image_placeholder));
+            }
+            view.setImageDrawable(sDrawable);
+        }
+    }
+
+    public static final DefaultImageProvider DEFAULT_AVATER = new AvatarDefaultImageProvider();
+
+    public static final DefaultImageProvider DEFAULT_BLANK = new BlankDefaultImageProvider();
+
     /**
      * Requests the singleton instance of {@link AccountTypeManager} with data bound from
      * the available authenticators. This method can safely be called from the UI thread.
@@ -91,14 +122,32 @@
      * it is displayed immediately.  Otherwise a request is sent to load the photo
      * from the database.
      */
-    public abstract void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme);
+    public abstract void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme,
+            DefaultImageProvider defaultProvider);
+
+    /**
+     * Calls {@link #loadPhoto(ImageView, long, boolean, boolean, DefaultImageProvider)} with
+     * {@link #DEFAULT_AVATER}.
+     */
+    public final void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme) {
+        loadPhoto(view, photoId, hires, darkTheme, DEFAULT_AVATER);
+    }
 
     /**
      * Load photo into the supplied image view.  If the photo is already cached,
      * it is displayed immediately.  Otherwise a request is sent to load the photo
      * from the location specified by the URI.
      */
-    public abstract void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme);
+    public abstract void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme,
+            DefaultImageProvider defaultProvider);
+
+    /**
+     * Calls {@link #loadPhoto(ImageView, Uri, boolean, boolean, DefaultImageProvider)} with
+     * {@link #DEFAULT_AVATER}.
+     */
+    public final void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme) {
+        loadPhoto(view, photoUri, hires, darkTheme, DEFAULT_AVATER);
+    }
 
     /**
      * Remove photo from the supplied image view. This also cancels current pending load request
@@ -236,24 +285,28 @@
     }
 
     @Override
-    public void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme) {
+    public void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme,
+            DefaultImageProvider defaultProvider) {
         if (photoId == 0) {
             // No photo is needed
-            view.setImageResource(getDefaultAvatarResId(hires, darkTheme));
+            defaultProvider.applyDefaultImage(view, hires, darkTheme);
             mPendingRequests.remove(view);
         } else {
-            loadPhotoByIdOrUri(view, Request.createFromId(photoId, hires, darkTheme));
+            loadPhotoByIdOrUri(view, Request.createFromId(photoId, hires, darkTheme,
+                    defaultProvider));
         }
     }
 
     @Override
-    public void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme) {
+    public void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme,
+            DefaultImageProvider defaultProvider) {
         if (photoUri == null) {
             // No photo is needed
-            view.setImageResource(getDefaultAvatarResId(hires, darkTheme));
+            defaultProvider.applyDefaultImage(view, hires, darkTheme);
             mPendingRequests.remove(view);
         } else {
-            loadPhotoByIdOrUri(view, Request.createFromUri(photoUri, hires, darkTheme));
+            loadPhotoByIdOrUri(view, Request.createFromUri(photoUri, hires, darkTheme,
+                    defaultProvider));
         }
     }
 
@@ -292,12 +345,12 @@
         BitmapHolder holder = mBitmapHolderCache.get(request.getKey());
         if (holder == null) {
             // The bitmap has not been loaded - should display the placeholder image.
-            view.setImageResource(getDefaultAvatarResId(request.isHires(), request.isDarkTheme()));
+            request.applyDefaultImage(view);
             return false;
         }
 
         if (holder.bytes == null) {
-            view.setImageResource(getDefaultAvatarResId(request.isHires(), request.isDarkTheme()));
+            request.applyDefaultImage(view);
             return holder.fresh;
         }
 
@@ -791,20 +844,25 @@
         private final Uri mUri;
         private final boolean mDarkTheme;
         private final boolean mHires;
+        private final DefaultImageProvider mDefaultProvider;
 
-        private Request(long id, Uri uri, boolean hires, boolean darkTheme) {
+        private Request(long id, Uri uri, boolean hires, boolean darkTheme,
+                DefaultImageProvider defaultProvider) {
             mId = id;
             mUri = uri;
             mDarkTheme = darkTheme;
             mHires = hires;
+            mDefaultProvider = defaultProvider;
         }
 
-        public static Request createFromId(long id, boolean hires, boolean darkTheme) {
-            return new Request(id, null /* no URI */, hires, darkTheme);
+        public static Request createFromId(long id, boolean hires, boolean darkTheme,
+                DefaultImageProvider defaultProvider) {
+            return new Request(id, null /* no URI */, hires, darkTheme, defaultProvider);
         }
 
-        public static Request createFromUri(Uri uri, boolean hires, boolean darkTheme) {
-            return new Request(0 /* no ID */, uri, hires, darkTheme);
+        public static Request createFromUri(Uri uri, boolean hires, boolean darkTheme,
+                DefaultImageProvider defaultProvider) {
+            return new Request(0 /* no ID */, uri, hires, darkTheme, defaultProvider);
         }
 
         public boolean isDarkTheme() {
@@ -841,5 +899,9 @@
         public Object getKey() {
             return mUri == null ? mId : mUri;
         }
+
+        public void applyDefaultImage(ImageView view) {
+            mDefaultProvider.applyDefaultImage(view, mHires, mDarkTheme);
+        }
     }
 }
diff --git a/src/com/android/contacts/ContactSaveService.java b/src/com/android/contacts/ContactSaveService.java
index e465772..2697589 100644
--- a/src/com/android/contacts/ContactSaveService.java
+++ b/src/com/android/contacts/ContactSaveService.java
@@ -331,10 +331,11 @@
                             new String[] {Contacts._ID, Contacts.LOOKUP_KEY},
                             null, null, null);
                     try {
-                        c.moveToFirst();
-                        final long contactId = c.getLong(0);
-                        final String lookupKey = c.getString(1);
-                        lookupUri = Contacts.getLookupUri(contactId, lookupKey);
+                        if (c.moveToFirst()) {
+                            final long contactId = c.getLong(0);
+                            final String lookupKey = c.getString(1);
+                            lookupUri = Contacts.getLookupUri(contactId, lookupKey);
+                        }
                     } finally {
                         c.close();
                     }
diff --git a/src/com/android/contacts/ContactsApplication.java b/src/com/android/contacts/ContactsApplication.java
index 4007916..eb8ffa9 100644
--- a/src/com/android/contacts/ContactsApplication.java
+++ b/src/com/android/contacts/ContactsApplication.java
@@ -22,6 +22,7 @@
 import com.google.common.annotations.VisibleForTesting;
 
 import android.app.Application;
+import android.app.FragmentManager;
 import android.app.LoaderManager;
 import android.content.ContentResolver;
 import android.content.Context;
@@ -109,10 +110,11 @@
         Context context = getApplicationContext();
         PreferenceManager.getDefaultSharedPreferences(context);
         AccountTypeManager.getInstance(context);
-        LoaderManager.enableDebugLogging(true);
 
-        StrictMode.setThreadPolicy(
-                new StrictMode.ThreadPolicy.Builder().detectAll().penaltyLog().build());
+        if (Log.isLoggable(Constants.STRICT_MODE_TAG, Log.DEBUG)) {
+            StrictMode.setThreadPolicy(
+                    new StrictMode.ThreadPolicy.Builder().detectAll().penaltyLog().build());
+        }
 
         if (Log.isLoggable(Constants.PERFORMANCE_TAG, Log.DEBUG)) {
             Log.d(Constants.PERFORMANCE_TAG, "ContactsApplication.onCreate finish");
diff --git a/src/com/android/contacts/GroupMemberLoader.java b/src/com/android/contacts/GroupMemberLoader.java
index 9605747..a75da48 100644
--- a/src/com/android/contacts/GroupMemberLoader.java
+++ b/src/com/android/contacts/GroupMemberLoader.java
@@ -16,6 +16,7 @@
 package com.android.contacts;
 
 import com.android.contacts.list.ContactListAdapter;
+import com.android.contacts.preference.ContactsPreferences;
 
 import android.content.Context;
 import android.content.CursorLoader;
@@ -81,7 +82,13 @@
         setProjection(PROJECTION_DATA);
         setSelection(createSelection());
         setSelectionArgs(createSelectionArgs());
-        setSortOrder(Contacts.SORT_KEY_ALTERNATIVE);
+
+        ContactsPreferences prefs = new ContactsPreferences(context);
+        if (prefs.getSortOrder() == ContactsContract.Preferences.SORT_ORDER_PRIMARY) {
+            setSortOrder(Contacts.SORT_KEY_PRIMARY);
+        } else {
+            setSortOrder(Contacts.SORT_KEY_ALTERNATIVE);
+        }
     }
 
     private Uri createUri() {
diff --git a/src/com/android/contacts/activities/ConfirmAddDetailActivity.java b/src/com/android/contacts/activities/ConfirmAddDetailActivity.java
index 95a39e7..4b297d9 100644
--- a/src/com/android/contacts/activities/ConfirmAddDetailActivity.java
+++ b/src/com/android/contacts/activities/ConfirmAddDetailActivity.java
@@ -560,8 +560,7 @@
             final String dataSet = state.getValues().getAsString(RawContacts.DATA_SET);
             final AccountType type = mAccountTypeManager.getAccountType(accountType, dataSet);
 
-            // Raw contacts that are not from external sources should be editable.
-            if (!type.isExternal()) {
+            if (type.areContactsWritable()) {
                 mEditableAccountType = type;
                 mState = state;
                 return;
diff --git a/src/com/android/contacts/activities/GroupDetailActivity.java b/src/com/android/contacts/activities/GroupDetailActivity.java
index 2708d5d..b0355fc 100644
--- a/src/com/android/contacts/activities/GroupDetailActivity.java
+++ b/src/com/android/contacts/activities/GroupDetailActivity.java
@@ -105,7 +105,9 @@
 
         @Override
         public void onContactSelected(Uri contactUri) {
-            startActivity(new Intent(Intent.ACTION_VIEW, contactUri));
+            Intent intent = new Intent(Intent.ACTION_VIEW, contactUri);
+            intent.putExtra(ContactDetailActivity.INTENT_KEY_IGNORE_DEFAULT_UP_BEHAVIOR, true);
+            startActivity(intent);
         }
 
     };
diff --git a/src/com/android/contacts/calllog/CallDetailHistoryAdapter.java b/src/com/android/contacts/calllog/CallDetailHistoryAdapter.java
index ed9c2e0..22b85d7 100644
--- a/src/com/android/contacts/calllog/CallDetailHistoryAdapter.java
+++ b/src/com/android/contacts/calllog/CallDetailHistoryAdapter.java
@@ -45,16 +45,30 @@
     private final boolean mShowVoicemail;
     /** Whether the call and SMS controls are shown. */
     private final boolean mShowCallAndSms;
+    /** The controls that are shown on top of the history list. */
+    private final View mControls;
+    /** The listener to changes of focus of the header. */
+    private View.OnFocusChangeListener mHeaderFocusChangeListener =
+            new View.OnFocusChangeListener() {
+        @Override
+        public void onFocusChange(View v, boolean hasFocus) {
+            // When the header is focused, focus the controls above it instead.
+            if (hasFocus) {
+                mControls.requestFocus();
+            }
+        }
+    };
 
     public CallDetailHistoryAdapter(Context context, LayoutInflater layoutInflater,
             CallTypeHelper callTypeHelper, PhoneCallDetails[] phoneCallDetails,
-            boolean showVoicemail, boolean showCallAndSms) {
+            boolean showVoicemail, boolean showCallAndSms, View controls) {
         mContext = context;
         mLayoutInflater = layoutInflater;
         mCallTypeHelper = callTypeHelper;
         mPhoneCallDetails = phoneCallDetails;
         mShowVoicemail = showVoicemail;
         mShowCallAndSms = showCallAndSms;
+        mControls = controls;
     }
 
     @Override
@@ -103,6 +117,8 @@
             // Call and SMS controls are only shown in the main UI if there is a known number.
             View callAndSmsContainer = header.findViewById(R.id.header_call_and_sms_container);
             callAndSmsContainer.setVisibility(mShowCallAndSms ? View.VISIBLE : View.GONE);
+            header.setFocusable(true);
+            header.setOnFocusChangeListener(mHeaderFocusChangeListener);
             return header;
         }
 
diff --git a/src/com/android/contacts/detail/PrimaryActionViewContainer.java b/src/com/android/contacts/detail/ActionsViewContainer.java
similarity index 79%
rename from src/com/android/contacts/detail/PrimaryActionViewContainer.java
rename to src/com/android/contacts/detail/ActionsViewContainer.java
index a342884..05382eb 100644
--- a/src/com/android/contacts/detail/PrimaryActionViewContainer.java
+++ b/src/com/android/contacts/detail/ActionsViewContainer.java
@@ -25,21 +25,21 @@
 
 /**
  * Custom {@link LinearLayout} which remembers its position in the {@link ListView}. Should be
- * used for primary touch targets in {@link ContactDetailFragment}.
+ * used for action touch targets in {@link ContactDetailFragment}.
  */
-/* package */ class PrimaryActionViewContainer extends LinearLayout {
+/* package */ class ActionsViewContainer extends LinearLayout {
 
     private ContextMenuInfo mContextMenuInfo;
 
-    public PrimaryActionViewContainer(Context context) {
+    public ActionsViewContainer(Context context) {
         super(context);
     }
 
-    public PrimaryActionViewContainer(Context context, AttributeSet attrs) {
+    public ActionsViewContainer(Context context, AttributeSet attrs) {
         this(context, attrs, 0);
     }
 
-    public PrimaryActionViewContainer(Context context, AttributeSet attrs, int defStyle) {
+    public ActionsViewContainer(Context context, AttributeSet attrs, int defStyle) {
         super(context, attrs, defStyle);
     }
 
diff --git a/src/com/android/contacts/detail/ContactDetailDisplayUtils.java b/src/com/android/contacts/detail/ContactDetailDisplayUtils.java
index bdcd6b0..ce5bf8d 100644
--- a/src/com/android/contacts/detail/ContactDetailDisplayUtils.java
+++ b/src/com/android/contacts/detail/ContactDetailDisplayUtils.java
@@ -249,7 +249,8 @@
         setDataOrHideIfNone(snippet, statusView);
         if (photoUri != null) {
             ContactPhotoManager.getInstance(context).loadPhoto(
-                    statusPhotoView, Uri.parse(photoUri), true, false);
+                    statusPhotoView, Uri.parse(photoUri), true, false,
+                    ContactPhotoManager.DEFAULT_BLANK);
             statusPhotoView.setVisibility(View.VISIBLE);
         } else {
             statusPhotoView.setVisibility(View.GONE);
@@ -339,7 +340,7 @@
             pushLayerView.setEnabled(false);
         }
         contactPhotoManager.loadPhoto(imageView, Uri.parse(streamItemPhoto.getPhotoUri()), true,
-                false);
+                false, ContactPhotoManager.DEFAULT_BLANK);
     }
 
     @VisibleForTesting
diff --git a/src/com/android/contacts/detail/ContactDetailFragment.java b/src/com/android/contacts/detail/ContactDetailFragment.java
index e111620..605a920 100644
--- a/src/com/android/contacts/detail/ContactDetailFragment.java
+++ b/src/com/android/contacts/detail/ContactDetailFragment.java
@@ -23,7 +23,6 @@
 import com.android.contacts.ContactSaveService;
 import com.android.contacts.ContactsUtils;
 import com.android.contacts.GroupMetaData;
-import com.android.contacts.NfcHandler;
 import com.android.contacts.R;
 import com.android.contacts.TypePrecedence;
 import com.android.contacts.activities.ContactDetailActivity.FragmentKeyListener;
@@ -154,7 +153,6 @@
 
     private Button mQuickFixButton;
     private QuickFix mQuickFix;
-    private final ArrayList<Long> mWritableRawContactIds = new ArrayList<Long>();
     private int mNumPhoneNumbers = 0;
     private String mDefaultCountryIso;
     private boolean mContactHasSocialUpdates;
@@ -531,8 +529,6 @@
         mPrimaryPhoneUri = null;
         mNumPhoneNumbers = 0;
 
-        mWritableRawContactIds.clear();
-
         final AccountTypeManager accountTypes = AccountTypeManager.getInstance(mContext);
 
         // Build up method entries
@@ -550,10 +546,8 @@
             if (!mRawContactIds.contains(rawContactId)) {
                 mRawContactIds.add(rawContactId);
             }
+
             AccountType type = accountTypes.getAccountType(accountType, dataSet);
-            if (type == null || !type.readOnly) {
-                mWritableRawContactIds.add(rawContactId);
-            }
 
             for (NamedContentValues subValue : entity.getSubValues()) {
                 final ContentValues entryValues = subValue.values;
@@ -1411,7 +1405,8 @@
         public final TextView footer;
         public final ImageView presenceIcon;
         public final ImageView secondaryActionButton;
-        public final View primaryActionViewContainer;
+        public final View actionsViewContainer;
+        public final View primaryActionView;
         public final View secondaryActionViewContainer;
         public final View secondaryActionDivider;
         public final View primaryIndicator;
@@ -1425,8 +1420,9 @@
             primaryIndicator = view.findViewById(R.id.primary_indicator);
             presenceIcon = (ImageView) view.findViewById(R.id.presence_icon);
 
-            primaryActionViewContainer = view.findViewById(R.id.primary_action_view_container);
-            primaryActionViewContainer.setOnClickListener(primaryActionClickListener);
+            actionsViewContainer = view.findViewById(R.id.actions_view_container);
+            actionsViewContainer.setOnClickListener(primaryActionClickListener);
+            primaryActionView = view.findViewById(R.id.primary_action_view);
 
             secondaryActionViewContainer = view.findViewById(
                     R.id.secondary_action_view_container);
@@ -1625,11 +1621,11 @@
                 presenceIconView.setVisibility(View.GONE);
             }
 
-            final PrimaryActionViewContainer primaryActionButtonContainer =
-                    (PrimaryActionViewContainer) views.primaryActionViewContainer;
-            primaryActionButtonContainer.setTag(entry);
-            primaryActionButtonContainer.setPosition(position);
-            registerForContextMenu(primaryActionButtonContainer);
+            final ActionsViewContainer actionsButtonContainer =
+                    (ActionsViewContainer) views.actionsViewContainer;
+            actionsButtonContainer.setTag(entry);
+            actionsButtonContainer.setPosition(position);
+            registerForContextMenu(actionsButtonContainer);
 
             // Set the secondary action button
             final ImageView secondaryActionView = views.secondaryActionButton;
@@ -1655,14 +1651,18 @@
                 views.secondaryActionDivider.setVisibility(View.GONE);
             }
 
-            // Right padding should not have "pressed" effect.
-            view.setPadding(0, 0, mViewEntryDimensions.getPaddingRight(), 0);
-            // Top, left, and bottom paddings should have "pressed" effect.
-            primaryActionButtonContainer.setPadding(entry.isInSubSection() ?
-                    mViewEntryDimensions.getWidePaddingLeft() :
-                            mViewEntryDimensions.getPaddingLeft(),
+            // Right and left padding should not have "pressed" effect.
+            view.setPadding(
+                    entry.isInSubSection()
+                            ? mViewEntryDimensions.getWidePaddingLeft()
+                            : mViewEntryDimensions.getPaddingLeft(),
+                    0, mViewEntryDimensions.getPaddingRight(), 0);
+            // Top and bottom padding should have "pressed" effect.
+            final View primaryActionView = views.primaryActionView;
+            primaryActionView.setPadding(
+                    primaryActionView.getPaddingLeft(),
                     mViewEntryDimensions.getPaddingTop(),
-                    0,
+                    primaryActionView.getPaddingRight(),
                     mViewEntryDimensions.getPaddingBottom());
             secondaryActionViewContainer.setPadding(
                     secondaryActionViewContainer.getPaddingLeft(),
@@ -1943,7 +1943,7 @@
                     AccountTypeManager.getInstance(mContext);
             final AccountType type = accountTypes.getAccountType(accountType, dataSet);
             // Offline or non-writeable account? Nothing to fix
-            if (type == null || type.readOnly) return false;
+            if (type == null || !type.areContactsWritable()) return false;
 
             // Check whether the contact is in the default group
             boolean isInDefaultGroup = false;
diff --git a/src/com/android/contacts/dialpad/DialpadFragment.java b/src/com/android/contacts/dialpad/DialpadFragment.java
index 45cb03b..412ceff 100644
--- a/src/com/android/contacts/dialpad/DialpadFragment.java
+++ b/src/com/android/contacts/dialpad/DialpadFragment.java
@@ -27,8 +27,12 @@
 import com.android.phone.HapticFeedback;
 
 import android.app.Activity;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.DialogFragment;
 import android.app.Fragment;
 import android.content.Context;
+import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.database.Cursor;
@@ -37,7 +41,6 @@
 import android.media.AudioManager;
 import android.media.ToneGenerator;
 import android.net.Uri;
-import android.os.AsyncTask;
 import android.os.Bundle;
 import android.os.RemoteException;
 import android.os.ServiceManager;
@@ -46,7 +49,6 @@
 import android.provider.Contacts.Phones;
 import android.provider.Contacts.PhonesColumns;
 import android.provider.Settings;
-import android.telephony.PhoneNumberFormattingTextWatcher;
 import android.telephony.PhoneNumberUtils;
 import android.telephony.PhoneStateListener;
 import android.telephony.TelephonyManager;
@@ -61,16 +63,21 @@
 import android.view.MenuInflater;
 import android.view.MenuItem;
 import android.view.View;
+import android.view.View.OnClickListener;
 import android.view.ViewConfiguration;
 import android.view.ViewGroup;
 import android.widget.AdapterView;
 import android.widget.BaseAdapter;
+import android.widget.Button;
 import android.widget.EditText;
 import android.widget.ImageView;
 import android.widget.ListView;
 import android.widget.PopupMenu;
 import android.widget.TextView;
 
+import java.util.HashSet;
+import java.util.Set;
+
 /**
  * Fragment that displays a twelve-key phone dialpad.
  */
@@ -117,6 +124,11 @@
     private ListView mDialpadChooser;
     private DialpadChooserAdapter mDialpadChooserAdapter;
 
+    /**
+     * Regular expression prohibiting manual phone call. Can be empty, which means "no rule".
+     */
+    private String mProhibitedPhoneNumberRegexp;
+
     private boolean mShowOptionsMenu;
 
     private boolean mHasVoicemail = false;
@@ -219,6 +231,9 @@
         }
 
         setHasOptionsMenu(true);
+
+        mProhibitedPhoneNumberRegexp = getResources().getString(
+                R.string.config_prohibited_phone_number_regexp);
     }
 
     @Override
@@ -794,6 +809,26 @@
         getActivity().finish();
     }
 
+    public static class CallProhibitedDialogFragment extends DialogFragment {
+        public static CallProhibitedDialogFragment newInstance() {
+            return new CallProhibitedDialogFragment();
+        }
+
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            return new AlertDialog.Builder(getActivity())
+                    .setTitle(R.string.phone_call_prohibited)
+                    .setPositiveButton(android.R.string.ok,
+                            new DialogInterface.OnClickListener() {
+                                @Override
+                                public void onClick(DialogInterface dialog, int which) {
+                                    dismiss();
+                                }
+                            })
+                    .create();
+        }
+    }
+
     /**
      * In most cases, when the dial button is pressed, there is a
      * number in digits area. Pack it in the intent, start the
@@ -847,9 +882,22 @@
         } else {
             final String number = mDigits.getText().toString();
 
-            startActivity(newDialNumberIntent(number));
-            mDigits.getText().clear();  // TODO: Fix bug 1745781
-            getActivity().finish();
+            if (number != null
+                    && !TextUtils.isEmpty(mProhibitedPhoneNumberRegexp)
+                    && number.matches(mProhibitedPhoneNumberRegexp)) {
+                Log.i(TAG, "The phone number is prohibited explicitly by a rule.");
+                if (getActivity() != null) {
+                    DialogFragment dialogFragment = CallProhibitedDialogFragment.newInstance();
+                    dialogFragment.show(getFragmentManager(), "phone_prohibited_dialog");
+                }
+
+                // Clear the digits just in case.
+                mDigits.getText().clear();
+            } else {
+                startActivity(newDialNumberIntent(number));
+                mDigits.getText().clear();  // TODO: Fix bug 1745781
+                getActivity().finish();
+            }
         }
     }
 
@@ -1224,7 +1272,7 @@
                 // been entered, or if there is a last dialed number
                 // that could be redialed.
                 mDialButton.setEnabled(digitsNotEmpty ||
-                                       !TextUtils.isEmpty(mLastNumberDialed));
+                        !TextUtils.isEmpty(mLastNumberDialed));
             }
         }
         mDelete.setEnabled(digitsNotEmpty);
diff --git a/src/com/android/contacts/editor/AggregationSuggestionView.java b/src/com/android/contacts/editor/AggregationSuggestionView.java
index 996dbc4..9d7e16a 100644
--- a/src/com/android/contacts/editor/AggregationSuggestionView.java
+++ b/src/com/android/contacts/editor/AggregationSuggestionView.java
@@ -120,7 +120,7 @@
                 return true;
             }
             AccountType type = accountTypes.getAccountType(accountType, dataSet);
-            if (!type.readOnly) {
+            if (type.areContactsWritable()) {
                 return true;
             }
         }
diff --git a/src/com/android/contacts/editor/ContactEditorFragment.java b/src/com/android/contacts/editor/ContactEditorFragment.java
index 2e54642..a8c0b36 100644
--- a/src/com/android/contacts/editor/ContactEditorFragment.java
+++ b/src/com/android/contacts/editor/ContactEditorFragment.java
@@ -95,7 +95,7 @@
 public class ContactEditorFragment extends Fragment implements
         SplitContactConfirmationDialogFragment.Listener,
         AggregationSuggestionEngine.Listener, AggregationSuggestionView.Listener,
-        ExternalRawContactEditorView.Listener {
+        RawContactReadOnlyEditorView.Listener {
 
     private static final String TAG = ContactEditorFragment.class.getSimpleName();
 
@@ -449,7 +449,8 @@
             String dataSet = entityValues.getAsString(RawContacts.DATA_SET);
             AccountType accountType = AccountTypeManager.getInstance(mContext).getAccountType(
                     type, dataSet);
-            if (accountType.getEditContactActivityClassName() != null) {
+            if (accountType.getEditContactActivityClassName() != null &&
+                    !accountType.areContactsWritable()) {
                 if (mListener != null) {
                     String name = entityValues.getAsString(RawContacts.ACCOUNT_NAME);
                     long rawContactId = entityValues.getAsLong(RawContacts.Entity._ID);
@@ -519,7 +520,7 @@
             final String accountType = state.getValues().getAsString(RawContacts.ACCOUNT_TYPE);
             final String dataSet = state.getValues().getAsString(RawContacts.DATA_SET);
             final AccountType type = accountTypes.getAccountType(accountType, dataSet);
-            if (!type.readOnly) {
+            if (type.areContactsWritable()) {
                 // Apply extras to the first writable raw contact only
                 EntityModifier.parseExtras(mContext, type, state, extras);
                 break;
@@ -671,10 +672,10 @@
             final long rawContactId = values.getAsLong(RawContacts._ID);
 
             final BaseRawContactEditorView editor;
-            if (type.isExternal()) {
+            if (!type.areContactsWritable()) {
                 editor = (BaseRawContactEditorView) inflater.inflate(
-                        R.layout.external_raw_contact_editor_view, mContent, false);
-                ((ExternalRawContactEditorView) editor).setListener(this);
+                        R.layout.raw_contact_readonly_editor_view, mContent, false);
+                ((RawContactReadOnlyEditorView) editor).setListener(this);
             } else {
                 editor = (RawContactEditorView) inflater.inflate(R.layout.raw_contact_editor_view,
                         mContent, false);
@@ -698,7 +699,7 @@
             editor.setState(entity, type, mViewIdGenerator, isEditingUserProfile());
 
             editor.getPhotoEditor().setEditorListener(
-                    new PhotoEditorListener(editor, type.readOnly));
+                    new PhotoEditorListener(editor, type.areContactsWritable()));
             if (editor instanceof RawContactEditorView) {
                 final RawContactEditorView rawContactEditor = (RawContactEditorView) editor;
                 EditorListener listener = new EditorListener() {
@@ -1154,7 +1155,7 @@
             final String accountType = values.getAsString(RawContacts.ACCOUNT_TYPE);
             final String dataSet = values.getAsString(RawContacts.DATA_SET);
             final AccountType type = accountTypes.getAccountType(accountType, dataSet);
-            if (!type.readOnly) {
+            if (type.areContactsWritable()) {
                 return true;
             }
         }
@@ -1234,9 +1235,9 @@
             final AccountType type2 = accountTypes.getAccountType(accountType2, dataSet2);
 
             // Check read-only
-            if (type1.readOnly && !type2.readOnly) {
+            if (!type1.areContactsWritable() && type2.areContactsWritable()) {
                 return 1;
-            } else if (!type1.readOnly && type2.readOnly) {
+            } else if (type1.areContactsWritable() && !type2.areContactsWritable()) {
                 return -1;
             }
 
@@ -1693,11 +1694,11 @@
     private final class PhotoEditorListener
             implements EditorListener, PhotoActionPopup.Listener {
         private final BaseRawContactEditorView mEditor;
-        private final boolean mAccountReadOnly;
+        private final boolean mAccountWritable;
 
-        private PhotoEditorListener(BaseRawContactEditorView editor, boolean accountReadOnly) {
+        private PhotoEditorListener(BaseRawContactEditorView editor, boolean accountWritable) {
             mEditor = editor;
-            mAccountReadOnly = accountReadOnly;
+            mAccountWritable = accountWritable;
         }
 
         @Override
@@ -1707,14 +1708,7 @@
             if (request == EditorListener.REQUEST_PICK_PHOTO) {
                 // Determine mode
                 final int mode;
-                if (mAccountReadOnly) {
-                    if (mEditor.hasSetPhoto() && hasMoreThanOnePhoto()) {
-                        mode = PhotoActionPopup.MODE_READ_ONLY_ALLOW_PRIMARY;
-                    } else {
-                        // Read-only and either no photo or the only photo ==> no options
-                        return;
-                    }
-                } else {
+                if (mAccountWritable) {
                     if (mEditor.hasSetPhoto()) {
                         if (hasMoreThanOnePhoto()) {
                             mode = PhotoActionPopup.MODE_PHOTO_ALLOW_PRIMARY;
@@ -1724,6 +1718,13 @@
                     } else {
                         mode = PhotoActionPopup.MODE_NO_PHOTO;
                     }
+                } else {
+                    if (mEditor.hasSetPhoto() && hasMoreThanOnePhoto()) {
+                        mode = PhotoActionPopup.MODE_READ_ONLY_ALLOW_PRIMARY;
+                    } else {
+                        // Read-only and either no photo or the only photo ==> no options
+                        return;
+                    }
                 }
                 PhotoActionPopup.createPopupMenu(mContext, mEditor.getPhotoEditor(), this, mode)
                         .show();
diff --git a/src/com/android/contacts/editor/ContactEditorUtils.java b/src/com/android/contacts/editor/ContactEditorUtils.java
new file mode 100644
index 0000000..0e27223
--- /dev/null
+++ b/src/com/android/contacts/editor/ContactEditorUtils.java
@@ -0,0 +1,249 @@
+/*
+ * Copyright (C) 2011 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 com.android.contacts.model.AccountType;
+import com.android.contacts.model.AccountTypeManager;
+import com.android.contacts.model.AccountWithDataSet;
+import com.android.contacts.test.NeededForTesting;
+import com.google.common.annotations.VisibleForTesting;
+import com.google.common.collect.ImmutableList;
+import com.google.common.collect.Sets;
+
+import android.accounts.Account;
+import android.accounts.AccountManager;
+import android.app.Activity;
+import android.content.Context;
+import android.content.Intent;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.text.TextUtils;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * Utility methods for the "account changed" notification in the new contact creation flow.
+ *
+ * TODO Remove all the "@VisibleForTesting"s once they're actually used in the app.
+ *      (Until then we need them to avoid "no such method" in tests)
+ */
+public class ContactEditorUtils {
+    private static final String TAG = "ContactEditorUtils";
+
+    private static final String KEY_DEFAULT_ACCOUNT = "ContactEditorUtils_default_account";
+    private static final String KEY_KNOWN_ACCOUNTS = "ContactEditorUtils_known_accounts";
+    // Key to tell the first time launch.
+    private static final String KEY_ANYTHING_SAVED = "ContactEditorUtils_anything_saved";
+
+    private static final List<AccountWithDataSet> EMPTY_ACCOUNTS = ImmutableList.of();
+
+    private static ContactEditorUtils sInstance;
+
+    private final Context mContext;
+    private final SharedPreferences mPrefs;
+    private final AccountTypeManager mAccountTypes;
+
+    private ContactEditorUtils(Context context) {
+        this(context, AccountTypeManager.getInstance(context));
+    }
+
+    @VisibleForTesting
+    ContactEditorUtils(Context context, AccountTypeManager accountTypes) {
+        mContext = context.getApplicationContext();
+        mPrefs = PreferenceManager.getDefaultSharedPreferences(mContext);
+        mAccountTypes = accountTypes;
+    }
+
+    public static synchronized ContactEditorUtils getInstance(Context context) {
+        if (sInstance == null) {
+            sInstance = new ContactEditorUtils(context);
+        }
+        return sInstance;
+    }
+
+    void cleanupForTest() {
+        mPrefs.edit().remove(KEY_DEFAULT_ACCOUNT).remove(KEY_KNOWN_ACCOUNTS)
+                .remove(KEY_ANYTHING_SAVED).apply();
+    }
+
+    private List<AccountWithDataSet> getWritableAccounts() {
+        return mAccountTypes.getAccounts(true);
+    }
+
+    /**
+     * @return true if it's the first launch and {@link #saveDefaultAndAllAccounts} has never
+     *     been called.
+     */
+    private boolean isFirstLaunch() {
+        return !mPrefs.getBoolean(KEY_ANYTHING_SAVED, false);
+    }
+
+    /**
+     * Saves all writable accounts and the default account, which can later be obtained
+     * with {@link #getDefaultAccount}.
+     *
+     * This should be called when saving a newly created contact.
+     *
+     * @param defaultAccount the account used to save a newly created contact.  Or pass {@code null}
+     *     If the user selected "local only".
+     */
+    @NeededForTesting
+    public void saveDefaultAndAllAccounts(AccountWithDataSet defaultAccount) {
+        mPrefs.edit()
+                .putBoolean(KEY_ANYTHING_SAVED, true)
+                .putString(
+                        KEY_KNOWN_ACCOUNTS,AccountWithDataSet.stringifyList(getWritableAccounts()))
+                .putString(KEY_DEFAULT_ACCOUNT,
+                        (defaultAccount == null) ? "" : defaultAccount.stringify())
+                .apply();
+    }
+
+    /**
+     * @return the default account saved with {@link #saveDefaultAndAllAccounts}.
+     *
+     * Note the {@code null} return value can mean either {@link #saveDefaultAndAllAccounts} has
+     * never been called, or {@code null} was passed to {@link #saveDefaultAndAllAccounts} --
+     * i.e. the user selected "local only".
+     *
+     * Also note that the returned account may have been removed already.
+     */
+    @NeededForTesting
+    public AccountWithDataSet getDefaultAccount() {
+        final String saved = mPrefs.getString(KEY_DEFAULT_ACCOUNT, null);
+        if (TextUtils.isEmpty(saved)) {
+            return null;
+        }
+        return AccountWithDataSet.unstringify(saved);
+    }
+
+    /**
+     * @return true if an account still exists.  {@code null} is considered "local only" here,
+     *    so it's valid too.
+     */
+    @VisibleForTesting
+    boolean isValidAccount(AccountWithDataSet account) {
+        if (account == null) {
+            return true; // It's "local only" account, which is valid.
+        }
+        return getWritableAccounts().contains(account);
+    }
+
+    /**
+     * @return saved known accounts, or an empty list if none has been saved yet.
+     */
+    @VisibleForTesting
+    List<AccountWithDataSet> getSavedAccounts() {
+        final String saved = mPrefs.getString(KEY_KNOWN_ACCOUNTS, null);
+        if (TextUtils.isEmpty(saved)) {
+            return EMPTY_ACCOUNTS;
+        }
+        return AccountWithDataSet.unstringifyList(saved);
+    }
+
+    /**
+     * @return true if the contact editor should show the "accounts changed" notification, that is:
+     * - If it's the first launch.
+     * - Or, if an account has been added.
+     * - Or, if the default account has been removed.
+     *
+     * Note if this method returns {@code false}, the caller can safely assume that
+     * {@link #getDefaultAccount} will return a valid account.  (Either an account which still
+     * exists, or {@code null} which should be interpreted as "local only".)
+     */
+    @NeededForTesting
+    public boolean shouldShowAccountChangedNotification() {
+        if (isFirstLaunch()) {
+            return true;
+        }
+
+        // Account added?
+        final List<AccountWithDataSet> savedAccounts = getSavedAccounts();
+        for (AccountWithDataSet account : getWritableAccounts()) {
+            if (!savedAccounts.contains(account)) {
+                return true; // New account found.
+            }
+        }
+
+        // Does default account still exist?
+        if (!isValidAccount(getDefaultAccount())) {
+            return true;
+        }
+
+        // All good.
+        return false;
+    }
+
+    @VisibleForTesting
+    String[] getWritableAccountTypeStrings() {
+        final Set<String> types = Sets.newHashSet();
+        for (AccountType type : mAccountTypes.getAccountTypes(true)) {
+            types.add(type.accountType);
+        }
+        return types.toArray(new String[types.size()]);
+    }
+
+    /**
+     * Create an {@link Intent} to start "add new account" setup wizard.  Selectable account
+     * types will be limited to ones that supports editing contacts.
+     *
+     * Use {@link Activity#startActivityForResult} or
+     * {@link android.app.Fragment#startActivityForResult} to start the wizard, and
+     * {@link Activity#onActivityResult} or {@link android.app.Fragment#onActivityResult} to
+     * get the result.
+     */
+    @NeededForTesting
+    public Intent createAddWritableAccountIntent() {
+        return AccountManager.newChooseAccountIntent(
+                null, // selectedAccount
+                new ArrayList<Account>(), // allowableAccounts
+                getWritableAccountTypeStrings(), // allowableAccountTypes
+                false, // alwaysPromptForAccount
+                null, // descriptionOverrideText
+                null, // addAccountAuthTokenType
+                null, // addAccountRequiredFeatures
+                null // addAccountOptions
+                );
+    }
+
+    /**
+     * Parses a result from {@link #createAddWritableAccountIntent} and returns the created
+     * {@link Account}, or null if the user has canceled the wizard.  Pass the {@code resultCode}
+     * and {@code data} parameters passed to {@link Activity#onActivityResult} or
+     * {@link android.app.Fragment#onActivityResult}.
+     *
+     * Note although the return type is {@link AccountWithDataSet}, return values from this method
+     * will never have {@link AccountWithDataSet#dataSet} set, as there's no way to create an
+     * extension package account from setup wizard.
+     */
+    @NeededForTesting
+    public AccountWithDataSet getCreatedAccount(int resultCode, Intent resultData) {
+        // Javadoc doesn't say anything about resultCode but that the data intent will be non null
+        // on success.
+        if (resultData == null) return null;
+
+        final String accountType = resultData.getStringExtra(AccountManager.KEY_ACCOUNT_TYPE);
+        final String accountName = resultData.getStringExtra(AccountManager.KEY_ACCOUNT_NAME);
+
+        // Just in case
+        if (TextUtils.isEmpty(accountType) || TextUtils.isEmpty(accountName)) return null;
+
+        return new AccountWithDataSet(accountName, accountType, null);
+    }
+}
+
diff --git a/src/com/android/contacts/editor/RawContactEditorView.java b/src/com/android/contacts/editor/RawContactEditorView.java
index 2d42a50..3a40a0f 100644
--- a/src/com/android/contacts/editor/RawContactEditorView.java
+++ b/src/com/android/contacts/editor/RawContactEditorView.java
@@ -195,8 +195,12 @@
                 accountType = mContext.getString(R.string.account_phone);
             }
             if (!TextUtils.isEmpty(accountName)) {
+                mAccountNameTextView.setVisibility(View.VISIBLE);
                 mAccountNameTextView.setText(
                         mContext.getString(R.string.from_account_format, accountName));
+            } else {
+                // Hide this view so the other text view will be centered vertically
+                mAccountNameTextView.setVisibility(View.GONE);
             }
             mAccountTypeTextView.setText(
                     mContext.getString(R.string.account_type_format, accountType));
diff --git a/src/com/android/contacts/editor/ExternalRawContactEditorView.java b/src/com/android/contacts/editor/RawContactReadOnlyEditorView.java
similarity index 94%
rename from src/com/android/contacts/editor/ExternalRawContactEditorView.java
rename to src/com/android/contacts/editor/RawContactReadOnlyEditorView.java
index 9b4f988..2cc5d98 100644
--- a/src/com/android/contacts/editor/ExternalRawContactEditorView.java
+++ b/src/com/android/contacts/editor/RawContactReadOnlyEditorView.java
@@ -51,7 +51,7 @@
 /**
  * Custom view that displays external contacts in the edit screen.
  */
-public class ExternalRawContactEditorView extends BaseRawContactEditorView
+public class RawContactReadOnlyEditorView extends BaseRawContactEditorView
         implements OnClickListener {
     private LayoutInflater mInflater;
 
@@ -76,11 +76,11 @@
         void onExternalEditorRequest(AccountWithDataSet account, Uri uri);
     }
 
-    public ExternalRawContactEditorView(Context context) {
+    public RawContactReadOnlyEditorView(Context context) {
         super(context);
     }
 
-    public ExternalRawContactEditorView(Context context, AttributeSet attrs) {
+    public RawContactReadOnlyEditorView(Context context, AttributeSet attrs) {
         super(context, attrs);
     }
 
@@ -148,8 +148,12 @@
                 accountType = mContext.getString(R.string.account_phone);
             }
             if (!TextUtils.isEmpty(mAccountName)) {
+                mAccountNameTextView.setVisibility(View.VISIBLE);
                 mAccountNameTextView.setText(
                         mContext.getString(R.string.from_account_format, mAccountName));
+            } else {
+                // Hide this view so the other text view will be centered vertically
+                mAccountNameTextView.setVisibility(View.GONE);
             }
             mAccountTypeTextView.setText(mContext.getString(R.string.account_type_format,
                     accountType));
@@ -172,7 +176,7 @@
             boolean hasPhotoEditor = type.getKindForMimetype(Photo.CONTENT_ITEM_TYPE) != null;
             setHasPhotoEditor(hasPhotoEditor);
             primary = state.getPrimaryEntry(Photo.CONTENT_ITEM_TYPE);
-            getPhotoEditor().setValues(kind, primary, state, type.readOnly, vig);
+            getPhotoEditor().setValues(kind, primary, state, !type.areContactsWritable(), vig);
             if (!hasPhotoEditor || !getPhotoEditor().hasSetPhoto()) {
                 mPhotoStub.setVisibility(View.GONE);
             } else {
@@ -187,7 +191,11 @@
         mName.setText(primary != null ? primary.getAsString(StructuredName.DISPLAY_NAME) :
                 mContext.getString(R.string.missing_name));
 
-        if (type.readOnly) {
+        if (type.getEditContactActivityClassName() != null) {
+            mAccountContainer.setBackgroundDrawable(null);
+            mAccountContainer.setEnabled(false);
+            mEditExternallyButton.setVisibility(View.VISIBLE);
+        } else {
             mAccountContainer.setOnClickListener(new OnClickListener() {
                 @Override
                 public void onClick(View v) {
@@ -196,10 +204,6 @@
                 }
             });
             mEditExternallyButton.setVisibility(View.GONE);
-        } else {
-            mAccountContainer.setBackgroundDrawable(null);
-            mAccountContainer.setEnabled(false);
-            mEditExternallyButton.setVisibility(View.VISIBLE);
         }
 
         final Resources res = mContext.getResources();
@@ -237,7 +241,8 @@
                 } else {
                     emailType = null;
                 }
-                bindData(mContext.getText(R.string.emailLabelsGroup), emailAddress, null, i == 0);
+                bindData(mContext.getText(R.string.emailLabelsGroup), emailAddress, emailType,
+                        i == 0);
             }
         }
 
diff --git a/src/com/android/contacts/editor/StructuredNameEditorView.java b/src/com/android/contacts/editor/StructuredNameEditorView.java
index 5a2ffd3..6911628 100644
--- a/src/com/android/contacts/editor/StructuredNameEditorView.java
+++ b/src/com/android/contacts/editor/StructuredNameEditorView.java
@@ -77,18 +77,18 @@
         if (!isFieldChanged(column, value)) {
             return;
         }
+        super.onFieldChanged(column, value);
 
         mChanged = true;
 
+        // Make sure the display name and the structured name are synced
         if (hasShortAndLongForms()) {
             if (areOptionalFieldsVisible()) {
-                eraseFullName(getValues());
+                rebuildFullName(getValues());
             } else {
-                eraseStructuredName(getValues());
+                rebuildStructuredName(getValues());
             }
         }
-
-        super.onFieldChanged(column, value);
     }
 
     @Override
@@ -165,12 +165,28 @@
         values.putNull(StructuredName.DISPLAY_NAME);
     }
 
+    private void rebuildFullName(ValuesDelta values) {
+        Map<String, String> structuredNameMap = valuesToStructuredNameMap(values);
+        String displayName = NameConverter.structuredNameToDisplayName(getContext(),
+                structuredNameMap);
+        values.put(StructuredName.DISPLAY_NAME, displayName);
+    }
+
     private void eraseStructuredName(ValuesDelta values) {
         for (String field : NameConverter.STRUCTURED_NAME_FIELDS) {
             values.putNull(field);
         }
     }
 
+    private void rebuildStructuredName(ValuesDelta values) {
+        String displayName = values.getAsString(StructuredName.DISPLAY_NAME);
+        Map<String, String> structuredNameMap = NameConverter.displayNameToStructuredName(
+                getContext(), displayName);
+        for (String field : structuredNameMap.keySet()) {
+            values.put(field, structuredNameMap.get(field));
+        }
+    }
+
     private static void appendQueryParameter(Uri.Builder builder, String field, String value) {
         if (!TextUtils.isEmpty(value)) {
             builder.appendQueryParameter(field, value);
diff --git a/src/com/android/contacts/interactions/ContactDeletionInteraction.java b/src/com/android/contacts/interactions/ContactDeletionInteraction.java
index 86f4eda..7e880a4 100644
--- a/src/com/android/contacts/interactions/ContactDeletionInteraction.java
+++ b/src/com/android/contacts/interactions/ContactDeletionInteraction.java
@@ -240,11 +240,11 @@
             contactId = cursor.getLong(COLUMN_INDEX_CONTACT_ID);
             lookupKey = cursor.getString(COLUMN_INDEX_LOOKUP_KEY);
             AccountType type = accountTypes.getAccountType(accountType, dataSet);
-            boolean readonly = type != null && type.readOnly;
-            if (readonly) {
-                readOnlyRawContacts.add(rawContactId);
-            } else {
+            boolean writable = type == null || type.areContactsWritable();
+            if (writable) {
                 writableRawContacts.add(rawContactId);
+            } else {
+                readOnlyRawContacts.add(rawContactId);
             }
         }
 
diff --git a/src/com/android/contacts/interactions/ImportExportDialogFragment.java b/src/com/android/contacts/interactions/ImportExportDialogFragment.java
index 078f63e..e0b617c 100644
--- a/src/com/android/contacts/interactions/ImportExportDialogFragment.java
+++ b/src/com/android/contacts/interactions/ImportExportDialogFragment.java
@@ -71,11 +71,11 @@
 
         // Adapter that shows a list of string resources
         final ArrayAdapter<Integer> adapter = new ArrayAdapter<Integer>(getActivity(),
-                android.R.layout.select_dialog_item) {
+                R.layout.select_dialog_item) {
             @Override
             public View getView(int position, View convertView, ViewGroup parent) {
                 final TextView result = (TextView)(convertView != null ? convertView :
-                        dialogInflater.inflate(android.R.layout.select_dialog_item, parent, false));
+                        dialogInflater.inflate(R.layout.select_dialog_item, parent, false));
 
                 final int resId = getItem(position);
                 result.setText(resId);
@@ -127,7 +127,6 @@
         };
         return new AlertDialog.Builder(getActivity())
                 .setTitle(R.string.dialog_import_export)
-                .setNegativeButton(android.R.string.cancel, null)
                 .setSingleChoiceItems(adapter, -1, clickListener)
                 .create();
     }
diff --git a/src/com/android/contacts/model/AccountType.java b/src/com/android/contacts/model/AccountType.java
index 879a89f..21e17bd 100644
--- a/src/com/android/contacts/model/AccountType.java
+++ b/src/com/android/contacts/model/AccountType.java
@@ -71,8 +71,6 @@
     public int titleRes;
     public int iconRes;
 
-    public boolean readOnly;
-
     /**
      * Set of {@link DataKind} supported by this source.
      */
@@ -83,15 +81,18 @@
      */
     private HashMap<String, DataKind> mMimeKinds = Maps.newHashMap();
 
-    public boolean isExternal() {
-        return false;
-    }
-
     public boolean isExtension() {
         return false;
     }
 
     /**
+     * @return True if contacts can be created and edited using this app. If false,
+     * there could still be an external editor as provided by
+     * {@link #getEditContactActivityClassName()} or {@link #getCreateContactActivityClassName()}
+     */
+    public abstract boolean areContactsWritable();
+
+    /**
      * Returns an optional custom edit activity.  The activity class should reside
      * in the sync adapter package as determined by {@link #resPackageName}.
      */
diff --git a/src/com/android/contacts/model/AccountTypeManager.java b/src/com/android/contacts/model/AccountTypeManager.java
index 33d6c97..dc2fb0d 100644
--- a/src/com/android/contacts/model/AccountTypeManager.java
+++ b/src/com/android/contacts/model/AccountTypeManager.java
@@ -112,6 +112,13 @@
         final AccountType type = getAccountType(accountType, dataSet);
         return type == null ? null : type.getKindForMimetype(mimeType);
     }
+
+    /*
+     * Returns all registered {@link AccountType}s, including extension ones.
+     *
+     * @param contactWritableOnly if true, it only returns ones that support writing contacts.
+     */
+    public abstract List<AccountType> getAccountTypes(boolean contactWritableOnly);
 }
 
 class AccountTypeManagerImpl extends AccountTypeManager
@@ -329,7 +336,6 @@
                         // Skip external account types that couldn't be initialized.
                         continue;
                     }
-                    accountType.readOnly = !sync.supportsUploading();
                 }
 
                 accountType.accountType = auth.type;
@@ -395,7 +401,7 @@
                         AccountWithDataSet accountWithDataSet = new AccountWithDataSet(
                                 account.name, account.type, accountType.dataSet);
                         allAccounts.add(accountWithDataSet);
-                        if (!accountType.readOnly) {
+                        if (accountType.areContactsWritable()) {
                             writableAccounts.add(accountWithDataSet);
                         }
                     }
@@ -540,4 +546,17 @@
         }
         return Collections.unmodifiableMap(result);
     }
+
+    @Override
+    public List<AccountType> getAccountTypes(boolean contactWritableOnly) {
+        final List<AccountType> accountTypes = Lists.newArrayList();
+        synchronized (this) {
+            for (AccountType type : mAccountTypesWithDataSets.values()) {
+                if (!contactWritableOnly || type.areContactsWritable()) {
+                    accountTypes.add(type);
+                }
+            }
+        }
+        return accountTypes;
+    }
 }
diff --git a/src/com/android/contacts/model/AccountWithDataSet.java b/src/com/android/contacts/model/AccountWithDataSet.java
index 55af795..e379346 100644
--- a/src/com/android/contacts/model/AccountWithDataSet.java
+++ b/src/com/android/contacts/model/AccountWithDataSet.java
@@ -17,21 +17,34 @@
 package com.android.contacts.model;
 
 import com.android.internal.util.Objects;
+import com.google.common.collect.Lists;
 
 import android.accounts.Account;
 import android.content.Context;
 import android.database.Cursor;
 import android.net.Uri;
 import android.os.Parcel;
+import android.os.Parcelable.Creator;
 import android.provider.BaseColumns;
 import android.provider.ContactsContract;
 import android.provider.ContactsContract.RawContacts;
 import android.text.TextUtils;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
 /**
  * Wrapper for an account that includes a data set (which may be null).
  */
 public class AccountWithDataSet extends Account {
+    private static final String STRINGIFY_SEPARATOR = "\u0001";
+    private static final String ARRAY_STRINGIFY_SEPARATOR = "\u0002";
+
+    private static final Pattern STRINGIFY_SEPARATOR_PAT =
+            Pattern.compile(Pattern.quote(STRINGIFY_SEPARATOR));
+    private static final Pattern ARRAY_STRINGIFY_SEPARATOR_PAT =
+            Pattern.compile(Pattern.quote(ARRAY_STRINGIFY_SEPARATOR));
 
     public final String dataSet;
     private final AccountTypeWithDataSet mAccountTypeWithDataSet;
@@ -47,12 +60,29 @@
         mAccountTypeWithDataSet = AccountTypeWithDataSet.get(type, dataSet);
     }
 
-    public AccountWithDataSet(Parcel in, String dataSet) {
+    public AccountWithDataSet(Parcel in) {
         super(in);
-        this.dataSet = dataSet;
+        this.dataSet = in.readString();
         mAccountTypeWithDataSet = AccountTypeWithDataSet.get(type, dataSet);
     }
 
+    @Override
+    public void writeToParcel(Parcel dest, int flags) {
+        super.writeToParcel(dest, flags);
+        dest.writeString(dataSet);
+    }
+
+    // For Parcelable
+    public static final Creator<AccountWithDataSet> CREATOR = new Creator<AccountWithDataSet>() {
+        public AccountWithDataSet createFromParcel(Parcel source) {
+            return new AccountWithDataSet(source);
+        }
+
+        public AccountWithDataSet[] newArray(int size) {
+            return new AccountWithDataSet[size];
+        }
+    };
+
     public AccountTypeWithDataSet getAccountTypeWithDataSet() {
         return mAccountTypeWithDataSet;
     }
@@ -100,4 +130,67 @@
     public String toString() {
         return "AccountWithDataSet {name=" + name + ", type=" + type + ", dataSet=" + dataSet + "}";
     }
+
+    private static StringBuilder addStringified(StringBuilder sb, AccountWithDataSet account) {
+        sb.append(account.name);
+        sb.append(STRINGIFY_SEPARATOR);
+        sb.append(account.type);
+        sb.append(STRINGIFY_SEPARATOR);
+        if (!TextUtils.isEmpty(account.dataSet)) sb.append(account.dataSet);
+
+        return sb;
+    }
+
+    /**
+     * Pack the instance into a string.
+     */
+    public String stringify() {
+        return addStringified(new StringBuilder(), this).toString();
+    }
+
+    /**
+     * Unpack a string created by {@link #stringify}.
+     */
+    public static AccountWithDataSet unstringify(String s) {
+        final String[] array = STRINGIFY_SEPARATOR_PAT.split(s, 3);
+        if (array.length < 3) {
+            throw new IllegalArgumentException("Invalid string");
+        }
+        return new AccountWithDataSet(array[0], array[1],
+                TextUtils.isEmpty(array[2]) ? null : array[2]);
+    }
+
+    /**
+     * Pack a list of {@link AccountWithDataSet} into a string.
+     */
+    public static String stringifyList(List<AccountWithDataSet> accounts) {
+        final StringBuilder sb = new StringBuilder();
+
+        for (AccountWithDataSet account : accounts) {
+            if (sb.length() > 0) {
+                sb.append(ARRAY_STRINGIFY_SEPARATOR);
+            }
+            addStringified(sb, account);
+        }
+
+        return sb.toString();
+    }
+
+    /**
+     * Unpack a list of {@link AccountWithDataSet} into a string.
+     */
+    public static List<AccountWithDataSet> unstringifyList(String s) {
+        final ArrayList<AccountWithDataSet> ret = Lists.newArrayList();
+        if (TextUtils.isEmpty(s)) {
+            return ret;
+        }
+
+        final String[] array = ARRAY_STRINGIFY_SEPARATOR_PAT.split(s);
+
+        for (int i = 0; i < array.length; i++) {
+            ret.add(unstringify(array[i]));
+        }
+
+        return ret;
+    }
 }
diff --git a/src/com/android/contacts/model/BaseAccountType.java b/src/com/android/contacts/model/BaseAccountType.java
index e6c0400..b599c66 100644
--- a/src/com/android/contacts/model/BaseAccountType.java
+++ b/src/com/android/contacts/model/BaseAccountType.java
@@ -40,7 +40,7 @@
 import android.provider.ContactsContract.CommonDataKinds.Website;
 import android.view.inputmethod.EditorInfo;
 
-public class BaseAccountType extends AccountType {
+public abstract class BaseAccountType extends AccountType {
     protected static final int FLAGS_PHONE = EditorInfo.TYPE_CLASS_PHONE;
     protected static final int FLAGS_EMAIL = EditorInfo.TYPE_CLASS_TEXT
             | EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS;
diff --git a/src/com/android/contacts/model/EntityModifier.java b/src/com/android/contacts/model/EntityModifier.java
index fdac645..8582ed8 100644
--- a/src/com/android/contacts/model/EntityModifier.java
+++ b/src/com/android/contacts/model/EntityModifier.java
@@ -961,12 +961,11 @@
             // Migrate data supported by the new account type.
             // All the other data inside oldState are silently dropped.
             for (DataKind kind : newAccountType.getSortedDataKinds()) {
+                if (!kind.editable) continue;
                 final String mimeType = kind.mimeType;
-                final int fieldCount = kind.fieldList.size();
-                final Set<String> allowedColumns = new HashSet<String>();
                 if (DataKind.PSEUDO_MIME_TYPE_DISPLAY_NAME.equals(mimeType)
                         || DataKind.PSEUDO_MIME_TYPE_PHONETIC_NAME.equals(mimeType)) {
-                    // Ignore pseude data.
+                    // Ignore pseudo data.
                     continue;
                 } else if (StructuredName.CONTENT_ITEM_TYPE.equals(mimeType)) {
                     migrateStructuredName(context, oldState, newState, kind);
@@ -976,8 +975,10 @@
                     migrateEvent(oldState, newState, kind, null /* default Year */);
                 } else if (sGenericMimeTypesWithoutTypeSupport.contains(mimeType)) {
                     migrateGenericWithoutTypeColumn(oldState, newState, kind);
-                } else {
+                } else if (sGenericMimeTypesWithTypeSupport.contains(mimeType)) {
                     migrateGenericWithTypeColumn(oldState, newState, kind);
+                } else {
+                    throw new IllegalStateException("Unexpected editable mime-type: " + mimeType);
                 }
             }
         }
@@ -1296,10 +1297,6 @@
     /** @hide Public only for testing. */
     public static void migrateGenericWithTypeColumn(
             EntityDelta oldState, EntityDelta newState, DataKind newDataKind) {
-        if (!sGenericMimeTypesWithTypeSupport.contains(newDataKind.mimeType)) {
-            throw new RuntimeException("not supported: " + newDataKind.mimeType);
-        }
-
         final ArrayList<ValuesDelta> mimeEntries = oldState.getMimeEntries(newDataKind.mimeType);
         if (mimeEntries == null || mimeEntries.isEmpty()) {
             return;
diff --git a/src/com/android/contacts/model/ExchangeAccountType.java b/src/com/android/contacts/model/ExchangeAccountType.java
index 240df47..4a0e7a0 100644
--- a/src/com/android/contacts/model/ExchangeAccountType.java
+++ b/src/com/android/contacts/model/ExchangeAccountType.java
@@ -339,4 +339,9 @@
     public boolean isGroupMembershipEditable() {
         return true;
     }
+
+    @Override
+    public boolean areContactsWritable() {
+        return true;
+    }
 }
diff --git a/src/com/android/contacts/model/ExternalAccountType.java b/src/com/android/contacts/model/ExternalAccountType.java
index 7fefc44..ca064c7 100644
--- a/src/com/android/contacts/model/ExternalAccountType.java
+++ b/src/com/android/contacts/model/ExternalAccountType.java
@@ -49,6 +49,7 @@
     private static final String TAG_CONTACTS_SOURCE_LEGACY = "ContactsSource";
     private static final String TAG_CONTACTS_ACCOUNT_TYPE = "ContactsAccountType";
     private static final String TAG_CONTACTS_DATA_KIND = "ContactsDataKind";
+    private static final String TAG_EDIT_SCHEMA = "EditSchema";
 
     private static final String ATTR_EDIT_CONTACT_ACTIVITY = "editContactActivity";
     private static final String ATTR_CREATE_CONTACT_ACTIVITY = "createContactActivity";
@@ -65,7 +66,6 @@
     // The following attributes should only be set in non-sync-adapter account types.  They allow
     // for the account type and resource IDs to be specified without an associated authenticator.
     private static final String ATTR_ACCOUNT_TYPE = "accountType";
-    private static final String ATTR_READ_ONLY = "readOnly";
     private static final String ATTR_ACCOUNT_LABEL = "accountTypeLabel";
     private static final String ATTR_ACCOUNT_ICON = "accountTypeIcon";
 
@@ -85,6 +85,7 @@
     private String mAccountTypeIconAttribute;
     private boolean mInitSuccessful;
     private boolean mHasContactsMetadata;
+    private boolean mHasEditSchema;
 
     public ExternalAccountType(Context context, String resPackageName, boolean isExtension) {
         this.mIsExtension = isExtension;
@@ -126,11 +127,6 @@
     }
 
     @Override
-    public boolean isExternal() {
-        return true;
-    }
-
-    @Override
     public boolean isExtension() {
         return mIsExtension;
     }
@@ -143,6 +139,11 @@
         return mInitSuccessful;
     }
 
+    @Override
+    public boolean areContactsWritable() {
+        return mHasEditSchema;
+    }
+
     /**
      * Whether this account type has the android.provider.CONTACTS_STRUCTURE metadata xml.
      */
@@ -251,8 +252,6 @@
                     mExtensionPackageNames.add(value);
                 } else if (ATTR_ACCOUNT_TYPE.equals(attr)) {
                     accountType = value;
-                } else if (ATTR_READ_ONLY.equals(attr)) {
-                    readOnly = !"0".equals(value) && !"false".equals(value);
                 } else if (ATTR_ACCOUNT_LABEL.equals(attr)) {
                     mAccountTypeLabelAttribute = value;
                 } else if (ATTR_ACCOUNT_ICON.equals(attr)) {
@@ -267,44 +266,45 @@
             while (((type = parser.next()) != XmlPullParser.END_TAG || parser.getDepth() > depth)
                     && type != XmlPullParser.END_DOCUMENT) {
                 String tag = parser.getName();
-                if (type == XmlPullParser.END_TAG || !TAG_CONTACTS_DATA_KIND.equals(tag)) {
-                    continue;
+                if (TAG_EDIT_SCHEMA.equals(tag)) {
+                    parseEditSchema(context, parser);
+                } else if (TAG_CONTACTS_DATA_KIND.equals(tag)) {
+                    final TypedArray a = context.obtainStyledAttributes(attrs,
+                            android.R.styleable.ContactsDataKind);
+                    final DataKind kind = new DataKind();
+
+                    kind.mimeType = a
+                            .getString(com.android.internal.R.styleable.ContactsDataKind_mimeType);
+                    kind.iconRes = a.getResourceId(
+                            com.android.internal.R.styleable.ContactsDataKind_icon, -1);
+
+                    final String summaryColumn = a.getString(
+                            com.android.internal.R.styleable.ContactsDataKind_summaryColumn);
+                    if (summaryColumn != null) {
+                        // Inflate a specific column as summary when requested
+                        kind.actionHeader = new SimpleInflater(summaryColumn);
+                    }
+
+                    final String detailColumn = a.getString(
+                            com.android.internal.R.styleable.ContactsDataKind_detailColumn);
+                    final boolean detailSocialSummary = a.getBoolean(
+                            com.android.internal.R.styleable.ContactsDataKind_detailSocialSummary,
+                            false);
+
+                    if (detailSocialSummary) {
+                        // Inflate social summary when requested
+                        kind.actionBodySocial = true;
+                    }
+
+                    if (detailColumn != null) {
+                        // Inflate specific column as summary
+                        kind.actionBody = new SimpleInflater(detailColumn);
+                    }
+
+                    a.recycle();
+
+                    addKind(kind);
                 }
-
-                final TypedArray a = context.obtainStyledAttributes(attrs,
-                        android.R.styleable.ContactsDataKind);
-                final DataKind kind = new DataKind();
-
-                kind.mimeType = a
-                        .getString(com.android.internal.R.styleable.ContactsDataKind_mimeType);
-                kind.iconRes = a.getResourceId(
-                        com.android.internal.R.styleable.ContactsDataKind_icon, -1);
-
-                final String summaryColumn = a
-                        .getString(com.android.internal.R.styleable.ContactsDataKind_summaryColumn);
-                if (summaryColumn != null) {
-                    // Inflate a specific column as summary when requested
-                    kind.actionHeader = new FallbackAccountType.SimpleInflater(summaryColumn);
-                }
-
-                final String detailColumn = a
-                        .getString(com.android.internal.R.styleable.ContactsDataKind_detailColumn);
-                final boolean detailSocialSummary = a.getBoolean(
-                        com.android.internal.R.styleable.ContactsDataKind_detailSocialSummary,
-                        false);
-
-                if (detailSocialSummary) {
-                    // Inflate social summary when requested
-                    kind.actionBodySocial = true;
-                }
-
-                if (detailColumn != null) {
-                    // Inflate specific column as summary
-                    kind.actionBody = new FallbackAccountType.SimpleInflater(detailColumn);
-                }
-
-                addKind(kind);
-                a.recycle();
             }
         } catch (XmlPullParserException e) {
             throw new IllegalStateException("Problem reading XML", e);
@@ -313,6 +313,36 @@
         }
     }
 
+    /**
+     * Has to be started while the parser is on the EditSchema tag. Will finish on the end tag
+     */
+    private void parseEditSchema(Context context, XmlPullParser parser)
+            throws XmlPullParserException, IOException {
+        // Loop until we left this tag
+        final int startingDepth = parser.getDepth();
+        int type;
+        do {
+            type = parser.next();
+        } while (!(parser.getDepth() == startingDepth && type == XmlPullParser.END_TAG));
+
+        // Just add all defaults for now
+        addDataKindStructuredName(context);
+        addDataKindDisplayName(context);
+        addDataKindPhoneticName(context);
+        addDataKindNickname(context);
+        addDataKindPhone(context);
+        addDataKindEmail(context);
+        addDataKindStructuredPostal(context);
+        addDataKindIm(context);
+        addDataKindOrganization(context);
+        addDataKindPhoto(context);
+        addDataKindNote(context);
+        addDataKindWebsite(context);
+        addDataKindSipAddress(context);
+
+        mHasEditSchema = true;
+    }
+
     @Override
     public int getHeaderColor(Context context) {
         return 0xff6d86b4;
diff --git a/src/com/android/contacts/model/FallbackAccountType.java b/src/com/android/contacts/model/FallbackAccountType.java
index 8bb3992..3b56b04 100644
--- a/src/com/android/contacts/model/FallbackAccountType.java
+++ b/src/com/android/contacts/model/FallbackAccountType.java
@@ -55,4 +55,9 @@
     public int getSideBarColor(Context context) {
         return 0xffbdc7b8;
     }
+
+    @Override
+    public boolean areContactsWritable() {
+        return true;
+    }
 }
diff --git a/src/com/android/contacts/model/GoogleAccountType.java b/src/com/android/contacts/model/GoogleAccountType.java
index a5fab96..cee43dd 100644
--- a/src/com/android/contacts/model/GoogleAccountType.java
+++ b/src/com/android/contacts/model/GoogleAccountType.java
@@ -183,4 +183,9 @@
     public boolean isGroupMembershipEditable() {
         return true;
     }
+
+    @Override
+    public boolean areContactsWritable() {
+        return true;
+    }
 }
diff --git a/src/com/android/contacts/quickcontact/QuickContactListFragment.java b/src/com/android/contacts/quickcontact/QuickContactListFragment.java
index cd899fa..962f07f 100644
--- a/src/com/android/contacts/quickcontact/QuickContactListFragment.java
+++ b/src/com/android/contacts/quickcontact/QuickContactListFragment.java
@@ -25,8 +25,6 @@
 import android.view.View;
 import android.view.View.OnClickListener;
 import android.view.ViewGroup;
-import android.widget.AbsListView;
-import android.widget.AdapterView;
 import android.widget.BaseAdapter;
 import android.widget.ImageView;
 import android.widget.LinearLayout;
@@ -100,14 +98,14 @@
                         android.R.id.text1);
                 final TextView text2 = (TextView) resultView.findViewById(
                         android.R.id.text2);
-                final View primaryActionContainer = resultView.findViewById(
-                        R.id.primary_action_view_container);
+                final View actionsContainer = resultView.findViewById(
+                        R.id.actions_view_container);
                 final ImageView alternateActionButton = (ImageView) resultView.findViewById(
                         R.id.secondary_action_button);
                 final View alternateActionDivider = resultView.findViewById(R.id.vertical_divider);
 
-                primaryActionContainer.setOnClickListener(mPrimaryActionClickListener);
-                primaryActionContainer.setTag(action);
+                actionsContainer.setOnClickListener(mPrimaryActionClickListener);
+                actionsContainer.setTag(action);
                 alternateActionButton.setOnClickListener(mSecondaryActionClickListener);
                 alternateActionButton.setTag(action);
 
diff --git a/src/com/android/contacts/util/Constants.java b/src/com/android/contacts/util/Constants.java
index d79f029..3a43c40 100644
--- a/src/com/android/contacts/util/Constants.java
+++ b/src/com/android/contacts/util/Constants.java
@@ -25,7 +25,27 @@
     public static final String SCHEME_IMTO = "imto";
     public static final String SCHEME_SIP = "sip";
 
-    // Log tag for performance measurement.
-    // To enable: adb shell setprop log.tag.ContactsPerf VERBOSE
+    /**
+     * Log tag for performance measurement.
+     * To enable: adb shell setprop log.tag.ContactsPerf VERBOSE
+     */
     public static final String PERFORMANCE_TAG = "ContactsPerf";
+
+    /**
+     * Log tag for enabling/disabling LoaderManager log.
+     * To enable: adb shell setprop log.tag.ContactsLoaderManager DEBUG
+     */
+    public static final String LOADER_MANAGER_TAG = "ContactsLoaderManager";
+
+    /**
+     * Log tag for enabling/disabling FragmentManager log.
+     * To enable: adb shell setprop log.tag.ContactsFragmentManager DEBUG
+     */
+    public static final String FRAGMENT_MANAGER_TAG = "ContactsFragmentManager";
+
+    /**
+     * Log tag for enabling/disabling StrictMode violation log.
+     * To enable: adb shell setprop log.tag.ContactsStrictMode DEBUG
+     */
+    public static final String STRICT_MODE_TAG = "ContactsStrictMode";
 }
diff --git a/tests/src/com/android/contacts/ContactLoaderTest.java b/tests/src/com/android/contacts/ContactLoaderTest.java
index 5d44cf1..f88b64e 100644
--- a/tests/src/com/android/contacts/ContactLoaderTest.java
+++ b/tests/src/com/android/contacts/ContactLoaderTest.java
@@ -51,7 +51,12 @@
         mContactsProvider = mMockContext.getContactsProvider();
 
         InjectedServices services = new InjectedServices();
-        AccountType accountType = new BaseAccountType();
+        AccountType accountType = new BaseAccountType() {
+            @Override
+            public boolean areContactsWritable() {
+                return false;
+            }
+        };
         accountType.accountType = "mockAccountType";
 
         AccountWithDataSet account =
diff --git a/tests/src/com/android/contacts/EntityModifierTests.java b/tests/src/com/android/contacts/EntityModifierTests.java
index cf6fefe..76d3d84 100644
--- a/tests/src/com/android/contacts/EntityModifierTests.java
+++ b/tests/src/com/android/contacts/EntityModifierTests.java
@@ -153,6 +153,11 @@
         public boolean isGroupMembershipEditable() {
             return false;
         }
+
+        @Override
+        public boolean areContactsWritable() {
+            return true;
+        }
     }
 
     /**
diff --git a/tests/src/com/android/contacts/activities/PeopleActivityTest.java b/tests/src/com/android/contacts/activities/PeopleActivityTest.java
index f419842..66c2c5a 100644
--- a/tests/src/com/android/contacts/activities/PeopleActivityTest.java
+++ b/tests/src/com/android/contacts/activities/PeopleActivityTest.java
@@ -94,7 +94,12 @@
         services.setSharedPreferences(new MockSharedPreferences());
         services.setSystemService(ContactPhotoManager.CONTACT_PHOTO_SERVICE,
                 new MockContactPhotoManager());
-        AccountType accountType = new BaseAccountType();
+        AccountType accountType = new BaseAccountType() {
+            @Override
+            public boolean areContactsWritable() {
+                return false;
+            }
+        };
         accountType.accountType = TEST_ACCOUNT_TYPE;
 
         AccountWithDataSet account = new AccountWithDataSet(TEST_ACCOUNT, TEST_ACCOUNT_TYPE, null);
diff --git a/tests/src/com/android/contacts/editor/ContactEditorUtilsTest.java b/tests/src/com/android/contacts/editor/ContactEditorUtilsTest.java
new file mode 100644
index 0000000..9f4e487
--- /dev/null
+++ b/tests/src/com/android/contacts/editor/ContactEditorUtilsTest.java
@@ -0,0 +1,310 @@
+/*
+ * Copyright (C) 2011 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 com.android.contacts.editor.ContactEditorUtils;
+import com.android.contacts.model.AccountType;
+import com.android.contacts.model.AccountWithDataSet;
+import com.android.contacts.tests.mocks.MockAccountTypeManager;
+import com.google.android.collect.Sets;
+
+import android.content.Context;
+import android.test.AndroidTestCase;
+import android.test.MoreAsserts;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import java.util.Collection;
+import java.util.Set;
+
+/**
+ * Test case for {@link ContactEditorUtils}.
+ *
+ * adb shell am instrument -w -e class com.android.contacts.editor.ContactEditorUtilsTest \
+       com.android.contacts.tests/android.test.InstrumentationTestRunner
+ */
+@SmallTest
+public class ContactEditorUtilsTest extends AndroidTestCase {
+    private MockAccountTypeManager mAccountTypes;
+    private ContactEditorUtils mTarget;
+
+    private static final MockAccountType TYPE1 = new MockAccountType("type1", null, true);
+    private static final MockAccountType TYPE2 = new MockAccountType("type2", null, true);
+    private static final MockAccountType TYPE2EX = new MockAccountType("type2", "ext", true);
+
+    // Only type 3 is "readonly".
+    private static final MockAccountType TYPE3 = new MockAccountType("type3", null, false);
+
+    private static final AccountWithDataSet ACCOUNT_1_A = new AccountWithDataSet(
+            "a", TYPE1.accountType, TYPE1.dataSet);
+    private static final AccountWithDataSet ACCOUNT_1_B = new AccountWithDataSet(
+            "b", TYPE1.accountType, TYPE1.dataSet);
+
+    private static final AccountWithDataSet ACCOUNT_2_A = new AccountWithDataSet(
+            "a", TYPE2.accountType, TYPE2.dataSet);
+    private static final AccountWithDataSet ACCOUNT_2EX_A = new AccountWithDataSet(
+            "a", TYPE2EX.accountType, TYPE2EX.dataSet);
+
+    private static final AccountWithDataSet ACCOUNT_3_C = new AccountWithDataSet(
+            "c", TYPE3.accountType, TYPE3.dataSet);
+
+    @Override
+    protected void setUp() throws Exception {
+        // Initialize with 0 types, 0 accounts.
+        mAccountTypes = new MockAccountTypeManager(new AccountType[] {},
+                new AccountWithDataSet[] {});
+        mTarget = new ContactEditorUtils(getContext(), mAccountTypes);
+
+        // Clear the preferences.
+        mTarget.cleanupForTest();
+    }
+
+    private void setAccountTypes(AccountType... types) {
+        mAccountTypes.mTypes = types;
+    }
+
+    private void setAccounts(AccountWithDataSet... accounts) {
+        mAccountTypes.mAccounts = accounts;
+    }
+
+    public void testGetWritableAccountTypeStrings() {
+        String[] types;
+
+        // 0 writable types
+        setAccountTypes();
+
+        types = mTarget.getWritableAccountTypeStrings();
+        MoreAsserts.assertEquals(types, new String[0]);
+
+        // 1 writable type
+        setAccountTypes(TYPE1);
+
+        types = mTarget.getWritableAccountTypeStrings();
+        MoreAsserts.assertEquals(Sets.newHashSet(TYPE1.accountType), Sets.newHashSet(types));
+
+        // 2 writable types
+        setAccountTypes(TYPE1, TYPE2EX);
+
+        types = mTarget.getWritableAccountTypeStrings();
+        MoreAsserts.assertEquals(Sets.newHashSet(TYPE1.accountType, TYPE2EX.accountType),
+                Sets.newHashSet(types));
+
+        // 3 writable types + 1 readonly type
+        setAccountTypes(TYPE1, TYPE2, TYPE2EX, TYPE3);
+
+        types = mTarget.getWritableAccountTypeStrings();
+        MoreAsserts.assertEquals(
+                Sets.newHashSet(TYPE1.accountType, TYPE2.accountType, TYPE2EX.accountType),
+                Sets.newHashSet(types));
+    }
+
+    /**
+     * Test for
+     * - {@link ContactEditorUtils#saveDefaultAndAllAccounts}
+     * - {@link ContactEditorUtils#getDefaultAccount}
+     * - {@link ContactEditorUtils#getSavedAccounts()}
+     */
+    public void testSaveDefaultAndAllAccounts() {
+        // Use these account types here.
+        setAccountTypes(TYPE1, TYPE2);
+
+        // If none has been saved, it should return an empty list.
+        assertEquals(0, mTarget.getSavedAccounts().size());
+
+        // Save 0 accounts.
+        mAccountTypes.mAccounts = new AccountWithDataSet[]{};
+        mTarget.saveDefaultAndAllAccounts(null);
+        assertNull(mTarget.getDefaultAccount());
+        MoreAsserts.assertEquals(
+                Sets.newHashSet(mAccountTypes.mAccounts),
+                toSet(mTarget.getSavedAccounts()));
+
+
+        // 1 account
+        mAccountTypes.mAccounts = new AccountWithDataSet[]{ACCOUNT_1_A};
+        mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A);
+        assertEquals(ACCOUNT_1_A, mTarget.getDefaultAccount());
+        MoreAsserts.assertEquals(
+                Sets.newHashSet(mAccountTypes.mAccounts),
+                toSet(mTarget.getSavedAccounts()));
+
+        // 2 account
+        mAccountTypes.mAccounts = new AccountWithDataSet[]{ACCOUNT_1_A, ACCOUNT_1_B};
+        mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_B);
+        assertEquals(ACCOUNT_1_B, mTarget.getDefaultAccount());
+        MoreAsserts.assertEquals(
+                Sets.newHashSet(mAccountTypes.mAccounts),
+                toSet(mTarget.getSavedAccounts()));
+    }
+
+    public void testIsAccountValid() {
+        // Use these account types here.
+        setAccountTypes(TYPE1, TYPE2);
+
+        // 0 accounts
+        mAccountTypes.mAccounts = new AccountWithDataSet[]{};
+        assertFalse(mTarget.isValidAccount(ACCOUNT_1_A));
+        assertTrue(mTarget.isValidAccount(null)); // null is always valid
+
+        // 2 accounts
+        mAccountTypes.mAccounts = new AccountWithDataSet[]{ACCOUNT_1_A, ACCOUNT_2_A};
+        assertTrue(mTarget.isValidAccount(ACCOUNT_1_A));
+        assertTrue(mTarget.isValidAccount(ACCOUNT_2_A));
+        assertFalse(mTarget.isValidAccount(ACCOUNT_2EX_A));
+        assertTrue(mTarget.isValidAccount(null)); // null is always valid
+    }
+
+    /**
+     * Tests for {@link ContactEditorUtils#shouldShowAccountChangedNotification()}, starting with
+     * 0 accounts.
+     */
+    public void testShouldShowAccountChangedNotification_0Accounts() {
+        // There's always at least one writable type...
+        setAccountTypes(TYPE1);
+
+        // First launch -- always true.
+        assertTrue(mTarget.shouldShowAccountChangedNotification());
+
+        // We show the notification here, and user clicked "add account"
+        setAccounts(ACCOUNT_1_A);
+
+        // Now we open the contact editor with the new account.
+
+        // When closing the editor, we save the default account.
+        mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A);
+
+        // Next time the user creates a contact, we don't show the notification.
+        assertFalse(mTarget.shouldShowAccountChangedNotification());
+
+        // User added a new writable account, ACCOUNT_1_B.
+        setAccounts(ACCOUNT_1_A, ACCOUNT_1_B);
+
+        // Now we show the notification again.
+        assertTrue(mTarget.shouldShowAccountChangedNotification());
+
+        // User saved a new contact.  We update the account list and the default account.
+        mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_B);
+
+        // User created another contact.  Now we don't show the notification.
+        assertFalse(mTarget.shouldShowAccountChangedNotification());
+
+        // User installed a new contact sync adapter...
+
+        // Added a new account type: TYPE2, and the TYPE2EX extension.
+        setAccountTypes(TYPE1, TYPE2, TYPE2EX);
+        // Add new accounts: ACCOUNT_2_A, ACCOUNT_2EX_A.
+        setAccounts(ACCOUNT_1_A, ACCOUNT_1_B, ACCOUNT_2_A, ACCOUNT_2EX_A);
+
+        // New account means another notification.
+        assertTrue(mTarget.shouldShowAccountChangedNotification());
+
+        // User saves a new contact, with a different default account.
+        mTarget.saveDefaultAndAllAccounts(ACCOUNT_2_A);
+
+        // Next time user creates a contact, no notification.
+        assertFalse(mTarget.shouldShowAccountChangedNotification());
+
+        // Remove ACCOUNT_2EX_A.
+        setAccountTypes(TYPE1, TYPE2, TYPE2EX);
+        setAccounts(ACCOUNT_1_A, ACCOUNT_1_B, ACCOUNT_2_A);
+
+        // ACCOUNT_2EX_A was not default, so no notification either.
+        assertFalse(mTarget.shouldShowAccountChangedNotification());
+
+        // Remove ACCOUNT_1_B, which is default.
+        setAccountTypes(TYPE1, TYPE2, TYPE2EX);
+        setAccounts(ACCOUNT_1_A, ACCOUNT_1_B);
+
+        // Now we show the notification.
+        assertTrue(mTarget.shouldShowAccountChangedNotification());
+    }
+
+    /**
+     * Tests for {@link ContactEditorUtils#shouldShowAccountChangedNotification()}, starting with
+     * 1 accounts.
+     */
+    public void testShouldShowAccountChangedNotification_1Account() {
+        setAccountTypes(TYPE1, TYPE2);
+        setAccounts(ACCOUNT_1_A);
+
+        // First launch -- always true.
+        assertTrue(mTarget.shouldShowAccountChangedNotification());
+
+        // User saves a new contact.
+        mTarget.saveDefaultAndAllAccounts(ACCOUNT_1_A);
+
+        // Next time, no notification.
+        assertFalse(mTarget.shouldShowAccountChangedNotification());
+
+        // The rest is the same...
+    }
+
+    /**
+     * Tests for {@link ContactEditorUtils#shouldShowAccountChangedNotification()}, starting with
+     * 0 accounts, and the user selected "local only".
+     */
+    public void testShouldShowAccountChangedNotification_0Account_localOnly() {
+        // There's always at least one writable type...
+        setAccountTypes(TYPE1);
+
+        // First launch -- always true.
+        assertTrue(mTarget.shouldShowAccountChangedNotification());
+
+        // We show the notification here, and user clicked "keep local" and saved an contact.
+        mTarget.saveDefaultAndAllAccounts(null);
+
+        // Now there are no accounts, and default account is null.
+
+        // The user created another contact, but this we shouldn't show the notification.
+        assertFalse(mTarget.shouldShowAccountChangedNotification());
+    }
+
+    private static <T> Set<T> toSet(Collection<T> collection) {
+        Set<T> ret = Sets.newHashSet();
+        ret.addAll(collection);
+        return ret;
+    }
+
+    private static class MockAccountType extends AccountType {
+        private boolean mAreContactsWritable;
+
+        public MockAccountType(String accountType, String dataSet, boolean areContactsWritable) {
+            this.accountType = accountType;
+            this.dataSet = dataSet;
+            mAreContactsWritable = areContactsWritable;
+        }
+
+        @Override
+        public boolean areContactsWritable() {
+            return mAreContactsWritable;
+        }
+
+        @Override
+        public int getHeaderColor(Context context) {
+            return 0;
+        }
+
+        @Override
+        public int getSideBarColor(Context context) {
+            return 0;
+        }
+
+        @Override
+        public boolean isGroupMembershipEditable() {
+            return true;
+        }
+    }
+}
diff --git a/tests/src/com/android/contacts/interactions/ContactDeletionInteractionTest.java b/tests/src/com/android/contacts/interactions/ContactDeletionInteractionTest.java
index a6222db..2c4b74c 100644
--- a/tests/src/com/android/contacts/interactions/ContactDeletionInteractionTest.java
+++ b/tests/src/com/android/contacts/interactions/ContactDeletionInteractionTest.java
@@ -83,11 +83,20 @@
         InjectedServices services = new InjectedServices();
         services.setContentResolver(mContext.getContentResolver());
 
-        AccountType readOnlyAccountType = new BaseAccountType();
+        AccountType readOnlyAccountType = new BaseAccountType() {
+            @Override
+            public boolean areContactsWritable() {
+                return false;
+            }
+        };
         readOnlyAccountType.accountType = READONLY_ACCOUNT_TYPE;
-        readOnlyAccountType.readOnly = true;
 
-        AccountType writableAccountType = new BaseAccountType();
+        AccountType writableAccountType = new BaseAccountType() {
+            @Override
+            public boolean areContactsWritable() {
+                return true;
+            }
+        };
         writableAccountType.accountType = WRITABLE_ACCOUNT_TYPE;
 
         services.setSystemService(AccountTypeManager.ACCOUNT_TYPE_SERVICE,
diff --git a/tests/src/com/android/contacts/model/AccountTypeManagerTest.java b/tests/src/com/android/contacts/model/AccountTypeManagerTest.java
index 81c270f..aadf411 100644
--- a/tests/src/com/android/contacts/model/AccountTypeManagerTest.java
+++ b/tests/src/com/android/contacts/model/AccountTypeManagerTest.java
@@ -196,5 +196,10 @@
         public boolean isGroupMembershipEditable() {
             return false;
         }
+
+        @Override
+        public boolean areContactsWritable() {
+            return false;
+        }
     }
 }
diff --git a/tests/src/com/android/contacts/model/AccountTypeTest.java b/tests/src/com/android/contacts/model/AccountTypeTest.java
index 3d80b52..9f7e7a2 100644
--- a/tests/src/com/android/contacts/model/AccountTypeTest.java
+++ b/tests/src/com/android/contacts/model/AccountTypeTest.java
@@ -84,6 +84,10 @@
             @Override public boolean isGroupMembershipEditable() {
                 return false;
             }
+
+            @Override public boolean areContactsWritable() {
+                return false;
+            }
         };
 
         assertEquals(getTestContext().getString(externalResID),
@@ -137,5 +141,10 @@
         public boolean isGroupMembershipEditable() {
             return false;
         }
+
+        @Override
+        public boolean areContactsWritable() {
+            return false;
+        }
     }
 }
diff --git a/tests/src/com/android/contacts/model/AccountWithDataSetTest.java b/tests/src/com/android/contacts/model/AccountWithDataSetTest.java
new file mode 100644
index 0000000..27c106e
--- /dev/null
+++ b/tests/src/com/android/contacts/model/AccountWithDataSetTest.java
@@ -0,0 +1,122 @@
+/*
+ * Copyright (C) 2011 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.model;
+
+import com.google.common.collect.Lists;
+
+import android.os.Bundle;
+import android.test.AndroidTestCase;
+import android.test.MoreAsserts;
+import android.test.suitebuilder.annotation.SmallTest;
+
+import java.util.List;
+
+/**
+ * Test case for {@link AccountWithDataSet}.
+ *
+ * adb shell am instrument -w -e class com.android.contacts.model.AccountWithDataSetTest \
+       com.android.contacts.tests/android.test.InstrumentationTestRunner
+ */
+@SmallTest
+public class AccountWithDataSetTest extends AndroidTestCase {
+    public void testStringifyAndUnstringify() {
+        AccountWithDataSet a1 = new AccountWithDataSet("name1", "typeA", null);
+        AccountWithDataSet a2 = new AccountWithDataSet("name2", "typeB", null);
+        AccountWithDataSet a3 = new AccountWithDataSet("name3", "typeB", "dataset");
+
+        // stringify() & unstringify
+        AccountWithDataSet a1r = AccountWithDataSet.unstringify(a1.stringify());
+        AccountWithDataSet a2r = AccountWithDataSet.unstringify(a2.stringify());
+        AccountWithDataSet a3r = AccountWithDataSet.unstringify(a3.stringify());
+
+        assertEquals(a1, a1r);
+        assertEquals(a2, a2r);
+        assertEquals(a3, a3r);
+
+        MoreAsserts.assertNotEqual(a1, a2r);
+        MoreAsserts.assertNotEqual(a1, a3r);
+
+        MoreAsserts.assertNotEqual(a2, a1r);
+        MoreAsserts.assertNotEqual(a2, a3r);
+
+        MoreAsserts.assertNotEqual(a3, a1r);
+        MoreAsserts.assertNotEqual(a3, a2r);
+    }
+
+    public void testStringifyListAndUnstringify() {
+        AccountWithDataSet a1 = new AccountWithDataSet("name1", "typeA", null);
+        AccountWithDataSet a2 = new AccountWithDataSet("name2", "typeB", null);
+        AccountWithDataSet a3 = new AccountWithDataSet("name3", "typeB", "dataset");
+
+        // Empty list
+        assertEquals(0, stringifyListAndUnstringify().size());
+
+        // 1 element
+        final List<AccountWithDataSet> listA = stringifyListAndUnstringify(a1);
+        assertEquals(1, listA.size());
+        assertEquals(a1, listA.get(0));
+
+        // 2 elements
+        final List<AccountWithDataSet> listB = stringifyListAndUnstringify(a2, a1);
+        assertEquals(2, listB.size());
+        assertEquals(a2, listB.get(0));
+        assertEquals(a1, listB.get(1));
+
+        // 3 elements
+        final List<AccountWithDataSet> listC = stringifyListAndUnstringify(a3, a2, a1);
+        assertEquals(3, listC.size());
+        assertEquals(a3, listC.get(0));
+        assertEquals(a2, listC.get(1));
+        assertEquals(a1, listC.get(2));
+    }
+
+    private static List<AccountWithDataSet> stringifyListAndUnstringify(
+            AccountWithDataSet... accounts) {
+
+        List<AccountWithDataSet> list = Lists.newArrayList(accounts);
+        return AccountWithDataSet.unstringifyList(AccountWithDataSet.stringifyList(list));
+    }
+
+    public void testParcelable() {
+        AccountWithDataSet a1 = new AccountWithDataSet("name1", "typeA", null);
+        AccountWithDataSet a2 = new AccountWithDataSet("name2", "typeB", null);
+        AccountWithDataSet a3 = new AccountWithDataSet("name3", "typeB", "dataset");
+
+        // Parcel them & unpercel.
+        final Bundle b = new Bundle();
+        b.putParcelable("a1", a1);
+        b.putParcelable("a2", a2);
+        b.putParcelable("a3", a3);
+
+        AccountWithDataSet a1r = b.getParcelable("a1");
+        AccountWithDataSet a2r = b.getParcelable("a2");
+        AccountWithDataSet a3r = b.getParcelable("a3");
+
+        assertEquals(a1, a1r);
+        assertEquals(a2, a2r);
+        assertEquals(a3, a3r);
+
+        MoreAsserts.assertNotEqual(a1, a2r);
+        MoreAsserts.assertNotEqual(a1, a3r);
+
+        MoreAsserts.assertNotEqual(a2, a1r);
+        MoreAsserts.assertNotEqual(a2, a3r);
+
+        MoreAsserts.assertNotEqual(a3, a1r);
+        MoreAsserts.assertNotEqual(a3, a2r);
+    }
+}
diff --git a/tests/src/com/android/contacts/tests/mocks/MockAccountTypeManager.java b/tests/src/com/android/contacts/tests/mocks/MockAccountTypeManager.java
index 7a04ae3..3b712c7 100644
--- a/tests/src/com/android/contacts/tests/mocks/MockAccountTypeManager.java
+++ b/tests/src/com/android/contacts/tests/mocks/MockAccountTypeManager.java
@@ -19,9 +19,11 @@
 import com.android.contacts.model.AccountTypeManager;
 import com.android.contacts.model.AccountTypeWithDataSet;
 import com.android.contacts.model.AccountWithDataSet;
+import com.google.android.collect.Lists;
 import com.google.android.collect.Maps;
 
 import java.util.Arrays;
+import java.util.Collection;
 import java.util.List;
 import java.util.Map;
 
@@ -32,8 +34,8 @@
  */
 public class MockAccountTypeManager extends AccountTypeManager {
 
-    private final AccountType[] mTypes;
-    private AccountWithDataSet[] mAccounts;
+    public AccountType[] mTypes;
+    public AccountWithDataSet[] mAccounts;
 
     public MockAccountTypeManager(AccountType[] types, AccountWithDataSet[] accounts) {
         this.mTypes = types;
@@ -60,4 +62,17 @@
     public Map<AccountTypeWithDataSet, AccountType> getInvitableAccountTypes() {
         return Maps.newHashMap(); // Always returns empty
     }
+
+    @Override
+    public List<AccountType> getAccountTypes(boolean writableOnly) {
+        final List<AccountType> ret = Lists.newArrayList();
+        synchronized (this) {
+            for (AccountType type : mTypes) {
+                if (!writableOnly || type.areContactsWritable()) {
+                    ret.add(type);
+                }
+            }
+        }
+        return ret;
+    }
 }
diff --git a/tests/src/com/android/contacts/tests/mocks/MockContactPhotoManager.java b/tests/src/com/android/contacts/tests/mocks/MockContactPhotoManager.java
index a98b365..51c665f 100644
--- a/tests/src/com/android/contacts/tests/mocks/MockContactPhotoManager.java
+++ b/tests/src/com/android/contacts/tests/mocks/MockContactPhotoManager.java
@@ -27,13 +27,15 @@
  */
 public class MockContactPhotoManager extends ContactPhotoManager {
     @Override
-    public void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme) {
-        view.setImageResource(getDefaultAvatarResId(hires, darkTheme));
+    public void loadPhoto(ImageView view, long photoId, boolean hires, boolean darkTheme,
+            DefaultImageProvider defaultProvider) {
+        defaultProvider.applyDefaultImage(view, hires, darkTheme);
     }
 
     @Override
-    public void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme) {
-        view.setImageResource(getDefaultAvatarResId(hires, darkTheme));
+    public void loadPhoto(ImageView view, Uri photoUri, boolean hires, boolean darkTheme,
+            DefaultImageProvider defaultProvider) {
+        defaultProvider.applyDefaultImage(view, hires, darkTheme);
     }
 
     @Override
