diff --git a/Android.mk b/Android.mk
index 777b053..6a84c0c 100644
--- a/Android.mk
+++ b/Android.mk
@@ -5,9 +5,13 @@
 
 LOCAL_SRC_FILES := $(call all-java-files-under, src)
 
+LOCAL_STATIC_JAVA_LIBRARIES := googlelogin-client
+
 LOCAL_PACKAGE_NAME := Contacts
 LOCAL_CERTIFICATE := shared
 
+LOCAL_STATIC_JAVA_LIBRARIES := googlelogin-client
+
 include $(BUILD_PACKAGE)
 
 # Use the folloing include to make our test apk.
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 8445355..949bfc8 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -24,6 +24,7 @@
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.READ_PHONE_STATE" />
     <uses-permission android:name="android.permission.MODIFY_PHONE_STATE" />
+    <uses-permission android:name="com.google.android.googleapps.permission.GOOGLE_AUTH.mail" />
 
     <application
         android:label="@string/contactsList"
@@ -239,7 +240,8 @@
         </activity>
 
         <!-- Edits the details of a single contact -->
-        <activity android:name="EditContactActivity">
+        <activity android:name="EditContactActivity"
+                android:windowSoftInputMode="stateVisible|adjustResize">
             <intent-filter android:label="@string/editContactDescription">
                 <action android:name="android.intent.action.EDIT" />
                 <category android:name="android.intent.category.DEFAULT" />
@@ -264,16 +266,47 @@
             />
         </activity>        
 
-        <!-- Preferences activity -->
-        <activity android:name="ContactsPreferenceActivity" />
-
         <!-- Activity used to select the groups that should be synced -->
-        <activity android:name="ContactsGroupSyncSelector" />
+        <activity android:name="ContactsGroupSyncSelector"
+            android:label="@string/seclectSyncGroups_title"
+        />
 
         <!-- Makes .ContactsListActivity the search target for any activity in Contacts -->
         <meta-data android:name="android.app.default_searchable" 
                    android:value=".ContactsListActivity" />
-        
+
+
+        <!-- LIVE FOLDERS -->
+        <activity
+            android:name=".ContactsLiveFolders$AllContacts"
+            android:label="@string/liveFolderAll"
+            android:icon="@drawable/ic_launcher_contacts">
+            <intent-filter>
+                <action android:name="android.intent.action.CREATE_LIVE_FOLDER" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".ContactsLiveFolders$StarredContacts"
+            android:label="@string/liveFolderFavorites"
+            android:icon="@drawable/ic_launcher_contacts_starred">
+            <intent-filter>
+                <action android:name="android.intent.action.CREATE_LIVE_FOLDER" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
+        <activity
+            android:name=".ContactsLiveFolders$PhoneContacts"
+            android:label="@string/liveFolderPhone"
+            android:icon="@drawable/ic_launcher_contacts_phones">
+            <intent-filter>
+                <action android:name="android.intent.action.CREATE_LIVE_FOLDER" />
+                <category android:name="android.intent.category.DEFAULT" />
+            </intent-filter>
+        </activity>
+
     </application>
 </manifest>
 
diff --git a/res/drawable-finger/backpanel_bottom_white.9.png b/res/drawable-finger/backpanel_bottom_white.9.png
deleted file mode 100644
index ffcc228..0000000
--- a/res/drawable-finger/backpanel_bottom_white.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/btn_dial_textfield_activated_full.9.png b/res/drawable-finger/btn_dial_textfield_activated_full.9.png
deleted file mode 100644
index f0a571c..0000000
--- a/res/drawable-finger/btn_dial_textfield_activated_full.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/btn_dial_textfield_normal_full.9.png b/res/drawable-finger/btn_dial_textfield_normal_full.9.png
deleted file mode 100644
index 261d130..0000000
--- a/res/drawable-finger/btn_dial_textfield_normal_full.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/btn_dial_textfield_pressed_full.9.png b/res/drawable-finger/btn_dial_textfield_pressed_full.9.png
deleted file mode 100644
index 7db856b..0000000
--- a/res/drawable-finger/btn_dial_textfield_pressed_full.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/btn_dial_textfield_selected_full.9.png b/res/drawable-finger/btn_dial_textfield_selected_full.9.png
deleted file mode 100644
index 2667868..0000000
--- a/res/drawable-finger/btn_dial_textfield_selected_full.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/header_bottom_white.9.png b/res/drawable-finger/header_bottom_white.9.png
deleted file mode 100644
index 5d06aec..0000000
--- a/res/drawable-finger/header_bottom_white.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/ic_btn_write_sms.png b/res/drawable-finger/ic_btn_write_sms.png
deleted file mode 100644
index 0f2cf07..0000000
--- a/res/drawable-finger/ic_btn_write_sms.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/ic_dialer_fork_add_call.png b/res/drawable-finger/ic_dialer_fork_add_call.png
new file mode 100644
index 0000000..5a1555b
--- /dev/null
+++ b/res/drawable-finger/ic_dialer_fork_add_call.png
Binary files differ
diff --git a/res/drawable-finger/ic_dialer_fork_current_call.png b/res/drawable-finger/ic_dialer_fork_current_call.png
new file mode 100644
index 0000000..1be783e
--- /dev/null
+++ b/res/drawable-finger/ic_dialer_fork_current_call.png
Binary files differ
diff --git a/res/drawable-finger/ic_dialer_fork_tt_keypad.png b/res/drawable-finger/ic_dialer_fork_tt_keypad.png
new file mode 100644
index 0000000..4e3dd82
--- /dev/null
+++ b/res/drawable-finger/ic_dialer_fork_tt_keypad.png
Binary files differ
diff --git a/res/drawable-finger/ic_menu_add_picture.png b/res/drawable-finger/ic_menu_add_picture.png
new file mode 100644
index 0000000..35f10b8
--- /dev/null
+++ b/res/drawable-finger/ic_menu_add_picture.png
Binary files differ
diff --git a/res/drawable-finger/ic_menu_contact.png b/res/drawable-finger/ic_menu_contact.png
deleted file mode 100644
index 29b7cd9..0000000
--- a/res/drawable-finger/ic_menu_contact.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/ic_menu_dialer.png b/res/drawable-finger/ic_menu_dialer.png
deleted file mode 100644
index db21f96..0000000
--- a/res/drawable-finger/ic_menu_dialer.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/ic_menu_import_contact.png b/res/drawable-finger/ic_menu_import_contact.png
new file mode 100755
index 0000000..fcb16db
--- /dev/null
+++ b/res/drawable-finger/ic_menu_import_contact.png
Binary files differ
diff --git a/res/drawable-finger/ic_menu_refresh.png b/res/drawable-finger/ic_menu_refresh.png
new file mode 100755
index 0000000..77d70dd
--- /dev/null
+++ b/res/drawable-finger/ic_menu_refresh.png
Binary files differ
diff --git a/res/drawable-finger/ic_menu_send.png b/res/drawable-finger/ic_menu_send.png
deleted file mode 100644
index 74c096d..0000000
--- a/res/drawable-finger/ic_menu_send.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable-finger/ic_menu_show_barcode.png b/res/drawable-finger/ic_menu_show_barcode.png
new file mode 100755
index 0000000..cb66ae5
--- /dev/null
+++ b/res/drawable-finger/ic_menu_show_barcode.png
Binary files differ
diff --git a/res/drawable/dialog_full_dark.9.png b/res/drawable/dialog_full_dark.9.png
deleted file mode 100755
index 18914b3..0000000
--- a/res/drawable/dialog_full_dark.9.png
+++ /dev/null
Binary files differ
diff --git a/res/drawable/ic_launcher_contacts_phones.png b/res/drawable/ic_launcher_contacts_phones.png
new file mode 100644
index 0000000..822cc31
--- /dev/null
+++ b/res/drawable/ic_launcher_contacts_phones.png
Binary files differ
diff --git a/res/drawable/ic_launcher_contacts_starred.png b/res/drawable/ic_launcher_contacts_starred.png
new file mode 100644
index 0000000..328761e
--- /dev/null
+++ b/res/drawable/ic_launcher_contacts_starred.png
Binary files differ
diff --git a/res/layout-finger/contacts_list_content.xml b/res/layout-finger/contacts_list_content.xml
index 23f8521..32b7ffc 100644
--- a/res/layout-finger/contacts_list_content.xml
+++ b/res/layout-finger/contacts_list_content.xml
@@ -18,29 +18,28 @@
         android:layout_width="fill_parent"
         android:layout_height="fill_parent"
         android:orientation="vertical">
-<!-- The group banner isn't used anymore
-    <TextView 
-            android:id="@+id/contact_group"
-            android:text="@string/noContacts"
+
+    <ListView android:id="@android:id/list"
+            android:layout_width="fill_parent" 
+            android:layout_height="fill_parent"
+            android:fastScrollEnabled="true"
+    />
+
+    <ScrollView android:id="@android:id/empty"
+        android:layout_width="fill_parent"
+        android:layout_height="fill_parent"
+        android:fillViewport="true"
+    >
+        <TextView android:id="@+id/emptyText"
             android:layout_width="fill_parent"
             android:layout_height="wrap_content"
-            android:background="@android:drawable/title_bar"
-            style="@android:style/TextAppearance.WindowTitle"/>
--->
-    <com.android.contacts.FastScrollView 
-            android:layout_width="fill_parent"
-            android:layout_height="fill_parent">
-        <ListView android:id="@android:id/list"
-                android:layout_width="fill_parent" 
-                android:layout_height="fill_parent"
+            android:text="@string/noContacts"
+            android:textSize="20sp"
+            android:textColor="?android:attr/textColorSecondary"
+            android:paddingLeft="10dip"
+            android:paddingRight="10dip"
+            android:paddingTop="10dip"
+            android:lineSpacingMultiplier="0.92"
         />
-
-        <TextView android:id="@android:id/empty"
-                android:layout_width="fill_parent"
-                android:layout_height="fill_parent"
-                android:gravity="center"
-                android:text="@string/noContacts"
-                android:textAppearance="?android:attr/textAppearanceLarge"
-        />
-    </com.android.contacts.FastScrollView>
+    </ScrollView>
 </LinearLayout>
diff --git a/res/layout-finger/dialpad_chooser_list_item.xml b/res/layout-finger/dialpad_chooser_list_item.xml
new file mode 100644
index 0000000..c5abeac
--- /dev/null
+++ b/res/layout-finger/dialpad_chooser_list_item.xml
@@ -0,0 +1,35 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- Copyright (C) 2008 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.
+-->
+
+<!-- Layout of a single item in the Dialer's "Dialpad chooser" UI. -->
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:orientation="horizontal"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent">
+
+    <ImageView android:id="@+id/icon"
+        android:layout_width="64px"
+        android:layout_height="64px"
+        android:scaleType="center" />
+
+    <TextView android:id="@+id/text"
+        android:textAppearance="?android:attr/textAppearanceMedium"
+        android:layout_gravity="center_vertical"
+        android:layout_width="0dip"
+        android:layout_weight="1"
+        android:layout_height="wrap_content" />
+
+</LinearLayout>
diff --git a/res/layout-finger/edit_contact.xml b/res/layout-finger/edit_contact.xml
index 858d654..7d0f449 100644
--- a/res/layout-finger/edit_contact.xml
+++ b/res/layout-finger/edit_contact.xml
@@ -43,10 +43,10 @@
                 android:layout_marginLeft="6dip"
                 android:layout_marginRight="10dip"
             >
-                <Button android:id="@+id/photoButton"
+                <ImageButton android:id="@+id/photoButton"
                     android:layout_width="fill_parent"
                     android:layout_height="fill_parent"
-                    android:text="@string/addPicture"
+                    android:src="@drawable/ic_menu_add_picture"
                     android:gravity="center"
                 />
 
@@ -66,8 +66,7 @@
                 android:layout_height="wrap_content"
                 android:layout_marginRight="4dip"
                 android:gravity="center_vertical"
-                android:singleLine="true"
-                android:capitalize="words"
+                android:inputType="textPersonName|textCapWords"
                 android:hint="@string/ghostData_name"
                 android:nextFocusDown="@id/data"
             />
diff --git a/res/layout-finger/sync_settings.xml b/res/layout-finger/sync_settings.xml
new file mode 100644
index 0000000..50d0d47
--- /dev/null
+++ b/res/layout-finger/sync_settings.xml
@@ -0,0 +1,53 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+/*
+ * Copyright (C) 2008 Google Inc.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+-->
+
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:layout_width="fill_parent"
+    android:layout_height="fill_parent"
+    android:orientation="vertical"
+>
+
+    <ListView android:id="@android:id/list"
+        android:layout_width="fill_parent"
+        android:layout_height="0dip"
+        android:layout_weight="1"
+    />
+
+    <LinearLayout
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:background="@android:drawable/bottom_bar"
+        android:orientation="horizontal"
+        android:gravity="center_vertical"
+    >
+        <Button android:id="@+id/ok"
+            android:layout_width="0dip"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@android:string/ok"
+        />
+
+        <Button android:id="@+id/cancel"
+            android:layout_width="0dip"
+            android:layout_height="wrap_content"
+            android:layout_weight="1"
+            android:text="@android:string/cancel"
+        />
+    </LinearLayout>
+</LinearLayout>
diff --git a/res/layout-finger/twelve_key_dialer.xml b/res/layout-finger/twelve_key_dialer.xml
index 84f2517..172a4ba 100644
--- a/res/layout-finger/twelve_key_dialer.xml
+++ b/res/layout-finger/twelve_key_dialer.xml
@@ -20,7 +20,7 @@
     android:layout_height="fill_parent"
     android:orientation="vertical"
 >
-    <LinearLayout
+    <LinearLayout android:id="@+id/digitsAndBackspace"
         android:layout_width="fill_parent"
         android:layout_height="66px"
         android:layout_marginTop="3px"
@@ -57,4 +57,15 @@
 
     <!-- Keypad section -->
     <include layout="@layout/dialpad" />
+
+    <!-- "Dialpad chooser" UI, shown only when the user brings up the
+         Dialer while a call is already in progress.
+         When this UI is visible, the other Dialer elements
+         (the textfield/button and the dialpad) are hidden. -->
+    <ListView android:id="@+id/dialpadChooser"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:footerDividersEnabled="true"
+    />
+
 </LinearLayout>
diff --git a/res/layout-land-finger/twelve_key_dialer.xml b/res/layout-land-finger/twelve_key_dialer.xml
index 3daf6d2..2b436b8 100644
--- a/res/layout-land-finger/twelve_key_dialer.xml
+++ b/res/layout-land-finger/twelve_key_dialer.xml
@@ -20,7 +20,7 @@
     android:layout_height="fill_parent"
     android:orientation="vertical"
 >
-    <LinearLayout
+    <LinearLayout android:id="@+id/digitsAndBackspace"
         android:layout_width="fill_parent"
         android:layout_height="66px"
         android:addStatesFromChildren="true"
@@ -58,4 +58,15 @@
         />
 
     </LinearLayout>
+
+    <!-- "Dialpad chooser" UI, shown only when the user brings up the
+         Dialer while a call is already in progress.
+         When this UI is visible, the other Dialer elements
+         (the textfield and button) are hidden. -->
+    <ListView android:id="@+id/dialpadChooser"
+        android:layout_width="fill_parent"
+        android:layout_height="wrap_content"
+        android:footerDividersEnabled="true"
+    />
+
 </LinearLayout>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index ac39f7d..9b8f033 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -1,65 +1,177 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="attachToContact">Obrázek kontaktu</string>
-  <string name="button_discard">Zrušit změny</string>
-  <string name="button_save">Uložit</string>
-  <string name="cancelButtonText">Storno</string>
-  <string name="contactsList">Kontakty</string>
-  <string name="continueEditing">Pokračovat v úpravách</string>
-  <string name="customLabelPickerTitle">Vlastní štítek</string>
-  <string name="deleteConfirmation">Odstranit tento kontakt?</string>
-  <string name="discardChanges">Zrušit změny</string>
-  <string name="displayAllPreference">Zobrazit všechny kontakty</string>
-  <string name="displayAllPreference_summary">Zobrazit všechny kontakty nebo jen kontakty s telefonními čísly</string>
-  <string name="editContact_title_edit">Upravit kontakt</string>
-  <string name="editContact_title_insert">Nový kontakt</string>
-  <string name="emailLabelsGroup">E-mail</string>
-  <string name="errorDialogTitle">Upozornění!</string>
-  <string name="frequentList">Časté</string>
-  <string name="ghostData_company">Společnost</string>
-  <string name="ghostData_email">E-mailová adresa</string>
-  <string name="ghostData_im">Jméno pro zasílání rychlých zpráv</string>
-  <string name="ghostData_name">První a poslední</string>
-  <string name="ghostData_notes">Poznámka</string>
-  <string name="ghostData_phone">Telefonní číslo</string>
-  <string name="ghostData_postal">"Ulice\nMěsto, stát, PSČ\nZemě"</string>
-  <string name="ghostData_title">Poloha</string>
-  <string name="imLabelsGroup">Rych. zpr.</string>
-  <string name="importFromSim">Importovat z karty SIM</string>
-  <string name="invalidContactMessage">Kontakty musí mít názvy</string>
-  <string name="label_company">Společnost</string>
-  <string name="label_notes">Poznámky</string>
-  <string name="label_title">Funkce</string>
-  <string name="menu_addItem">a další</string>
-  <string name="menu_addStar">Přidat hvězdičku</string>
-  <string name="menu_call">Volat</string>
-  <string name="menu_callNumber">Volat<xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">Odstranit kontakt</string>
-  <string name="menu_dialer">Telefon</string>
-  <string name="menu_doNotSave">Zrušit změny</string>
-  <string name="menu_done">Uložit</string>
-  <string name="menu_editContact">Upravit kontakt</string>
-  <string name="menu_editNumberBeforeCall">Upravit číslo před voláním</string>
-  <string name="menu_makeDefaultNumber">Vytvořit výchozí číslo</string>
-  <string name="menu_newContact">Nový kontakt</string>
-  <string name="menu_preferences">Nastavení</string>
-  <string name="menu_removeStar">Odebrat hvězdičku</string>
-  <string name="menu_sendEmail">Odeslat e-mail</string>
-  <string name="menu_sendSMS">Odeslat text</string>
-  <string name="menu_viewAddress">Adresa na mapě</string>
-  <string name="menu_viewContact">Zobrazit kontakt</string>
-  <string name="noButton">Storno</string>
-  <string name="okButtonText">OK</string>
-  <string name="otherLabelsGroup">Jiné</string>
-  <string name="phoneLabelsGroup">Telefon</string>
-  <string name="photoPickerNotFoundText">Žádné obrázky nejsou k dispozici.</string>
-  <string name="pickerNewContactHeader">Vytvořit nový kontakt</string>
-  <string name="postalLabelsGroup">Poštovní adresa</string>
-  <string name="searchHint">Hledat v kontaktech</string>
-  <string name="selectLabel">Vybrat štítek</string>
-  <string name="sms_entry_label">Odeslat SMS</string>
-  <string name="starredList">Hlavní</string>
-  <string name="strequentList">Oblíbené položky</string>
-  <string name="yesButton">OK</string>
+    <string name="contactsList">"Kontakty"</string>
+    <!-- no translation found for shortcutContact (1520089872483067797) -->
+    <skip />
+    <string name="starredList">"Hlavní"</string>
+    <string name="frequentList">"Časté"</string>
+    <string name="strequentList">"Oblíbené položky"</string>
+    <!-- no translation found for viewContactTitle (5340316765801746261) -->
+    <skip />
+    <!-- no translation found for viewContactDesription (5593543465183236254) -->
+    <skip />
+    <!-- no translation found for editContactDescription (207393633337592309) -->
+    <skip />
+    <!-- no translation found for insertContactDescription (8392185611221432248) -->
+    <skip />
+    <string name="searchHint">"Hledat v kontaktech"</string>
+    <string name="menu_newContact">"Nový kontakt"</string>
+    <string name="menu_viewContact">"Zobrazit kontakt"</string>
+    <!-- unknown placeholder CONTACT in menu_callNumber -->
+    <skip />
+    <string name="menu_addStar">"Přidat hvězdičku"</string>
+    <string name="menu_removeStar">"Odebrat hvězdičku"</string>
+    <!-- no translation found for menu_showBarcode (4627916987700748636) -->
+    <skip />
+    <string name="menu_editContact">"Upravit kontakt"</string>
+    <string name="menu_deleteContact">"Odstranit kontakt"</string>
+    <string name="menu_call">"Volat"</string>
+    <string name="menu_sendSMS">"Odeslat text"</string>
+    <string name="menu_sendEmail">"Odeslat e-mail"</string>
+    <string name="menu_viewAddress">"Adresa na mapě"</string>
+    <string name="menu_makeDefaultNumber">"Vytvořit výchozí číslo"</string>
+    <!-- no translation found for deleteConfirmation_title (1628057421142368583) -->
+    <skip />
+    <string name="deleteConfirmation">"Odstranit tento kontakt?"</string>
+    <string name="menu_done">"Uložit"</string>
+    <string name="menu_doNotSave">"Zrušit změny"</string>
+    <string name="button_save">"Uložit"</string>
+    <string name="button_discard">"Zrušit změny"</string>
+    <string name="editContact_title_edit">"Upravit kontakt"</string>
+    <string name="editContact_title_insert">"Nový kontakt"</string>
+    <string name="menu_addItem">"a další"</string>
+    <string name="label_notes">"Poznámky"</string>
+    <!-- no translation found for label_ringtone (1269538172838343970) -->
+    <skip />
+    <string name="ghostData_name">"První a poslední"</string>
+    <string name="ghostData_company">"Společnost"</string>
+    <string name="ghostData_title">"Poloha"</string>
+    <string name="ghostData_im">"Jméno pro zasílání rychlých zpráv"</string>
+    <string name="ghostData_notes">"Poznámka"</string>
+    <string name="ghostData_phone">"Telefonní číslo"</string>
+    <string name="ghostData_email">"E-mailová adresa"</string>
+    <!-- unknown placeholder BREAK_0 in ghostData_postal -->
+    <skip />
+    <string name="invalidContactMessage">"Kontakty musí mít názvy"</string>
+    <string name="pickerNewContactHeader">"Vytvořit nový kontakt"</string>
+    <string name="selectLabel">"Vybrat štítek"</string>
+    <string name="phoneLabelsGroup">"Telefon"</string>
+    <string name="emailLabelsGroup">"E-mail"</string>
+    <string name="imLabelsGroup">"Rych. zpr."</string>
+    <string name="postalLabelsGroup">"Poštovní adresa"</string>
+    <string name="otherLabelsGroup">"Jiné"</string>
+    <!-- no translation found for otherLabels:0 (3318569574569948132) -->
+    <!-- no translation found for otherLabels:1 (3325413568383685728) -->
+    <string name="errorDialogTitle">"Upozornění!"</string>
+    <string name="photoPickerNotFoundText">"Žádné obrázky nejsou k dispozici."</string>
+    <string name="attachToContact">"Obrázek kontaktu"</string>
+    <string name="customLabelPickerTitle">"Vlastní štítek"</string>
+    <!-- no translation found for menu_displayGroup (2835746769742496686) -->
+    <skip />
+    <!-- no translation found for syncGroupPreference (759121296595419145) -->
+    <skip />
+    <string name="importFromSim">"Importovat z karty SIM"</string>
+    <!-- no translation found for alphabet (4977128516779796464) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_checkbox (1699633783417579410) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_view (4299389800446371057) -->
+    <skip />
+    <!-- no translation found for default_ringtone (3998437793418131562) -->
+    <skip />
+    <!-- no translation found for addPicture (7010902051370875352) -->
+    <skip />
+    <!-- no translation found for removePicture (2322840177008417519) -->
+    <skip />
+    <!-- no translation found for noContacts (7515781671301309298) -->
+    <skip />
+    <!-- no translation found for noContactsWithPhoneNumbers (3105170743499016241) -->
+    <skip />
+    <!-- no translation found for noFavorites (7957536428532225634) -->
+    <skip />
+    <!-- no translation found for select_group_title (8821785850959403592) -->
+    <skip />
+    <!-- no translation found for groupEmpty (1733723844723885242) -->
+    <skip />
+    <!-- no translation found for showAllGroups (4524662887308889400) -->
+    <skip />
+    <!-- no translation found for syncAllGroups (8415112909188430211) -->
+    <skip />
+    <!-- no translation found for groupNameMyContacts (1298661863710879264) -->
+    <skip />
+    <!-- no translation found for groupNameWithPhones (4051877952712463294) -->
+    <skip />
+    <!-- no translation found for contactCreatedToast (5309869712901550955) -->
+    <skip />
+    <!-- no translation found for contactSavedToast (1228932477738680325) -->
+    <skip />
+    <!-- no translation found for listSeparatorCallNumber (9142725721395758026) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendSmsMms (8878062000446372333) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendEmail (3813935531061488274) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendIm (3885045096980470847) -->
+    <skip />
+    <!-- no translation found for listSeparatorMapAddress (7749519405208811410) -->
+    <skip />
+    <!-- no translation found for listSeparatorOrganizations (5731454670822188295) -->
+    <skip />
+    <!-- no translation found for listSeparatorOtherInformation (3399084175925138065) -->
+    <skip />
+    <!-- no translation found for contactsIconLabel (392729648321810378) -->
+    <skip />
+    <!-- no translation found for contactsFavoritesLabel (6274307000699136596) -->
+    <skip />
+    <!-- no translation found for dialerIconLabel (396765298398417139) -->
+    <skip />
+    <!-- no translation found for recentCallsIconLabel (7432201162713288826) -->
+    <skip />
+    <!-- no translation found for liveFolderAll (5991510762804226223) -->
+    <skip />
+    <!-- no translation found for liveFolderFavorites (8755759874416875970) -->
+    <skip />
+    <!-- no translation found for liveFolderPhone (3440101264360244544) -->
+    <skip />
+    <!-- no translation found for menu_sendTextMessage (3055919380461974147) -->
+    <skip />
+    <!-- no translation found for recentCalls_callNumber (924407199258234369) -->
+    <skip />
+    <!-- no translation found for recentCalls_editNumberBeforeCall (7859145185424954030) -->
+    <skip />
+    <!-- no translation found for recentCalls_addToContact (6950267092567953305) -->
+    <skip />
+    <!-- no translation found for recentCalls_removeFromRecentList (5273789011391059975) -->
+    <skip />
+    <!-- no translation found for recentCalls_deleteAll (425798199678070888) -->
+    <skip />
+    <!-- no translation found for recentCalls_empty (7787624895504983911) -->
+    <skip />
+    <!-- no translation found for imei (1052536402066249452) -->
+    <skip />
+    <!-- no translation found for voicemail (1135686231023059817) -->
+    <skip />
+    <!-- no translation found for unknown (6231893925212017656) -->
+    <skip />
+    <!-- no translation found for private_num (3065614133902647350) -->
+    <skip />
+    <!-- no translation found for dialerKeyboardHintText (2013777173021862941) -->
+    <skip />
+    <!-- no translation found for simContacts_emptyLoading (4828419758306519589) -->
+    <skip />
+    <!-- no translation found for simContacts_title (4162577066960174009) -->
+    <skip />
+    <!-- no translation found for contactsSyncPlug (1549212649158409469) -->
+    <skip />
+    <!-- no translation found for noContactsHelpText (6155730972704522463) -->
+    <skip />
+    <!-- no translation found for seclectSyncGroups_title (7675331949118054911) -->
+    <skip />
+    <!-- no translation found for liveFolder_all_label (3716551598022430019) -->
+    <skip />
+    <!-- no translation found for liveFolder_favorites_label (9053985659909059395) -->
+    <skip />
+    <!-- no translation found for liveFolder_phones_label (8943901400107401868) -->
+    <skip />
 </resources>
diff --git a/res/values-de-rDE/strings.xml b/res/values-de-rDE/strings.xml
deleted file mode 100644
index dc2aa59..0000000
--- a/res/values-de-rDE/strings.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="addPicture">Symbol hinzufügen</string>
-  <string name="allContacts">Alle Kontakte</string>
-  <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-  <string name="attachToContact">Kontaktsymbol</string>
-  <string name="button_discard">Änderungen verwerfen</string>
-  <string name="button_save">Speichern</string>
-  <string name="cancelButtonText">Abbrechen</string>
-  <string name="contactCreatedToast">Kontakt erstellt.</string>
-  <string name="contactSavedToast">Kontakt gespeichert.</string>
-  <string name="contactsFavoritesLabel">Favoriten</string>
-  <string name="contactsIconLabel">Kontakte</string>
-  <string name="contactsList">Kontakte</string>
-  <string name="customLabelPickerTitle">Benutzerdefiniertes Etikett</string>
-  <string name="default_ringtone">Standard</string>
-  <string name="deleteConfirmation">Dieser Kontakt wird gelöscht.</string>
-  <string name="deleteConfirmation_title">Löschen</string>
-  <string name="dialerIconLabel">Wähltastatur</string>
-  <string name="dialerKeyboardHintText">Feste Tastatur zum Wählen verwenden</string>
-  <string name="doneButton">Fertig</string>
-  <string name="editContactDescription">Kontakt bearbeiten</string>
-  <string name="editContact_title_edit">Kontakt bearbeiten</string>
-  <string name="editContact_title_insert">Neuer Kontakt</string>
-  <string name="emailLabelsGroup">E-Mail</string>
-  <string name="errorDialogTitle">Keine Bilder</string>
-  <string name="frequentList">Häufig</string>
-  <string name="ghostData_company">Firma</string>
-  <string name="ghostData_email">E-Mail-Adresse</string>
-  <string name="ghostData_im">IM-Name</string>
-  <string name="ghostData_name">Vor- und Nachname</string>
-  <string name="ghostData_notes">Eigene Notiz</string>
-  <string name="ghostData_phone">Telefonnummer</string>
-  <string name="ghostData_postal">Postadresse</string>
-  <string name="ghostData_title">Position</string>
-  <string name="groupEmpty">Die \"<xliff:g id="groupName">%s</xliff:g>\" Gruppe ist leer.</string>
-  <string name="groupNameMyContacts">Eigene Kontakte</string>
-  <string name="groupNameWithPhones">Kontakte mit Telefonnummern</string>
-  <string name="imLabelsGroup">IM</string>
-  <string name="imei">IMEI</string>
-  <string name="importFromSim">SIM-Kontakt-Import</string>
-  <string name="insertContactDescription">Kontakt erstellen</string>
-  <string name="invalidContactMessage">Der Kontakt existiert nicht.</string>
-  <string name="label_company">Firma</string>
-  <string name="label_notes">Notizen</string>
-  <string name="label_ringtone">Klingelton</string>
-  <string name="label_title">Arbeitsbezeichnung</string>
-  <string name="listSeparatorCallNumber">Nummer wählen</string>
-  <string name="listSeparatorMapAddress">Kartenansicht Adresse</string>
-  <string name="listSeparatorOrganizations">Organisationen</string>
-  <string name="listSeparatorOtherInformation">Andere Informationen</string>
-  <string name="listSeparatorSendEmail">E-Mail senden</string>
-  <string name="listSeparatorSendIm">Sofortnachricht senden</string>
-  <string name="listSeparatorSendSmsMms">SMS/MMS senden</string>
-  <string name="menu_addItem">Weitere Info</string>
-  <string name="menu_addStar">Zu Favoriten hinzufügen</string>
-  <string name="menu_call">Anrufen</string>
-  <string name="menu_callNumber"><xliff:g id="contact">%s</xliff:g> anrufen</string>
-  <string name="menu_deleteContact">Kontakt löschen</string>
-  <string name="menu_dialer">Wähltastatur</string>
-  <string name="menu_displayGroup">Gruppe anzeigen</string>
-  <string name="menu_doNotSave">Änderungen verwerfen</string>
-  <string name="menu_done">Speichern</string>
-  <string name="menu_editContact">Kontakt bearbeiten</string>
-  <string name="menu_editNumberBeforeCall">Nummer vor Anruf bearbeiten</string>
-  <string name="menu_makeDefaultNumber">Standardnummer erstellen</string>
-  <string name="menu_newContact">Neuer Kontakt</string>
-  <string name="menu_newFavortie">Neuer Favorit</string>
-  <string name="menu_preferences">Einstellungen</string>
-  <string name="menu_removeStar">Aus Favoriten entfernen</string>
-  <string name="menu_sendEmail">E-Mail senden</string>
-  <string name="menu_sendSMS">SMS/MMS senden</string>
-  <string name="menu_sendTextMessage">SMS-Nachricht senden</string>
-  <string name="menu_viewAddress">Kartenansicht Adresse</string>
-  <string name="menu_viewContact">Kontakt anzeigen</string>
-  <string name="noButton">Abbrechen</string>
-  <string name="noContacts">Keine Kontakte.</string>
-  <string name="noContactsWithPhoneNumbers">Keine Kontakte mit Telefonnummern.</string>
-  <string name="noFavorites">Keine Favoriten.</string>
-  <string name="no_imei">Unbekannte IMEI</string>
-  <string name="ok">OK</string>
-  <string name="okButtonText">OK</string>
-  <string name="otherLabelsGroup">Andere</string>
-  <string name="phoneIconLabel">Telefon</string>
-  <string name="phoneLabelsGroup">Telefon</string>
-  <string name="photoPickerNotFoundText">Für Telefon stehen keine Bilder zur Verfügung.</string>
-  <string name="pickerNewContactHeader">Neuen Kontakt erstellen</string>
-  <string name="postalLabelsGroup">Postanschrift</string>
-  <string name="private_num">Privatnummer</string>
-  <string name="recentCallsIconLabel">Anrufliste</string>
-  <string name="recentCalls_addToContact">Zu Kontakten hinzufügen</string>
-  <string name="recentCalls_callNumber"><xliff:g id="who">%s</xliff:g> anrufen</string>
-  <string name="recentCalls_deleteAll">Anrufliste löschen</string>
-  <string name="recentCalls_editNumberBeforeCall">Nummer vor Anruf bearbeiten</string>
-  <string name="recentCalls_empty">Anrufliste ist leer.</string>
-  <string name="recentCalls_removeFromRecentList">Aus Anrufliste entfernen</string>
-  <string name="removePicture">Symbol entfernen</string>
-  <string name="searchHint">Kontakte suchen</string>
-  <string name="selectGroupsToSync">Gruppen synchronisieren</string>
-  <string name="selectLabel">Etikett auswählen</string>
-  <string name="select_group_title">Gruppe zur Anzeige auswählen</string>
-  <string name="send_to_voicemail_checkbox">Anrufe direkt zur Mobilbox suchen.</string>
-  <string name="send_to_voicemail_view">Anrufe werden direkt zur Mobilbox gesendet.</string>
-  <string name="shortcutContact">Kontakt</string>
-  <string name="showAllGroups">Alle Kontakte</string>
-  <string name="showingGroupTitle">
-					<xliff:g id="groupName">%s</xliff:g>
-				</string>
-  <string name="simContacts_emptyLoading">Laden von SIM-Karte\u2026</string>
-  <string name="simContacts_title">SIM-Karten-Kontakte</string>
-  <string name="sms_entry_label">SMS/MMS senden</string>
-  <string name="starredList">Mit Stern</string>
-  <string name="strequentList">Favoriten</string>
-  <string name="syncAllGroups">Alle Kontakte synchronisieren</string>
-  <string name="syncGroupChooserTitle">Gruppe für Synchronisierung auswählen</string>
-  <string name="syncGroupPreference">Gruppen synchronisieren</string>
-  <string name="syncGroupPreference_summary">Gruppen für Synchronisierung auswählen</string>
-  <string name="unknown">Unbekannt</string>
-  <string name="viewContactDesription">Kontakt anzeigen</string>
-  <string name="viewContactTitle">Kontaktdetails</string>
-  <string name="voicemail">Mobilbox</string>
-  <string name="yesButton">OK</string>
-</resources>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
new file mode 100644
index 0000000..0b98318
--- /dev/null
+++ b/res/values-de/strings.xml
@@ -0,0 +1,133 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="contactsList">"Kontakte"</string>
+    <string name="shortcutContact">"Kontakt"</string>
+    <string name="starredList">"Markiert"</string>
+    <string name="frequentList">"Häufig"</string>
+    <string name="strequentList">"Favoriten"</string>
+    <string name="viewContactTitle">"Kontaktinformationen"</string>
+    <string name="viewContactDesription">"Kontakt anzeigen"</string>
+    <string name="editContactDescription">"Kontakt bearbeiten"</string>
+    <string name="insertContactDescription">"Kontakt erstellen"</string>
+    <string name="searchHint">"Kontakte durchsuchen"</string>
+    <string name="menu_newContact">"Neuer Kontakt"</string>
+    <string name="menu_viewContact">"Kontakt anzeigen"</string>
+    <string name="menu_callNumber">"<xliff:g id="NAME">%s</xliff:g> anrufen"</string>
+    <string name="menu_addStar">"Zu Favoriten hinzufügen"</string>
+    <string name="menu_removeStar">"Aus Favoriten entfernen"</string>
+    <!-- no translation found for menu_showBarcode (309973637178814132) -->
+    <skip />
+    <string name="menu_editContact">"Kontakt bearbeiten"</string>
+    <string name="menu_deleteContact">"Kontakt löschen"</string>
+    <string name="menu_call">"Anruf"</string>
+    <string name="menu_sendSMS">"SMS/MMS senden"</string>
+    <string name="menu_sendEmail">"E-Mail senden"</string>
+    <string name="menu_viewAddress">"Adresse auf der Karte"</string>
+    <string name="menu_makeDefaultNumber">"Als Standardnummer festlegen"</string>
+    <string name="deleteConfirmation_title">"Löschen"</string>
+    <string name="deleteConfirmation">"Dieser Kontakt wird gelöscht."</string>
+    <string name="menu_done">"Speichern"</string>
+    <string name="menu_doNotSave">"Änderungen löschen"</string>
+    <string name="button_save">"Speichern"</string>
+    <string name="button_discard">"Änderungen löschen"</string>
+    <string name="editContact_title_edit">"Kontakt bearbeiten"</string>
+    <string name="editContact_title_insert">"Neuer Kontakt"</string>
+    <string name="menu_addItem">"Weitere Informationen"</string>
+    <string name="label_notes">"Notizen"</string>
+    <string name="label_ringtone">"Klingelton"</string>
+    <string name="ghostData_name">"Vor- und Nachname"</string>
+    <string name="ghostData_company">"Unternehmen"</string>
+    <string name="ghostData_title">"Position"</string>
+    <string name="ghostData_im">"IM-Name"</string>
+    <string name="ghostData_notes">"Meine Notiz"</string>
+    <string name="ghostData_phone">"Telefonnummer"</string>
+    <string name="ghostData_email">"E-Mail-Adresse"</string>
+    <string name="ghostData_postal">"Postanschrift"</string>
+    <string name="invalidContactMessage">"Dieser Kontakt existiert nicht."</string>
+    <string name="pickerNewContactHeader">"Neuen Kontakt erstellen"</string>
+    <string name="selectLabel">"Wählen Sie ein Label aus."</string>
+    <string name="phoneLabelsGroup">"Telefon"</string>
+    <string name="emailLabelsGroup">"E-Mail"</string>
+    <string name="imLabelsGroup">"IM"</string>
+    <string name="postalLabelsGroup">"Postanschrift"</string>
+    <string name="otherLabelsGroup">"Sonstiges"</string>
+  <string-array name="otherLabels">
+    <item>"Organisation"</item>
+    <item>"Notiz"</item>
+  </string-array>
+    <string name="errorDialogTitle">"Keine Bilder"</string>
+    <string name="photoPickerNotFoundText">"Auf dem Telefon sind keine Bilder verfügbar."</string>
+    <string name="attachToContact">"Kontaktsymbol"</string>
+    <!-- no translation found for customLabelPickerTitle (1081475101983255212) -->
+    <skip />
+    <string name="menu_displayGroup">"Gruppe anzeigen"</string>
+    <string name="syncGroupPreference">"Synchron. bearbeiten"</string>
+    <string name="importFromSim">"Kontakte importieren"</string>
+    <string name="alphabet">"ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
+    <string name="send_to_voicemail_checkbox">"Anrufe direkt an Mailbox senden"</string>
+    <string name="send_to_voicemail_view">"Anrufe werden direkt an Mailbox gesendet"</string>
+    <string name="default_ringtone">"Standard"</string>
+    <string name="addPicture">"Symbol hinzufügen"</string>
+    <string name="removePicture">"Symbol entfernen"</string>
+    <string name="noContacts">"Keine Kontakte"</string>
+    <string name="noContactsWithPhoneNumbers">"Keine Kontakte mit Telefonnummern"</string>
+    <string name="noFavorites">"Keine Favoriten"</string>
+    <!-- no translation found for select_group_title (7955698611959835612) -->
+    <skip />
+    <string name="groupEmpty">"Ihre Gruppe \"<xliff:g id="GROUPNAME">%s</xliff:g>\" ist leer."</string>
+    <string name="showAllGroups">"Alle Kontakte"</string>
+    <string name="syncAllGroups">"Alle Kontakte synchronisieren"</string>
+    <string name="groupNameMyContacts">"Meine Kontakte"</string>
+    <string name="groupNameWithPhones">"Kontakte mit Telefonnummern"</string>
+    <string name="contactCreatedToast">"Kontakt erstellt"</string>
+    <string name="contactSavedToast">"Kontakt gespeichert"</string>
+    <string name="listSeparatorCallNumber">"Rufnummer"</string>
+    <string name="listSeparatorSendSmsMms">"SMS/MMS senden"</string>
+    <string name="listSeparatorSendEmail">"E-Mail senden"</string>
+    <string name="listSeparatorSendIm">"Per Chat (IM) kontaktieren"</string>
+    <string name="listSeparatorMapAddress">"Adresse in Maps"</string>
+    <string name="listSeparatorOrganizations">"Organisationen"</string>
+    <string name="listSeparatorOtherInformation">"Mehr Informationen"</string>
+    <string name="contactsIconLabel">"Kontakte"</string>
+    <string name="contactsFavoritesLabel">"Favoriten"</string>
+    <string name="dialerIconLabel">"Telefon"</string>
+    <string name="recentCallsIconLabel">"Anrufe"</string>
+    <!-- no translation found for liveFolderAll (4789010460767506206) -->
+    <skip />
+    <!-- no translation found for liveFolderFavorites (3100957542927222282) -->
+    <skip />
+    <!-- no translation found for liveFolderPhone (3739376066610926780) -->
+    <skip />
+    <string name="menu_sendTextMessage">"SMS-Nachricht senden"</string>
+    <string name="recentCalls_callNumber">"<xliff:g id="NAME">%s</xliff:g> anrufen"</string>
+    <string name="recentCalls_editNumberBeforeCall">"Nummer vor Anruf bearbeiten"</string>
+    <string name="recentCalls_addToContact">"Kontakten hinzufügen"</string>
+    <string name="recentCalls_removeFromRecentList">"Aus Anrufliste entfernen"</string>
+    <string name="recentCalls_deleteAll">"Anrufliste löschen"</string>
+    <string name="recentCalls_empty">"Anrufliste ist leer"</string>
+    <string name="imei">"IMEI"</string>
+    <string name="voicemail">"Mailbox"</string>
+    <string name="unknown">"Unbekannt"</string>
+    <string name="private_num">"Private Nummer"</string>
+    <string name="dialerKeyboardHintText">"Mit Tastatur wählen"</string>
+    <!-- no translation found for dialerDialpadHintText (5824490365898349041) -->
+    <skip />
+    <string name="simContacts_emptyLoading">"Ladevorgang von SIM-Karte läuft..."</string>
+    <string name="simContacts_title">"Kontakte auf SIM-Karte"</string>
+    <string name="contactsSyncPlug"><font fgcolor="#ffffffff">"Synchronisieren Sie Ihre Google-Kontakte!"</font>" "\n"Nach der Synchronisierung stehen Ihnen Ihre Kontakte überall zur Verfügung."</string>
+    <string name="noContactsHelpText">"Sie haben keine Kontakte."\n\n"Um Kontakte hinzuzufügen, klicken Sie auf "<font fgcolor="#ffffffff"><b>"Menü"</b></font>" und wählen Sie "\n\n" "\n<li><font fgcolor="#ffffffff"><b>"Synchronisierte Gruppen bearbeiten"</b></font>", um Kontakte aus einem neuen oder bestehenden Google-Konto hinzuzufügen,"\n</li>\n" "\n<li><font fgcolor="#ffffffff"><b>"Neuer Kontakt"</b></font>", um einen ganz neuen Kontakt hinzuzufügen"\n</li>\n" "\n<li><font fgcolor="#ffffffff"><b>"Kontakte importieren"</b></font>", um Kontakte von Ihrer SIM-Karte hinzuzufügen"\n</li></string>
+    <string name="seclectSyncGroups_title">"Zu synchronisierende Gruppen auswählen"</string>
+    <!-- no translation found for liveFolder_all_label (1552523730090319259) -->
+    <skip />
+    <!-- no translation found for liveFolder_favorites_label (2674341514070517105) -->
+    <skip />
+    <!-- no translation found for liveFolder_phones_label (1709786878793436245) -->
+    <skip />
+    <!-- no translation found for dialer_useDtmfDialpad (1707548397435075040) -->
+    <skip />
+    <!-- no translation found for dialer_returnToInCallScreen (3719386377550913067) -->
+    <skip />
+    <!-- no translation found for dialer_addAnotherCall (4205688819890074468) -->
+    <skip />
+</resources>
diff --git a/res/values-en-rGB/strings.xml b/res/values-en-rGB/strings.xml
index fdd1323..07b51da 100644
--- a/res/values-en-rGB/strings.xml
+++ b/res/values-en-rGB/strings.xml
@@ -1,122 +1,126 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="addPicture">Add icon</string>
-  <string name="allContacts">All contacts</string>
-  <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-  <string name="attachToContact">Contact icon</string>
-  <string name="button_discard">Discard changes</string>
-  <string name="button_save">Save</string>
-  <string name="cancelButtonText">Cancel</string>
-  <string name="contactCreatedToast">Contact created.</string>
-  <string name="contactSavedToast">Contact saved.</string>
-  <string name="contactsFavoritesLabel">Favourites</string>
-  <string name="contactsIconLabel">Contacts</string>
-  <string name="contactsList">Contacts</string>
-  <string name="customLabelPickerTitle">Custom label</string>
-  <string name="default_ringtone">Default</string>
-  <string name="deleteConfirmation">This contact will be deleted.</string>
-  <string name="deleteConfirmation_title">Delete</string>
-  <string name="dialerIconLabel">Dialer</string>
-  <string name="dialerKeyboardHintText">Use keyboard to dial</string>
-  <string name="doneButton">Done</string>
-  <string name="editContactDescription">Edit contact</string>
-  <string name="editContact_title_edit">Edit contact</string>
-  <string name="editContact_title_insert">New contact</string>
-  <string name="emailLabelsGroup">Email</string>
-  <string name="errorDialogTitle">No pictures</string>
-  <string name="frequentList">Frequent</string>
-  <string name="ghostData_company">Company</string>
-  <string name="ghostData_email">Email address</string>
-  <string name="ghostData_im">IM name</string>
-  <string name="ghostData_name">First and Last</string>
-  <string name="ghostData_notes">My note</string>
-  <string name="ghostData_phone">Phone number</string>
-  <string name="ghostData_postal">Postal address</string>
-  <string name="ghostData_title">Position</string>
-  <string name="groupEmpty">Your \"<xliff:g id="groupName">%s</xliff:g>\" group is empty.</string>
-  <string name="groupNameMyContacts">My Contacts</string>
-  <string name="groupNameWithPhones">Contacts with phone numbers</string>
-  <string name="imLabelsGroup">IM</string>
-  <string name="imei">IMEI</string>
-  <string name="importFromSim">Import from SIM card</string>
-  <string name="insertContactDescription">Create contact</string>
-  <string name="invalidContactMessage">The contact does not exist.</string>
-  <string name="label_company">Company</string>
-  <string name="label_notes">Notes</string>
-  <string name="label_ringtone">Ringtone</string>
-  <string name="label_title">Job title</string>
-  <string name="listSeparatorCallNumber">Dial number</string>
-  <string name="listSeparatorMapAddress">Map address</string>
-  <string name="listSeparatorOrganizations">Organisations</string>
-  <string name="listSeparatorOtherInformation">Other information</string>
-  <string name="listSeparatorSendEmail">Send email</string>
-  <string name="listSeparatorSendIm">Send instant message</string>
-  <string name="listSeparatorSendSmsMms">Send SMS/MMS</string>
-  <string name="menu_addItem">More info</string>
-  <string name="menu_addStar">Add to favourites</string>
-  <string name="menu_call">Call</string>
-  <string name="menu_callNumber">Call <xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">Delete contact</string>
-  <string name="menu_dialer">Dialer</string>
-  <string name="menu_displayGroup">Display group</string>
-  <string name="menu_doNotSave">Discard changes</string>
-  <string name="menu_done">Save</string>
-  <string name="menu_editContact">Edit contact</string>
-  <string name="menu_editNumberBeforeCall">Edit number before call</string>
-  <string name="menu_makeDefaultNumber">Make default number</string>
-  <string name="menu_newContact">New contact</string>
-  <string name="menu_newFavortie">New favourite</string>
-  <string name="menu_preferences">Settings</string>
-  <string name="menu_removeStar">Remove from favourites</string>
-  <string name="menu_sendEmail">Send email</string>
-  <string name="menu_sendSMS">Send SMS/MMS</string>
-  <string name="menu_sendTextMessage">Send SMS message</string>
-  <string name="menu_viewAddress">Map address</string>
-  <string name="menu_viewContact">View contact</string>
-  <string name="noButton">Cancel</string>
-  <string name="noContacts">No contacts.</string>
-  <string name="noContactsWithPhoneNumbers">No contacts with phone numbers.</string>
-  <string name="noFavorites">No favourites.</string>
-  <string name="no_imei">Unknown IMEI</string>
-  <string name="ok">OK</string>
-  <string name="okButtonText">OK</string>
-  <string name="otherLabelsGroup">Other</string>
-  <string name="phoneIconLabel">Phone</string>
-  <string name="phoneLabelsGroup">Phone</string>
-  <string name="photoPickerNotFoundText">No pictures are available on the phone.</string>
-  <string name="pickerNewContactHeader">Create new contact</string>
-  <string name="postalLabelsGroup">Postal address</string>
-  <string name="private_num">Private number</string>
-  <string name="recentCallsIconLabel">Call log</string>
-  <string name="recentCalls_addToContact">Add to contacts</string>
-  <string name="recentCalls_callNumber">Call <xliff:g id="who">%s</xliff:g></string>
-  <string name="recentCalls_deleteAll">Clear call log</string>
-  <string name="recentCalls_editNumberBeforeCall">Edit number before call</string>
-  <string name="recentCalls_empty">Call log is empty.</string>
-  <string name="recentCalls_removeFromRecentList">Remove from call log</string>
-  <string name="removePicture">Remove icon</string>
-  <string name="searchHint">Search contacts</string>
-  <string name="selectGroupsToSync">Sync groups</string>
-  <string name="selectLabel">Select label</string>
-  <string name="select_group_title">Select group to display</string>
-  <string name="send_to_voicemail_checkbox">Send calls directly to voicemail.</string>
-  <string name="send_to_voicemail_view">Calls are sent directly to voicemail.</string>
-  <string name="shortcutContact">Contact</string>
-  <string name="showAllGroups">All contacts</string>
-  <string name="showingGroupTitle"><xliff:g id="groupName">%s</xliff:g></string>
-  <string name="simContacts_emptyLoading">Loading from SIM card\u2026</string>
-  <string name="simContacts_title">SIM card contacts</string>
-  <string name="sms_entry_label">Send SMS/MMS</string>
-  <string name="starredList">Starred</string>
-  <string name="strequentList">Favourites</string>
-  <string name="syncAllGroups">Sync all contacts</string>
-  <string name="syncGroupChooserTitle">Select groups to sync</string>
-  <string name="syncGroupPreference">Sync groups</string>
-  <string name="syncGroupPreference_summary">Select groups to synchronize</string>
-  <string name="unknown">Unknown</string>
-  <string name="viewContactDesription">View contact</string>
-  <string name="viewContactTitle">Contact details</string>
-  <string name="voicemail">Voicemail</string>
-  <string name="yesButton">OK</string>
+    <string name="contactsList">"Contacts"</string>
+    <string name="shortcutContact">"Contact"</string>
+    <string name="starredList">"Starred"</string>
+    <string name="frequentList">"Frequent"</string>
+    <string name="strequentList">"Favourites"</string>
+    <string name="viewContactTitle">"Contact details"</string>
+    <string name="viewContactDesription">"View contact"</string>
+    <string name="editContactDescription">"Edit contact"</string>
+    <string name="insertContactDescription">"Create contact"</string>
+    <string name="searchHint">"Search contacts"</string>
+    <string name="menu_newContact">"New contact"</string>
+    <string name="menu_viewContact">"View contact"</string>
+    <!-- unknown placeholder CONTACT in menu_callNumber -->
+    <skip />
+    <string name="menu_addStar">"Add to favourites"</string>
+    <string name="menu_removeStar">"Remove from favourites"</string>
+    <!-- no translation found for menu_showBarcode (4627916987700748636) -->
+    <skip />
+    <string name="menu_editContact">"Edit contact"</string>
+    <string name="menu_deleteContact">"Delete contact"</string>
+    <string name="menu_call">"Call"</string>
+    <string name="menu_sendSMS">"Send SMS/MMS"</string>
+    <string name="menu_sendEmail">"Send email"</string>
+    <string name="menu_viewAddress">"Map address"</string>
+    <string name="menu_makeDefaultNumber">"Make default number"</string>
+    <string name="deleteConfirmation_title">"Delete"</string>
+    <string name="deleteConfirmation">"This contact will be deleted."</string>
+    <string name="menu_done">"Save"</string>
+    <string name="menu_doNotSave">"Discard changes"</string>
+    <string name="button_save">"Save"</string>
+    <string name="button_discard">"Discard changes"</string>
+    <string name="editContact_title_edit">"Edit contact"</string>
+    <string name="editContact_title_insert">"New contact"</string>
+    <string name="menu_addItem">"More info"</string>
+    <string name="label_notes">"Notes"</string>
+    <string name="label_ringtone">"Ringtone"</string>
+    <string name="ghostData_name">"First and Last"</string>
+    <string name="ghostData_company">"Company"</string>
+    <string name="ghostData_title">"Position"</string>
+    <string name="ghostData_im">"IM name"</string>
+    <string name="ghostData_notes">"My note"</string>
+    <string name="ghostData_phone">"Phone number"</string>
+    <string name="ghostData_email">"Email address"</string>
+    <string name="ghostData_postal">"Postal address"</string>
+    <string name="invalidContactMessage">"The contact does not exist."</string>
+    <string name="pickerNewContactHeader">"Create new contact"</string>
+    <string name="selectLabel">"Select label"</string>
+    <string name="phoneLabelsGroup">"Phone"</string>
+    <string name="emailLabelsGroup">"Email"</string>
+    <string name="imLabelsGroup">"IM"</string>
+    <string name="postalLabelsGroup">"Postal address"</string>
+    <string name="otherLabelsGroup">"Other"</string>
+    <!-- no translation found for otherLabels:0 (3318569574569948132) -->
+    <!-- no translation found for otherLabels:1 (3325413568383685728) -->
+    <string name="errorDialogTitle">"No pictures"</string>
+    <string name="photoPickerNotFoundText">"No pictures are available on the phone."</string>
+    <string name="attachToContact">"Contact icon"</string>
+    <string name="customLabelPickerTitle">"Custom label"</string>
+    <string name="menu_displayGroup">"Display group"</string>
+    <string name="syncGroupPreference">"Sync groups"</string>
+    <string name="importFromSim">"Import from SIM card"</string>
+    <string name="alphabet">" ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
+    <string name="send_to_voicemail_checkbox">"Send calls directly to voicemail."</string>
+    <string name="send_to_voicemail_view">"Calls are sent directly to voicemail."</string>
+    <string name="default_ringtone">"Default"</string>
+    <string name="addPicture">"Add icon"</string>
+    <string name="removePicture">"Remove icon"</string>
+    <string name="noContacts">"No contacts."</string>
+    <string name="noContactsWithPhoneNumbers">"No contacts with phone numbers."</string>
+    <string name="noFavorites">"No favourites."</string>
+    <string name="select_group_title">"Select group to display"</string>
+    <string name="groupEmpty">"Your \"<xliff:g id="GROUPNAME">%s</xliff:g>\" group is empty."</string>
+    <string name="showAllGroups">"All contacts"</string>
+    <string name="syncAllGroups">"Sync all contacts"</string>
+    <string name="groupNameMyContacts">"My Contacts"</string>
+    <string name="groupNameWithPhones">"Contacts with phone numbers"</string>
+    <string name="contactCreatedToast">"Contact created."</string>
+    <string name="contactSavedToast">"Contact saved."</string>
+    <string name="listSeparatorCallNumber">"Dial number"</string>
+    <string name="listSeparatorSendSmsMms">"Send SMS/MMS"</string>
+    <string name="listSeparatorSendEmail">"Send email"</string>
+    <string name="listSeparatorSendIm">"Send instant message"</string>
+    <string name="listSeparatorMapAddress">"Map address"</string>
+    <string name="listSeparatorOrganizations">"Organisations"</string>
+    <string name="listSeparatorOtherInformation">"Other information"</string>
+    <string name="contactsIconLabel">"Contacts"</string>
+    <string name="contactsFavoritesLabel">"Favourites"</string>
+    <string name="dialerIconLabel">"Dialer"</string>
+    <string name="recentCallsIconLabel">"Call log"</string>
+    <!-- no translation found for liveFolderAll (5991510762804226223) -->
+    <skip />
+    <!-- no translation found for liveFolderFavorites (8755759874416875970) -->
+    <skip />
+    <!-- no translation found for liveFolderPhone (3440101264360244544) -->
+    <skip />
+    <string name="menu_sendTextMessage">"Send SMS message"</string>
+    <!-- unknown placeholder WHO in recentCalls_callNumber -->
+    <skip />
+    <string name="recentCalls_editNumberBeforeCall">"Edit number before call"</string>
+    <string name="recentCalls_addToContact">"Add to contacts"</string>
+    <string name="recentCalls_removeFromRecentList">"Remove from call log"</string>
+    <string name="recentCalls_deleteAll">"Clear call log"</string>
+    <string name="recentCalls_empty">"Call log is empty."</string>
+    <string name="imei">"IMEI"</string>
+    <string name="voicemail">"Voicemail"</string>
+    <string name="unknown">"Unknown"</string>
+    <string name="private_num">"Private number"</string>
+    <string name="dialerKeyboardHintText">"Use keyboard to dial"</string>
+    <string name="simContacts_emptyLoading">"Loading from SIM card…"</string>
+    <string name="simContacts_title">"SIM card contacts"</string>
+    <!-- no translation found for contactsSyncPlug (1549212649158409469) -->
+    <skip />
+    <!-- no translation found for noContactsHelpText (6155730972704522463) -->
+    <skip />
+    <!-- no translation found for seclectSyncGroups_title (7675331949118054911) -->
+    <skip />
+    <!-- no translation found for liveFolder_all_label (3716551598022430019) -->
+    <skip />
+    <!-- no translation found for liveFolder_favorites_label (9053985659909059395) -->
+    <skip />
+    <!-- no translation found for liveFolder_phones_label (8943901400107401868) -->
+    <skip />
 </resources>
diff --git a/res/values-es-rUS/strings.xml b/res/values-es-rUS/strings.xml
index db7617e..2f8a286 100644
--- a/res/values-es-rUS/strings.xml
+++ b/res/values-es-rUS/strings.xml
@@ -1,124 +1,177 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="addPicture">Agregar icono</string>
-  <string name="allContacts">Todos los contactos</string>
-  <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-  <string name="attachToContact">Icono de Contacto</string>
-  <string name="button_discard">Rechazar cambios</string>
-  <string name="button_save">Guardar</string>
-  <string name="cancelButtonText">Cancelar</string>
-  <string name="contactCreatedToast">Contacto creado.</string>
-  <string name="contactSavedToast">Contacto guardado.</string>
-  <string name="contactsFavoritesLabel">Favoritos</string>
-  <string name="contactsIconLabel">Contactos</string>
-  <string name="contactsList">Contactos</string>
-  <string name="customLabelPickerTitle">Etiqueta personalizada</string>
-  <string name="default_ringtone">Predeterminado</string>
-  <string name="deleteConfirmation">Se eliminará este contacto.</string>
-  <string name="deleteConfirmation_title">Eliminar</string>
-  <string name="dialerIconLabel">Marcador</string>
-  <string name="dialerKeyboardHintText">Utilizar teclado para marcar</string>
-  <string name="doneButton">Listo</string>
-  <string name="editContactDescription">Editar contacto</string>
-  <string name="editContact_title_edit">Editar contacto</string>
-  <string name="editContact_title_insert">Nuevo contacto</string>
-  <string name="emailLabelsGroup">Correo electrónico</string>
-  <string name="errorDialogTitle">Ninguna imagen</string>
-  <string name="frequentList">Frecuente</string>
-  <string name="ghostData_company">Organización</string>
-  <string name="ghostData_email">Dirección de correo electrónico</string>
-  <string name="ghostData_im">Nombre MI</string>
-  <string name="ghostData_name">Nombre y apellido</string>
-  <string name="ghostData_notes">Mi nota</string>
-  <string name="ghostData_phone">Número de teléfono</string>
-  <string name="ghostData_postal">Dirección postal</string>
-  <string name="ghostData_title">Puesto</string>
-  <string name="groupEmpty">Su \"<xliff:g id="groupName">%s</xliff:g>\" grupo está vacío.</string>
-  <string name="groupNameMyContacts">Mis contactos</string>
-  <string name="groupNameWithPhones">Contactos con números de teléfono</string>
-  <string name="imLabelsGroup">MI</string>
-  <string name="imei">IMEI</string>
-  <string name="importFromSim">Importador de contactos de la SIM</string>
-  <string name="insertContactDescription">Crear contacto</string>
-  <string name="invalidContactMessage">El contacto no existe. </string>
-  <string name="label_company">Organización</string>
-  <string name="label_notes">Notas</string>
-  <string name="label_ringtone">Tono de timbre</string>
-  <string name="label_title">Título</string>
-  <string name="listSeparatorCallNumber">Marcar número</string>
-  <string name="listSeparatorMapAddress">Dirección en el mapa</string>
-  <string name="listSeparatorOrganizations">Organizaciones</string>
-  <string name="listSeparatorOtherInformation">Otra información</string>
-  <string name="listSeparatorSendEmail">Enviar correo electrónico</string>
-  <string name="listSeparatorSendIm">Enviar mensaje instantáneo</string>
-  <string name="listSeparatorSendSmsMms">Enviar SMS/MMS</string>
-  <string name="menu_addItem">Más información</string>
-  <string name="menu_addStar">Agregar a favoritos</string>
-  <string name="menu_call">Llamar</string>
-  <string name="menu_callNumber">Llamar a <xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">Eliminar contacto</string>
-  <string name="menu_dialer">Marcador</string>
-  <string name="menu_displayGroup">Mostrar grupo</string>
-  <string name="menu_doNotSave">Rechazar cambios</string>
-  <string name="menu_done">Guardar</string>
-  <string name="menu_editContact">Editar contacto</string>
-  <string name="menu_editNumberBeforeCall">Editar número antes de llamar</string>
-  <string name="menu_makeDefaultNumber">Convertir en número predeterminado</string>
-  <string name="menu_newContact">Nuevo contacto</string>
-  <string name="menu_newFavortie">Nuevo favorito</string>
-  <string name="menu_preferences">Configuración</string>
-  <string name="menu_removeStar">Quitar de favoritos</string>
-  <string name="menu_sendEmail">Enviar correo electrónico</string>
-  <string name="menu_sendSMS">Enviar SMS/MMS</string>
-  <string name="menu_sendTextMessage">Enviar mensaje SMS </string>
-  <string name="menu_viewAddress">Dirección en el mapa</string>
-  <string name="menu_viewContact">Ver contacto</string>
-  <string name="noButton">Cancelar</string>
-  <string name="noContacts">No hay contactos. </string>
-  <string name="noContactsWithPhoneNumbers">Sin contactos con números de teléfono. </string>
-  <string name="noFavorites">Sin favoritos.</string>
-  <string name="no_imei">IMEI desconocido</string>
-  <string name="ok">Aceptar</string>
-  <string name="okButtonText">Aceptar</string>
-  <string name="otherLabelsGroup">Otros</string>
-  <string name="phoneIconLabel">Teléfono</string>
-  <string name="phoneLabelsGroup">Teléfono</string>
-  <string name="photoPickerNotFoundText">No se dispone de imágenes en el teléfono. </string>
-  <string name="pickerNewContactHeader">Crear nuevo contacto</string>
-  <string name="postalLabelsGroup">Dirección postal</string>
-  <string name="private_num">Número privado</string>
-  <string name="recentCallsIconLabel">Registro de llamadas</string>
-  <string name="recentCalls_addToContact">Agregar a contactos</string>
-  <string name="recentCalls_callNumber">Llamar a <xliff:g id="who">%s</xliff:g></string>
-  <string name="recentCalls_deleteAll">Borrar registro de llamadas</string>
-  <string name="recentCalls_editNumberBeforeCall">Editar número antes de llamar</string>
-  <string name="recentCalls_empty">El registro de la llamada está vacío.</string>
-  <string name="recentCalls_removeFromRecentList">Eliminar del registro de llamadas</string>
-  <string name="removePicture">Eliminar icono</string>
-  <string name="searchHint">Buscar contactos</string>
-  <string name="selectGroupsToSync">Grupos de sincronización</string>
-  <string name="selectLabel">Seleccionar etiqueta</string>
-  <string name="select_group_title">Seleccionar grupo a visualizar</string>
-  <string name="send_to_voicemail_checkbox">Enviar las llamadas directamente al correo de voz.</string>
-  <string name="send_to_voicemail_view">Las llamadas se envían directamente al correo de voz.</string>
-  <string name="shortcutContact">Contacto</string>
-  <string name="showAllGroups">Todos los contactos</string>
-  <string name="showingGroupTitle">
-					<xliff:g id="groupName">%s</xliff:g>
-				</string>
-  <string name="simContacts_emptyLoading">Cargando de tarjeta SIM\u2026</string>
-  <string name="simContacts_title">Contactos de la tarjeta SIM</string>
-  <string name="sms_entry_label">Enviar SMS/MMS</string>
-  <string name="starredList">Con estrella</string>
-  <string name="strequentList">Favoritos</string>
-  <string name="syncAllGroups">Sincronizar todos los contactos</string>
-  <string name="syncGroupChooserTitle">Seleccionar grupos a sincronizar</string>
-  <string name="syncGroupPreference">Grupos de sincronización</string>
-  <string name="syncGroupPreference_summary">Seleccionar grupos a sincronizar</string>
-  <string name="unknown">Desconocido</string>
-  <string name="viewContactDesription">Ver contacto</string>
-  <string name="viewContactTitle">Detalles del contacto</string>
-  <string name="voicemail">Correo de voz</string>
-  <string name="yesButton">Aceptar</string>
+    <string name="contactsList">"Contactos"</string>
+    <!-- no translation found for shortcutContact (1520089872483067797) -->
+    <skip />
+    <string name="starredList">"Con estrella"</string>
+    <string name="frequentList">"Frecuente"</string>
+    <string name="strequentList">"Favoritos"</string>
+    <!-- no translation found for viewContactTitle (5340316765801746261) -->
+    <skip />
+    <!-- no translation found for viewContactDesription (5593543465183236254) -->
+    <skip />
+    <!-- no translation found for editContactDescription (207393633337592309) -->
+    <skip />
+    <!-- no translation found for insertContactDescription (8392185611221432248) -->
+    <skip />
+    <string name="searchHint">"Buscar contactos"</string>
+    <string name="menu_newContact">"Nuevo contacto"</string>
+    <string name="menu_viewContact">"Ver contacto"</string>
+    <!-- unknown placeholder CONTACT in menu_callNumber -->
+    <skip />
+    <string name="menu_addStar">"Agregar estrella"</string>
+    <string name="menu_removeStar">"Quitar estrella"</string>
+    <!-- no translation found for menu_showBarcode (4627916987700748636) -->
+    <skip />
+    <string name="menu_editContact">"Editar contacto"</string>
+    <string name="menu_deleteContact">"Eliminar contacto"</string>
+    <string name="menu_call">"Llamar"</string>
+    <string name="menu_sendSMS">"Enviar texto"</string>
+    <string name="menu_sendEmail">"Enviar correo electrónico"</string>
+    <string name="menu_viewAddress">"Dirección en el mapa"</string>
+    <string name="menu_makeDefaultNumber">"Convertir en número predeterminado"</string>
+    <!-- no translation found for deleteConfirmation_title (1628057421142368583) -->
+    <skip />
+    <string name="deleteConfirmation">"¿Eliminar este contacto?"</string>
+    <string name="menu_done">"Guardar"</string>
+    <string name="menu_doNotSave">"Rechazar cambios"</string>
+    <string name="button_save">"Guardar"</string>
+    <string name="button_discard">"Rechazar cambios"</string>
+    <string name="editContact_title_edit">"Editar contacto"</string>
+    <string name="editContact_title_insert">"Nuevo contacto"</string>
+    <string name="menu_addItem">"Agregar más"</string>
+    <string name="label_notes">"Notas"</string>
+    <!-- no translation found for label_ringtone (1269538172838343970) -->
+    <skip />
+    <string name="ghostData_name">"Nombre y apellido"</string>
+    <string name="ghostData_company">"Organización"</string>
+    <string name="ghostData_title">"Puesto"</string>
+    <string name="ghostData_im">"Nombre MI"</string>
+    <string name="ghostData_notes">"Mi nota"</string>
+    <string name="ghostData_phone">"Número de teléfono"</string>
+    <string name="ghostData_email">"Dirección de correo electrónico"</string>
+    <!-- unknown placeholder BREAK_0 in ghostData_postal -->
+    <skip />
+    <string name="invalidContactMessage">"Los contactos deben tener nombres"</string>
+    <string name="pickerNewContactHeader">"Crear nuevo contacto"</string>
+    <string name="selectLabel">"Seleccionar etiqueta"</string>
+    <string name="phoneLabelsGroup">"Teléfono"</string>
+    <string name="emailLabelsGroup">"C. electrónico"</string>
+    <string name="imLabelsGroup">"MI"</string>
+    <string name="postalLabelsGroup">"Dirección postal"</string>
+    <string name="otherLabelsGroup">"Otros"</string>
+    <!-- no translation found for otherLabels:0 (3318569574569948132) -->
+    <!-- no translation found for otherLabels:1 (3325413568383685728) -->
+    <string name="errorDialogTitle">"¡Atención!"</string>
+    <string name="photoPickerNotFoundText">"Ninguna imagen disponible."</string>
+    <string name="attachToContact">"Foto de los contactos"</string>
+    <string name="customLabelPickerTitle">"Etiqueta personalizada"</string>
+    <!-- no translation found for menu_displayGroup (2835746769742496686) -->
+    <skip />
+    <!-- no translation found for syncGroupPreference (759121296595419145) -->
+    <skip />
+    <string name="importFromSim">"Importar de tarjeta SIM"</string>
+    <!-- no translation found for alphabet (4977128516779796464) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_checkbox (1699633783417579410) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_view (4299389800446371057) -->
+    <skip />
+    <!-- no translation found for default_ringtone (3998437793418131562) -->
+    <skip />
+    <!-- no translation found for addPicture (7010902051370875352) -->
+    <skip />
+    <!-- no translation found for removePicture (2322840177008417519) -->
+    <skip />
+    <!-- no translation found for noContacts (7515781671301309298) -->
+    <skip />
+    <!-- no translation found for noContactsWithPhoneNumbers (3105170743499016241) -->
+    <skip />
+    <!-- no translation found for noFavorites (7957536428532225634) -->
+    <skip />
+    <!-- no translation found for select_group_title (8821785850959403592) -->
+    <skip />
+    <!-- no translation found for groupEmpty (1733723844723885242) -->
+    <skip />
+    <!-- no translation found for showAllGroups (4524662887308889400) -->
+    <skip />
+    <!-- no translation found for syncAllGroups (8415112909188430211) -->
+    <skip />
+    <!-- no translation found for groupNameMyContacts (1298661863710879264) -->
+    <skip />
+    <!-- no translation found for groupNameWithPhones (4051877952712463294) -->
+    <skip />
+    <!-- no translation found for contactCreatedToast (5309869712901550955) -->
+    <skip />
+    <!-- no translation found for contactSavedToast (1228932477738680325) -->
+    <skip />
+    <!-- no translation found for listSeparatorCallNumber (9142725721395758026) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendSmsMms (8878062000446372333) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendEmail (3813935531061488274) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendIm (3885045096980470847) -->
+    <skip />
+    <!-- no translation found for listSeparatorMapAddress (7749519405208811410) -->
+    <skip />
+    <!-- no translation found for listSeparatorOrganizations (5731454670822188295) -->
+    <skip />
+    <!-- no translation found for listSeparatorOtherInformation (3399084175925138065) -->
+    <skip />
+    <!-- no translation found for contactsIconLabel (392729648321810378) -->
+    <skip />
+    <!-- no translation found for contactsFavoritesLabel (6274307000699136596) -->
+    <skip />
+    <!-- no translation found for dialerIconLabel (396765298398417139) -->
+    <skip />
+    <!-- no translation found for recentCallsIconLabel (7432201162713288826) -->
+    <skip />
+    <!-- no translation found for liveFolderAll (5991510762804226223) -->
+    <skip />
+    <!-- no translation found for liveFolderFavorites (8755759874416875970) -->
+    <skip />
+    <!-- no translation found for liveFolderPhone (3440101264360244544) -->
+    <skip />
+    <!-- no translation found for menu_sendTextMessage (3055919380461974147) -->
+    <skip />
+    <!-- no translation found for recentCalls_callNumber (924407199258234369) -->
+    <skip />
+    <!-- no translation found for recentCalls_editNumberBeforeCall (7859145185424954030) -->
+    <skip />
+    <!-- no translation found for recentCalls_addToContact (6950267092567953305) -->
+    <skip />
+    <!-- no translation found for recentCalls_removeFromRecentList (5273789011391059975) -->
+    <skip />
+    <!-- no translation found for recentCalls_deleteAll (425798199678070888) -->
+    <skip />
+    <!-- no translation found for recentCalls_empty (7787624895504983911) -->
+    <skip />
+    <!-- no translation found for imei (1052536402066249452) -->
+    <skip />
+    <!-- no translation found for voicemail (1135686231023059817) -->
+    <skip />
+    <!-- no translation found for unknown (6231893925212017656) -->
+    <skip />
+    <!-- no translation found for private_num (3065614133902647350) -->
+    <skip />
+    <!-- no translation found for dialerKeyboardHintText (2013777173021862941) -->
+    <skip />
+    <!-- no translation found for simContacts_emptyLoading (4828419758306519589) -->
+    <skip />
+    <!-- no translation found for simContacts_title (4162577066960174009) -->
+    <skip />
+    <!-- no translation found for contactsSyncPlug (1549212649158409469) -->
+    <skip />
+    <!-- no translation found for noContactsHelpText (6155730972704522463) -->
+    <skip />
+    <!-- no translation found for seclectSyncGroups_title (7675331949118054911) -->
+    <skip />
+    <!-- no translation found for liveFolder_all_label (3716551598022430019) -->
+    <skip />
+    <!-- no translation found for liveFolder_favorites_label (9053985659909059395) -->
+    <skip />
+    <!-- no translation found for liveFolder_phones_label (8943901400107401868) -->
+    <skip />
 </resources>
diff --git a/res/values-fr-rFR/strings.xml b/res/values-fr-rFR/strings.xml
deleted file mode 100644
index 649348f..0000000
--- a/res/values-fr-rFR/strings.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="addPicture">Ajouter une icône</string>
-  <string name="allContacts">Tous les contacts</string>
-  <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-  <string name="attachToContact">Icône de contact</string>
-  <string name="button_discard">Abandonner les modifications</string>
-  <string name="button_save">Enregistrer</string>
-  <string name="cancelButtonText">Annuler</string>
-  <string name="contactCreatedToast">Contact créé.</string>
-  <string name="contactSavedToast">Contact enregistré.</string>
-  <string name="contactsFavoritesLabel">Favoris</string>
-  <string name="contactsIconLabel">Contacts</string>
-  <string name="contactsList">Contacts</string>
-  <string name="customLabelPickerTitle">Étiquette personnalisée</string>
-  <string name="default_ringtone">Par défaut</string>
-  <string name="deleteConfirmation">Ce contact sera supprimé.</string>
-  <string name="deleteConfirmation_title">Supprimer</string>
-  <string name="dialerIconLabel">Numéroteur</string>
-  <string name="dialerKeyboardHintText">Utiliser le clavier pour numéroter</string>
-  <string name="doneButton">Terminé</string>
-  <string name="editContactDescription">Modifier le contact</string>
-  <string name="editContact_title_edit">Modifier le contact</string>
-  <string name="editContact_title_insert">Nouveau contact</string>
-  <string name="emailLabelsGroup">Email</string>
-  <string name="errorDialogTitle">Aucune image</string>
-  <string name="frequentList">Fréquent</string>
-  <string name="ghostData_company">Société</string>
-  <string name="ghostData_email">Adresse de messagerie</string>
-  <string name="ghostData_im">Nom IM</string>
-  <string name="ghostData_name">Prénom et Nom</string>
-  <string name="ghostData_notes">Ma note</string>
-  <string name="ghostData_phone">Numéro de téléphone</string>
-  <string name="ghostData_postal">Adresse postale</string>
-  <string name="ghostData_title">Position</string>
-  <string name="groupEmpty">Votre groupe \"<xliff:g id="groupName">%s</xliff:g>\" est vide.</string>
-  <string name="groupNameMyContacts">Mes contacts</string>
-  <string name="groupNameWithPhones">Contacts avec numéros de téléphone</string>
-  <string name="imLabelsGroup">IM</string>
-  <string name="imei">IMEI</string>
-  <string name="importFromSim">Importateur de contacts SIM</string>
-  <string name="insertContactDescription">Créer un contact</string>
-  <string name="invalidContactMessage">Le contact n\'existe pas.</string>
-  <string name="label_company">Société</string>
-  <string name="label_notes">Notes</string>
-  <string name="label_ringtone">Sonnerie</string>
-  <string name="label_title">Titre</string>
-  <string name="listSeparatorCallNumber">Composer le numéro</string>
-  <string name="listSeparatorMapAddress">Adresse carte</string>
-  <string name="listSeparatorOrganizations">Organisations</string>
-  <string name="listSeparatorOtherInformation">Autres informations</string>
-  <string name="listSeparatorSendEmail">Envoyer e-mail</string>
-  <string name="listSeparatorSendIm">Envoyer message instantané</string>
-  <string name="listSeparatorSendSmsMms">Envoyer SMS/MMS</string>
-  <string name="menu_addItem">Plus d\'infos</string>
-  <string name="menu_addStar">Ajouter aux favoris</string>
-  <string name="menu_call">Appeler</string>
-  <string name="menu_callNumber">Appeler <xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">Supprimer le contact</string>
-  <string name="menu_dialer">Numéroteur</string>
-  <string name="menu_displayGroup">Afficher le groupe</string>
-  <string name="menu_doNotSave">Abandonner les modifications</string>
-  <string name="menu_done">Enregistrer</string>
-  <string name="menu_editContact">Modifier le contact</string>
-  <string name="menu_editNumberBeforeCall">Modifier le numéro avant l\'appel</string>
-  <string name="menu_makeDefaultNumber">Définir numéro par défaut</string>
-  <string name="menu_newContact">Nouveau contact</string>
-  <string name="menu_newFavortie">Nouveau favori</string>
-  <string name="menu_preferences">Paramètres</string>
-  <string name="menu_removeStar">Supprimer des favoris</string>
-  <string name="menu_sendEmail">Envoyer e-mail</string>
-  <string name="menu_sendSMS">Envoyer SMS/MMS</string>
-  <string name="menu_sendTextMessage">Envoyer SMS</string>
-  <string name="menu_viewAddress">Adresse carte</string>
-  <string name="menu_viewContact">Afficher le contact</string>
-  <string name="noButton">Annuler</string>
-  <string name="noContacts">Aucun contact.</string>
-  <string name="noContactsWithPhoneNumbers">Aucun contact avec numéros de téléphone.</string>
-  <string name="noFavorites">Aucun favori.</string>
-  <string name="no_imei">IMEI inconnu</string>
-  <string name="ok">OK</string>
-  <string name="okButtonText">OK</string>
-  <string name="otherLabelsGroup">Autre</string>
-  <string name="phoneIconLabel">Téléphone</string>
-  <string name="phoneLabelsGroup">Téléphone</string>
-  <string name="photoPickerNotFoundText">Aucune image disponible sur le téléphone.</string>
-  <string name="pickerNewContactHeader">Créer un nouveau contact</string>
-  <string name="postalLabelsGroup">Adresse postale</string>
-  <string name="private_num">Numéro privé</string>
-  <string name="recentCallsIconLabel">Journal d\'appel</string>
-  <string name="recentCalls_addToContact">Ajouter aux contacts</string>
-  <string name="recentCalls_callNumber">Appeler <xliff:g id="who">%s</xliff:g></string>
-  <string name="recentCalls_deleteAll">Effacer le journal d\'appel</string>
-  <string name="recentCalls_editNumberBeforeCall">Modifier le numéro avant l\'appel</string>
-  <string name="recentCalls_empty">Le journal d\'appel est vide.</string>
-  <string name="recentCalls_removeFromRecentList">Supprimer du journal d\'appel</string>
-  <string name="removePicture">Supprimer l\'icône</string>
-  <string name="searchHint">Rechercher les contacts</string>
-  <string name="selectGroupsToSync">Synchroniser les groupes</string>
-  <string name="selectLabel">Sélectionner étiquette</string>
-  <string name="select_group_title">Sélectionner un groupe à afficher</string>
-  <string name="send_to_voicemail_checkbox">Envoyez les appels directement à la messagerie.</string>
-  <string name="send_to_voicemail_view">Les appels sont envoyés directement à la messagerie.</string>
-  <string name="shortcutContact">Contact</string>
-  <string name="showAllGroups">Tous les contacts</string>
-  <string name="showingGroupTitle">
-					<xliff:g id="groupName">%s</xliff:g>
-				</string>
-  <string name="simContacts_emptyLoading">Chargement depuis la carte SIM\u2026</string>
-  <string name="simContacts_title">Contacts de la carte SIM</string>
-  <string name="sms_entry_label">Envoyer SMS/MMS</string>
-  <string name="starredList">Étoilé</string>
-  <string name="strequentList">Favoris</string>
-  <string name="syncAllGroups">Synchroniser tous les contacts</string>
-  <string name="syncGroupChooserTitle">Sélectionner les groupes à synchroniser</string>
-  <string name="syncGroupPreference">Synchroniser les groupes</string>
-  <string name="syncGroupPreference_summary">Sélectionner les groupes à synchroniser</string>
-  <string name="unknown">Inconnu</string>
-  <string name="viewContactDesription">Afficher le contact</string>
-  <string name="viewContactTitle">Détails du contact</string>
-  <string name="voicemail">Messagerie vocale</string>
-  <string name="yesButton">OK</string>
-</resources>
diff --git a/res/values-it-rIT/strings.xml b/res/values-it-rIT/strings.xml
deleted file mode 100644
index 24e3e17..0000000
--- a/res/values-it-rIT/strings.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="addPicture">Aggiungi icona</string>
-  <string name="allContacts">Tutti i contatti</string>
-  <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-  <string name="attachToContact">Icona Contatti</string>
-  <string name="button_discard">Ignora modifiche</string>
-  <string name="button_save">Salva</string>
-  <string name="cancelButtonText">Annulla</string>
-  <string name="contactCreatedToast">Creazione contatto completata.</string>
-  <string name="contactSavedToast">Salvataggio contatto completato.</string>
-  <string name="contactsFavoritesLabel">Preferiti</string>
-  <string name="contactsIconLabel">Contatti</string>
-  <string name="contactsList">Contatti</string>
-  <string name="customLabelPickerTitle">Etichetta personalizzata</string>
-  <string name="default_ringtone">Predefinito</string>
-  <string name="deleteConfirmation">Il contatto verrà eliminato.</string>
-  <string name="deleteConfirmation_title">Elimina</string>
-  <string name="dialerIconLabel">Dialer</string>
-  <string name="dialerKeyboardHintText">Utilizzare la tastiera per comporre il numero</string>
-  <string name="doneButton">Completato</string>
-  <string name="editContactDescription">Modifica contatto</string>
-  <string name="editContact_title_edit">Modifica contatto</string>
-  <string name="editContact_title_insert">Nuovo contatto</string>
-  <string name="emailLabelsGroup">Email</string>
-  <string name="errorDialogTitle">Nessuna immagine</string>
-  <string name="frequentList">Frequente</string>
-  <string name="ghostData_company">Società</string>
-  <string name="ghostData_email">Indirizzo e-mail</string>
-  <string name="ghostData_im">Nome IM</string>
-  <string name="ghostData_name">Nome e cognome</string>
-  <string name="ghostData_notes">Nota</string>
-  <string name="ghostData_phone">Numero di telefono</string>
-  <string name="ghostData_postal">Indirizzo postale</string>
-  <string name="ghostData_title">Posizione</string>
-  <string name="groupEmpty">Il gruppo \"<xliff:g id="groupName">%s</xliff:g>\" è vuoto.</string>
-  <string name="groupNameMyContacts">Contatti</string>
-  <string name="groupNameWithPhones">Contatti con numeri di telefono</string>
-  <string name="imLabelsGroup">IM</string>
-  <string name="imei">IMEI</string>
-  <string name="importFromSim">Importazione contati SIM</string>
-  <string name="insertContactDescription">Crea contatto</string>
-  <string name="invalidContactMessage">Il contatto non esiste.</string>
-  <string name="label_company">Società</string>
-  <string name="label_notes">Note</string>
-  <string name="label_ringtone">Suoneria</string>
-  <string name="label_title">Posizione</string>
-  <string name="listSeparatorCallNumber">Componi numero</string>
-  <string name="listSeparatorMapAddress">Indirizzo su cartina</string>
-  <string name="listSeparatorOrganizations">Organizzazioni</string>
-  <string name="listSeparatorOtherInformation">Altre informazioni</string>
-  <string name="listSeparatorSendEmail">Invia messaggio e-mail</string>
-  <string name="listSeparatorSendIm">Invia messaggio immediato</string>
-  <string name="listSeparatorSendSmsMms">Invia SMS/MMS</string>
-  <string name="menu_addItem">Ulteriori informazioni</string>
-  <string name="menu_addStar">Aggiungi a Preferiti</string>
-  <string name="menu_call">Chiama</string>
-  <string name="menu_callNumber">Chiama <xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">Elimina contatto</string>
-  <string name="menu_dialer">Dialer</string>
-  <string name="menu_displayGroup">Visualizza gruppo</string>
-  <string name="menu_doNotSave">Ignora modifiche</string>
-  <string name="menu_done">Salva</string>
-  <string name="menu_editContact">Modifica contatto</string>
-  <string name="menu_editNumberBeforeCall">Modifica numero prima di chiamare</string>
-  <string name="menu_makeDefaultNumber">Imposta come numero predefinito</string>
-  <string name="menu_newContact">Nuovo contatto</string>
-  <string name="menu_newFavortie">Nuovo preferito</string>
-  <string name="menu_preferences">Impostazioni</string>
-  <string name="menu_removeStar">Rimuovi da Preferiti</string>
-  <string name="menu_sendEmail">Invia messaggio e-mail</string>
-  <string name="menu_sendSMS">Invia SMS/MMS</string>
-  <string name="menu_sendTextMessage">Invia messaggio SMS</string>
-  <string name="menu_viewAddress">Indirizzo su cartina</string>
-  <string name="menu_viewContact">Visualizza contatto</string>
-  <string name="noButton">Annulla</string>
-  <string name="noContacts">Nessun contatto.</string>
-  <string name="noContactsWithPhoneNumbers">Nessun contatto con numeri di telefono.</string>
-  <string name="noFavorites">Nessun preferito.</string>
-  <string name="no_imei">IMEI sconosciuto</string>
-  <string name="ok">OK</string>
-  <string name="okButtonText">OK</string>
-  <string name="otherLabelsGroup">Altro</string>
-  <string name="phoneIconLabel">Telefono</string>
-  <string name="phoneLabelsGroup">Telefono</string>
-  <string name="photoPickerNotFoundText">Nessuna immagine disponibile sul telefono.</string>
-  <string name="pickerNewContactHeader">Crea nuovo contatto</string>
-  <string name="postalLabelsGroup">Indirizzo postale</string>
-  <string name="private_num">Numero privato</string>
-  <string name="recentCallsIconLabel">Registro chiamate</string>
-  <string name="recentCalls_addToContact">Aggiungi a Contatti</string>
-  <string name="recentCalls_callNumber">Chiama <xliff:g id="who">%s</xliff:g></string>
-  <string name="recentCalls_deleteAll">Cancella registro chiamate</string>
-  <string name="recentCalls_editNumberBeforeCall">Modifica numero prima di chiamare</string>
-  <string name="recentCalls_empty">Il registro chiamate è vuoto.</string>
-  <string name="recentCalls_removeFromRecentList">Rimuovi da registro chiamate</string>
-  <string name="removePicture">Icona Rimuovi</string>
-  <string name="searchHint">Cerca contatti</string>
-  <string name="selectGroupsToSync">Sincronizza gruppi</string>
-  <string name="selectLabel">Seleziona etichetta</string>
-  <string name="select_group_title">Seleziona gruppo da visualizzare</string>
-  <string name="send_to_voicemail_checkbox">Invia le chiamate direttamente alla casella vocale.</string>
-  <string name="send_to_voicemail_view">Le chiamate vengono inviate direttamente alla casella vocale.</string>
-  <string name="shortcutContact">Contatto</string>
-  <string name="showAllGroups">Tutti i contatti</string>
-  <string name="showingGroupTitle">
-					<xliff:g id="groupName">%s</xliff:g>
-				</string>
-  <string name="simContacts_emptyLoading">Caricamento dalla scheda SIM in corso\u2026</string>
-  <string name="simContacts_title">Contatti scheda SIM</string>
-  <string name="sms_entry_label">Invia SMS/MMS</string>
-  <string name="starredList">Primo piano</string>
-  <string name="strequentList">Preferiti</string>
-  <string name="syncAllGroups">Sincronizza tutti i contatti</string>
-  <string name="syncGroupChooserTitle">Selezionare i gruppi da sincronizzare</string>
-  <string name="syncGroupPreference">Sincronizza gruppi</string>
-  <string name="syncGroupPreference_summary">Selezionare i gruppi da sincronizzare</string>
-  <string name="unknown">Sconosciuto</string>
-  <string name="viewContactDesription">Visualizza contatto</string>
-  <string name="viewContactTitle">Dettagli contatto</string>
-  <string name="voicemail">Posta vocale</string>
-  <string name="yesButton">OK</string>
-</resources>
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
new file mode 100644
index 0000000..cb8c49c
--- /dev/null
+++ b/res/values-ja/strings.xml
@@ -0,0 +1,135 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<resources xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
+    <string name="contactsList">"連絡先"</string>
+    <string name="shortcutContact">"連絡先"</string>
+    <string name="starredList">"スター付き"</string>
+    <string name="frequentList">"よく連絡する連絡先"</string>
+    <string name="strequentList">"お気に入り"</string>
+    <string name="viewContactTitle">"連絡先情報"</string>
+    <string name="viewContactDesription">"連絡先を表示"</string>
+    <string name="editContactDescription">"連絡先を編集"</string>
+    <string name="insertContactDescription">"連絡先を作成"</string>
+    <string name="searchHint">"連絡先を検索"</string>
+    <string name="menu_newContact">"新しい連絡先"</string>
+    <string name="menu_viewContact">"連絡先を表示"</string>
+    <string name="menu_callNumber">"<xliff:g id="NAME">%s</xliff:g>さんに発信"</string>
+    <!-- no translation found for menu_addStar (2908478235715404876) -->
+    <skip />
+    <!-- no translation found for menu_removeStar (5844227078364227030) -->
+    <skip />
+    <!-- no translation found for menu_showBarcode (309973637178814132) -->
+    <skip />
+    <string name="menu_editContact">"連絡先を編集"</string>
+    <string name="menu_deleteContact">"連絡先を削除"</string>
+    <string name="menu_call">"発信"</string>
+    <string name="menu_sendSMS">"SMS/MMSを送信"</string>
+    <string name="menu_sendEmail">"メールを送信"</string>
+    <string name="menu_viewAddress">"地図の住所"</string>
+    <string name="menu_makeDefaultNumber">"デフォルトの番号に設定"</string>
+    <string name="deleteConfirmation_title">"削除"</string>
+    <string name="deleteConfirmation">"この連絡先を削除します。"</string>
+    <string name="menu_done">"保存"</string>
+    <string name="menu_doNotSave">"変更を破棄"</string>
+    <string name="button_save">"保存"</string>
+    <string name="button_discard">"変更を破棄"</string>
+    <string name="editContact_title_edit">"連絡先を編集"</string>
+    <string name="editContact_title_insert">"新しい連絡先"</string>
+    <string name="menu_addItem">"詳細情報"</string>
+    <string name="label_notes">"メモ"</string>
+    <string name="label_ringtone">"着信音"</string>
+    <string name="ghostData_name">"氏名を入力してください"</string>
+    <string name="ghostData_company">"会社"</string>
+    <string name="ghostData_title">"役職"</string>
+    <string name="ghostData_im">"IM名"</string>
+    <string name="ghostData_notes">"メモ"</string>
+    <string name="ghostData_phone">"電話番号"</string>
+    <string name="ghostData_email">"メールアドレス"</string>
+    <string name="ghostData_postal">"住所"</string>
+    <string name="invalidContactMessage">"連絡先が存在しません。"</string>
+    <string name="pickerNewContactHeader">"新しい連絡先を登録"</string>
+    <string name="selectLabel">"ラベルを選択"</string>
+    <string name="phoneLabelsGroup">"電話番号"</string>
+    <string name="emailLabelsGroup">"メール"</string>
+    <string name="imLabelsGroup">"IM"</string>
+    <string name="postalLabelsGroup">"住所"</string>
+    <string name="otherLabelsGroup">"その他"</string>
+  <string-array name="otherLabels">
+    <item>"組織"</item>
+    <item>"メモ"</item>
+  </string-array>
+    <string name="errorDialogTitle">"写真なし"</string>
+    <string name="photoPickerNotFoundText">"使用できる写真が携帯電話にありません。"</string>
+    <string name="attachToContact">"連絡先のアイコン"</string>
+    <!-- no translation found for customLabelPickerTitle (1081475101983255212) -->
+    <skip />
+    <string name="menu_displayGroup">"グループを表示"</string>
+    <string name="syncGroupPreference">"同期グループを編集"</string>
+    <string name="importFromSim">"連絡先をインポート"</string>
+    <string name="alphabet">"ABCDEFGHIJKLMNOPQRSTUVWXYZ"</string>
+    <string name="send_to_voicemail_checkbox">"着信を直接ボイスメールに転送する"</string>
+    <string name="send_to_voicemail_view">"着信はボイスメールに直接転送されます。"</string>
+    <string name="default_ringtone">"デフォルト"</string>
+    <string name="addPicture">"アイコンを追加"</string>
+    <string name="removePicture">"アイコンを削除"</string>
+    <string name="noContacts">"連絡先がありません。"</string>
+    <string name="noContactsWithPhoneNumbers">"電話番号のある連絡先がありません。"</string>
+    <string name="noFavorites">"お気に入りがありません。"</string>
+    <!-- no translation found for select_group_title (7955698611959835612) -->
+    <skip />
+    <string name="groupEmpty">"「<xliff:g id="GROUPNAME">%s</xliff:g>」グループには何も登録されていません。"</string>
+    <string name="showAllGroups">"すべての連絡先"</string>
+    <string name="syncAllGroups">"全連絡先の同期を取る"</string>
+    <string name="groupNameMyContacts">"連絡先リスト"</string>
+    <string name="groupNameWithPhones">"電話番号のある連絡先"</string>
+    <string name="contactCreatedToast">"連絡先を作成しました。"</string>
+    <string name="contactSavedToast">"連絡先を保存しました。"</string>
+    <string name="listSeparatorCallNumber">"電話をかける"</string>
+    <string name="listSeparatorSendSmsMms">"SMS/MMSを送信"</string>
+    <string name="listSeparatorSendEmail">"メールを送信"</string>
+    <string name="listSeparatorSendIm">"インスタントメッセージを送信"</string>
+    <string name="listSeparatorMapAddress">"地図の住所"</string>
+    <string name="listSeparatorOrganizations">"組織"</string>
+    <string name="listSeparatorOtherInformation">"その他の情報"</string>
+    <string name="contactsIconLabel">"連絡先"</string>
+    <string name="contactsFavoritesLabel">"お気に入り"</string>
+    <string name="dialerIconLabel">"ダイヤラ"</string>
+    <string name="recentCallsIconLabel">"通話ログ"</string>
+    <!-- no translation found for liveFolderAll (4789010460767506206) -->
+    <skip />
+    <!-- no translation found for liveFolderFavorites (3100957542927222282) -->
+    <skip />
+    <!-- no translation found for liveFolderPhone (3739376066610926780) -->
+    <skip />
+    <string name="menu_sendTextMessage">"SMSメッセージを送信"</string>
+    <string name="recentCalls_callNumber">"<xliff:g id="NAME">%s</xliff:g>さんに発信"</string>
+    <string name="recentCalls_editNumberBeforeCall">"番号を編集して発信"</string>
+    <string name="recentCalls_addToContact">"連絡先に追加"</string>
+    <string name="recentCalls_removeFromRecentList">"通話ログを削除"</string>
+    <string name="recentCalls_deleteAll">"すべてのログをクリア"</string>
+    <string name="recentCalls_empty">"通話ログはありません。"</string>
+    <string name="imei">"IMEI"</string>
+    <string name="voicemail">"ボイスメール"</string>
+    <string name="unknown">"不明"</string>
+    <string name="private_num">"非通知番号"</string>
+    <string name="dialerKeyboardHintText">"番号をキーボードから入力してください"</string>
+    <!-- no translation found for dialerDialpadHintText (5824490365898349041) -->
+    <skip />
+    <string name="simContacts_emptyLoading">"SIMカードからロードしています..."</string>
+    <string name="simContacts_title">"SIMカードの連絡先"</string>
+    <string name="contactsSyncPlug"><font fgcolor="#ffffffff">"Googleコンタクトと同期を取ります。"</font>" "\n"同期が終わると、いつでもこの携帯電話で連絡先を使用できます。"</string>
+    <string name="noContactsHelpText">"登録されている連絡先がありません。"\n\n"連絡先を追加するには["<font fgcolor="#ffffffff"><b>"メニュー"</b></font>"]を押して、次のどれかを選択します。"\n\n"        "\n<li>"["<font fgcolor="#ffffffff"><b>"同期グループを編集"</b></font>"]-新規または既存のGoogleアカウントから追加する場合"\n</li>\n"        "\n<li>"["<font fgcolor="#ffffffff"><b>"新しい連絡先"</b></font>"]-最初から新しい連絡先を作成する場合"\n</li>\n"        "\n<li>"["<font fgcolor="#ffffffff"><b>"連絡先をインポート"</b></font>"]-SIMカードから連絡先を追加する場合"\n</li></string>
+    <string name="seclectSyncGroups_title">"同期を取るグループを選択"</string>
+    <!-- no translation found for liveFolder_all_label (1552523730090319259) -->
+    <skip />
+    <!-- no translation found for liveFolder_favorites_label (2674341514070517105) -->
+    <skip />
+    <!-- no translation found for liveFolder_phones_label (1709786878793436245) -->
+    <skip />
+    <!-- no translation found for dialer_useDtmfDialpad (1707548397435075040) -->
+    <skip />
+    <!-- no translation found for dialer_returnToInCallScreen (3719386377550913067) -->
+    <skip />
+    <!-- no translation found for dialer_addAnotherCall (4205688819890074468) -->
+    <skip />
+</resources>
diff --git a/res/values-nl-rNL/strings.xml b/res/values-nl-rNL/strings.xml
index 9955277..09ce1bb 100644
--- a/res/values-nl-rNL/strings.xml
+++ b/res/values-nl-rNL/strings.xml
@@ -1,65 +1,177 @@
-<?xml version="1.0" encoding="utf-8"?>
+<?xml version="1.0" encoding="UTF-8"?>
 <resources xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="attachToContact">Afbeelding contactpersoon </string>
-  <string name="button_discard">Wijzigingen negeren</string>
-  <string name="button_save">Opslaan</string>
-  <string name="cancelButtonText">Annuleren</string>
-  <string name="contactsList">Contacten</string>
-  <string name="continueEditing">Bewerken hervatten</string>
-  <string name="customLabelPickerTitle">Aangepast label</string>
-  <string name="deleteConfirmation">Deze contact verwijderen?</string>
-  <string name="discardChanges">Wijzigingen negeren</string>
-  <string name="displayAllPreference">Alle contacten weergeven</string>
-  <string name="displayAllPreference_summary">Alle contacten weergeven, of alleen die met telefoonnummers</string>
-  <string name="editContact_title_edit">Contact bewerken</string>
-  <string name="editContact_title_insert">Nieuw contact</string>
-  <string name="emailLabelsGroup">E-mail</string>
-  <string name="errorDialogTitle">Let op!</string>
-  <string name="frequentList">Regelmatig</string>
-  <string name="ghostData_company">Bedrijf</string>
-  <string name="ghostData_email">E-mailadres</string>
-  <string name="ghostData_im">IM-naam</string>
-  <string name="ghostData_name">Eerste en laatste</string>
-  <string name="ghostData_notes">Mijn opmerking</string>
-  <string name="ghostData_phone">Telefoonnummer</string>
-  <string name="ghostData_postal">"Straat\nPlaats, staat postcode\nland"</string>
-  <string name="ghostData_title">Positie</string>
-  <string name="imLabelsGroup">Expresbericht</string>
-  <string name="importFromSim">Importeren van sim-kaart</string>
-  <string name="invalidContactMessage">Contacten moeten namen hebben</string>
-  <string name="label_company">Bedrijf</string>
-  <string name="label_notes">Opmerkingen</string>
-  <string name="label_title">Functie</string>
-  <string name="menu_addItem">Meer toevoegen</string>
-  <string name="menu_addStar">Ster toevoegen</string>
-  <string name="menu_call">Bellen</string>
-  <string name="menu_callNumber">Bellen<xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">Contact verwijderen</string>
-  <string name="menu_dialer">Kiezer</string>
-  <string name="menu_doNotSave">Wijzigingen negeren</string>
-  <string name="menu_done">Opslaan</string>
-  <string name="menu_editContact">Contact bewerken</string>
-  <string name="menu_editNumberBeforeCall">Nummer bewerken voor bellen</string>
-  <string name="menu_makeDefaultNumber">Standaardnummer maken</string>
-  <string name="menu_newContact">Nieuw contact</string>
-  <string name="menu_preferences">Instellingen</string>
-  <string name="menu_removeStar">Ster verwijderen</string>
-  <string name="menu_sendEmail">E-mail verzenden</string>
-  <string name="menu_sendSMS">Tekst verzenden</string>
-  <string name="menu_viewAddress">Kaartadres</string>
-  <string name="menu_viewContact">Contact weergeven</string>
-  <string name="noButton">Annuleren</string>
-  <string name="okButtonText">OK</string>
-  <string name="otherLabelsGroup">Overig</string>
-  <string name="phoneLabelsGroup">Telefoon</string>
-  <string name="photoPickerNotFoundText">Geen afbeeldingen beschikbaar.</string>
-  <string name="pickerNewContactHeader">Nieuwe contact maken</string>
-  <string name="postalLabelsGroup">Postadres</string>
-  <string name="searchHint">Contacten zoeken</string>
-  <string name="selectLabel">Label selecteren</string>
-  <string name="sms_entry_label">SMS verzenden</string>
-  <string name="starredList">Met ster</string>
-  <string name="strequentList">Favorieten</string>
-  <string name="yesButton">OK</string>
+    <string name="contactsList">"Contacten"</string>
+    <!-- no translation found for shortcutContact (1520089872483067797) -->
+    <skip />
+    <string name="starredList">"Met ster"</string>
+    <string name="frequentList">"Regelmatig"</string>
+    <string name="strequentList">"Favorieten"</string>
+    <!-- no translation found for viewContactTitle (5340316765801746261) -->
+    <skip />
+    <!-- no translation found for viewContactDesription (5593543465183236254) -->
+    <skip />
+    <!-- no translation found for editContactDescription (207393633337592309) -->
+    <skip />
+    <!-- no translation found for insertContactDescription (8392185611221432248) -->
+    <skip />
+    <string name="searchHint">"Contacten zoeken"</string>
+    <string name="menu_newContact">"Nieuw contact"</string>
+    <string name="menu_viewContact">"Contact weergeven"</string>
+    <!-- unknown placeholder CONTACT in menu_callNumber -->
+    <skip />
+    <string name="menu_addStar">"Ster toevoegen"</string>
+    <string name="menu_removeStar">"Ster verwijderen"</string>
+    <!-- no translation found for menu_showBarcode (4627916987700748636) -->
+    <skip />
+    <string name="menu_editContact">"Contact bewerken"</string>
+    <string name="menu_deleteContact">"Contact verwijderen"</string>
+    <string name="menu_call">"Bellen"</string>
+    <string name="menu_sendSMS">"Tekst verzenden"</string>
+    <string name="menu_sendEmail">"E-mail verzenden"</string>
+    <string name="menu_viewAddress">"Kaartadres"</string>
+    <string name="menu_makeDefaultNumber">"Standaardnummer maken"</string>
+    <!-- no translation found for deleteConfirmation_title (1628057421142368583) -->
+    <skip />
+    <string name="deleteConfirmation">"Deze contact verwijderen?"</string>
+    <string name="menu_done">"Opslaan"</string>
+    <string name="menu_doNotSave">"Wijzigingen negeren"</string>
+    <string name="button_save">"Opslaan"</string>
+    <string name="button_discard">"Wijzigingen negeren"</string>
+    <string name="editContact_title_edit">"Contact bewerken"</string>
+    <string name="editContact_title_insert">"Nieuw contact"</string>
+    <string name="menu_addItem">"Meer toevoegen"</string>
+    <string name="label_notes">"Opmerkingen"</string>
+    <!-- no translation found for label_ringtone (1269538172838343970) -->
+    <skip />
+    <string name="ghostData_name">"Eerste en laatste"</string>
+    <string name="ghostData_company">"Bedrijf"</string>
+    <string name="ghostData_title">"Positie"</string>
+    <string name="ghostData_im">"IM-naam"</string>
+    <string name="ghostData_notes">"Mijn opmerking"</string>
+    <string name="ghostData_phone">"Telefoonnummer"</string>
+    <string name="ghostData_email">"E-mailadres"</string>
+    <!-- unknown placeholder BREAK_0 in ghostData_postal -->
+    <skip />
+    <string name="invalidContactMessage">"Contacten moeten namen hebben"</string>
+    <string name="pickerNewContactHeader">"Nieuwe contact maken"</string>
+    <string name="selectLabel">"Label selecteren"</string>
+    <string name="phoneLabelsGroup">"Telefoon"</string>
+    <string name="emailLabelsGroup">"E-mail"</string>
+    <string name="imLabelsGroup">"Expresbericht"</string>
+    <string name="postalLabelsGroup">"Postadres"</string>
+    <string name="otherLabelsGroup">"Overig"</string>
+    <!-- no translation found for otherLabels:0 (3318569574569948132) -->
+    <!-- no translation found for otherLabels:1 (3325413568383685728) -->
+    <string name="errorDialogTitle">"Let op!"</string>
+    <string name="photoPickerNotFoundText">"Geen afbeeldingen beschikbaar."</string>
+    <string name="attachToContact">"Afbeelding contactpersoon "</string>
+    <string name="customLabelPickerTitle">"Aangepast label"</string>
+    <!-- no translation found for menu_displayGroup (2835746769742496686) -->
+    <skip />
+    <!-- no translation found for syncGroupPreference (759121296595419145) -->
+    <skip />
+    <string name="importFromSim">"Importeren van sim-kaart"</string>
+    <!-- no translation found for alphabet (4977128516779796464) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_checkbox (1699633783417579410) -->
+    <skip />
+    <!-- no translation found for send_to_voicemail_view (4299389800446371057) -->
+    <skip />
+    <!-- no translation found for default_ringtone (3998437793418131562) -->
+    <skip />
+    <!-- no translation found for addPicture (7010902051370875352) -->
+    <skip />
+    <!-- no translation found for removePicture (2322840177008417519) -->
+    <skip />
+    <!-- no translation found for noContacts (7515781671301309298) -->
+    <skip />
+    <!-- no translation found for noContactsWithPhoneNumbers (3105170743499016241) -->
+    <skip />
+    <!-- no translation found for noFavorites (7957536428532225634) -->
+    <skip />
+    <!-- no translation found for select_group_title (8821785850959403592) -->
+    <skip />
+    <!-- no translation found for groupEmpty (1733723844723885242) -->
+    <skip />
+    <!-- no translation found for showAllGroups (4524662887308889400) -->
+    <skip />
+    <!-- no translation found for syncAllGroups (8415112909188430211) -->
+    <skip />
+    <!-- no translation found for groupNameMyContacts (1298661863710879264) -->
+    <skip />
+    <!-- no translation found for groupNameWithPhones (4051877952712463294) -->
+    <skip />
+    <!-- no translation found for contactCreatedToast (5309869712901550955) -->
+    <skip />
+    <!-- no translation found for contactSavedToast (1228932477738680325) -->
+    <skip />
+    <!-- no translation found for listSeparatorCallNumber (9142725721395758026) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendSmsMms (8878062000446372333) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendEmail (3813935531061488274) -->
+    <skip />
+    <!-- no translation found for listSeparatorSendIm (3885045096980470847) -->
+    <skip />
+    <!-- no translation found for listSeparatorMapAddress (7749519405208811410) -->
+    <skip />
+    <!-- no translation found for listSeparatorOrganizations (5731454670822188295) -->
+    <skip />
+    <!-- no translation found for listSeparatorOtherInformation (3399084175925138065) -->
+    <skip />
+    <!-- no translation found for contactsIconLabel (392729648321810378) -->
+    <skip />
+    <!-- no translation found for contactsFavoritesLabel (6274307000699136596) -->
+    <skip />
+    <!-- no translation found for dialerIconLabel (396765298398417139) -->
+    <skip />
+    <!-- no translation found for recentCallsIconLabel (7432201162713288826) -->
+    <skip />
+    <!-- no translation found for liveFolderAll (5991510762804226223) -->
+    <skip />
+    <!-- no translation found for liveFolderFavorites (8755759874416875970) -->
+    <skip />
+    <!-- no translation found for liveFolderPhone (3440101264360244544) -->
+    <skip />
+    <!-- no translation found for menu_sendTextMessage (3055919380461974147) -->
+    <skip />
+    <!-- no translation found for recentCalls_callNumber (924407199258234369) -->
+    <skip />
+    <!-- no translation found for recentCalls_editNumberBeforeCall (7859145185424954030) -->
+    <skip />
+    <!-- no translation found for recentCalls_addToContact (6950267092567953305) -->
+    <skip />
+    <!-- no translation found for recentCalls_removeFromRecentList (5273789011391059975) -->
+    <skip />
+    <!-- no translation found for recentCalls_deleteAll (425798199678070888) -->
+    <skip />
+    <!-- no translation found for recentCalls_empty (7787624895504983911) -->
+    <skip />
+    <!-- no translation found for imei (1052536402066249452) -->
+    <skip />
+    <!-- no translation found for voicemail (1135686231023059817) -->
+    <skip />
+    <!-- no translation found for unknown (6231893925212017656) -->
+    <skip />
+    <!-- no translation found for private_num (3065614133902647350) -->
+    <skip />
+    <!-- no translation found for dialerKeyboardHintText (2013777173021862941) -->
+    <skip />
+    <!-- no translation found for simContacts_emptyLoading (4828419758306519589) -->
+    <skip />
+    <!-- no translation found for simContacts_title (4162577066960174009) -->
+    <skip />
+    <!-- no translation found for contactsSyncPlug (1549212649158409469) -->
+    <skip />
+    <!-- no translation found for noContactsHelpText (6155730972704522463) -->
+    <skip />
+    <!-- no translation found for seclectSyncGroups_title (7675331949118054911) -->
+    <skip />
+    <!-- no translation found for liveFolder_all_label (3716551598022430019) -->
+    <skip />
+    <!-- no translation found for liveFolder_favorites_label (9053985659909059395) -->
+    <skip />
+    <!-- no translation found for liveFolder_phones_label (8943901400107401868) -->
+    <skip />
 </resources>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
deleted file mode 100644
index 8d527f5..0000000
--- a/res/values-zh-rTW/strings.xml
+++ /dev/null
@@ -1,124 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<resources xmlns:android="http://schemas.android.com/apk/res/android"
-    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-  <string name="addPicture">新增圖示</string>
-  <string name="allContacts">所有連絡人</string>
-  <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-  <string name="attachToContact">連絡人圖示</string>
-  <string name="button_discard">放棄變更</string>
-  <string name="button_save">儲存</string>
-  <string name="cancelButtonText">取消</string>
-  <string name="contactCreatedToast">已經建立連絡人。</string>
-  <string name="contactSavedToast">已經儲存連絡人。</string>
-  <string name="contactsFavoritesLabel">我的最愛</string>
-  <string name="contactsIconLabel">連絡人</string>
-  <string name="contactsList">連絡人</string>
-  <string name="customLabelPickerTitle">自訂標籤</string>
-  <string name="default_ringtone">預設值</string>
-  <string name="deleteConfirmation">將會刪除此連絡人。</string>
-  <string name="deleteConfirmation_title">刪除</string>
-  <string name="dialerIconLabel">撥號員</string>
-  <string name="dialerKeyboardHintText">使用鍵盤撥號</string>
-  <string name="doneButton">完成</string>
-  <string name="editContactDescription">編輯連絡人</string>
-  <string name="editContact_title_edit">編輯連絡人</string>
-  <string name="editContact_title_insert">新增連絡人</string>
-  <string name="emailLabelsGroup">電子郵件</string>
-  <string name="errorDialogTitle">無圖片</string>
-  <string name="frequentList">經常</string>
-  <string name="ghostData_company">公司</string>
-  <string name="ghostData_email">電子郵件地址</string>
-  <string name="ghostData_im">立即訊息名稱</string>
-  <string name="ghostData_name">姓名</string>
-  <string name="ghostData_notes">我的記事</string>
-  <string name="ghostData_phone">電話號碼</string>
-  <string name="ghostData_postal">郵遞地址</string>
-  <string name="ghostData_title">職位</string>
-  <string name="groupEmpty">\"<xliff:g id="groupName">%s</xliff:g>\" 群組空白。</string>
-  <string name="groupNameMyContacts">我的連絡人</string>
-  <string name="groupNameWithPhones">含有電話號碼的連絡人</string>
-  <string name="imLabelsGroup">立即訊息</string>
-  <string name="imei">IMEI</string>
-  <string name="importFromSim">SIM 卡連絡人匯入工具</string>
-  <string name="insertContactDescription">建立連絡人</string>
-  <string name="invalidContactMessage">此連絡人不存在。</string>
-  <string name="label_company">公司</string>
-  <string name="label_notes">記事</string>
-  <string name="label_ringtone">響鈴音調</string>
-  <string name="label_title">職稱</string>
-  <string name="listSeparatorCallNumber">撥號</string>
-  <string name="listSeparatorMapAddress">地圖地址</string>
-  <string name="listSeparatorOrganizations">組織</string>
-  <string name="listSeparatorOtherInformation">其它資訊</string>
-  <string name="listSeparatorSendEmail">傳送電子郵件</string>
-  <string name="listSeparatorSendIm">傳送立即訊息</string>
-  <string name="listSeparatorSendSmsMms">傳送簡訊/多媒體簡訊</string>
-  <string name="menu_addItem">其它資訊</string>
-  <string name="menu_addStar">加到我的最愛</string>
-  <string name="menu_call">撥號</string>
-  <string name="menu_callNumber">撥打到 <xliff:g id="contact">%s</xliff:g></string>
-  <string name="menu_deleteContact">刪除連絡人</string>
-  <string name="menu_dialer">撥號員</string>
-  <string name="menu_displayGroup">顯示群組</string>
-  <string name="menu_doNotSave">放棄變更</string>
-  <string name="menu_done">儲存</string>
-  <string name="menu_editContact">編輯連絡人</string>
-  <string name="menu_editNumberBeforeCall">撥號之前編輯號碼</string>
-  <string name="menu_makeDefaultNumber">設成預設號碼</string>
-  <string name="menu_newContact">新增連絡人</string>
-  <string name="menu_newFavortie">新增我的最愛</string>
-  <string name="menu_preferences">設定</string>
-  <string name="menu_removeStar">從我的最愛中移除</string>
-  <string name="menu_sendEmail">傳送電子郵件</string>
-  <string name="menu_sendSMS">傳送簡訊/多媒體簡訊</string>
-  <string name="menu_sendTextMessage">傳送簡訊</string>
-  <string name="menu_viewAddress">地圖地址</string>
-  <string name="menu_viewContact">檢視連絡人</string>
-  <string name="noButton">取消</string>
-  <string name="noContacts">無連絡人。</string>
-  <string name="noContactsWithPhoneNumbers">無含有電話號碼的連絡人。</string>
-  <string name="noFavorites">無我的最愛。</string>
-  <string name="no_imei">未知的 IMEI</string>
-  <string name="ok">確定</string>
-  <string name="okButtonText">確定</string>
-  <string name="otherLabelsGroup">其他</string>
-  <string name="phoneIconLabel">電話</string>
-  <string name="phoneLabelsGroup">電話</string>
-  <string name="photoPickerNotFoundText">電話上無可用圖片。</string>
-  <string name="pickerNewContactHeader">建立新連絡人</string>
-  <string name="postalLabelsGroup">郵遞地址</string>
-  <string name="private_num">私人號碼</string>
-  <string name="recentCallsIconLabel">撥號記錄</string>
-  <string name="recentCalls_addToContact">新增到連絡人</string>
-  <string name="recentCalls_callNumber">撥打到 <xliff:g id="who">%s</xliff:g></string>
-  <string name="recentCalls_deleteAll">清除撥號記錄</string>
-  <string name="recentCalls_editNumberBeforeCall">撥號之前編輯號碼</string>
-  <string name="recentCalls_empty">撥號記錄空白。</string>
-  <string name="recentCalls_removeFromRecentList">從撥號記錄中移除</string>
-  <string name="removePicture">移除圖示</string>
-  <string name="searchHint">搜尋連絡人</string>
-  <string name="selectGroupsToSync">同步群組</string>
-  <string name="selectLabel">選取標籤</string>
-  <string name="select_group_title">選取要顯示的群組</string>
-  <string name="send_to_voicemail_checkbox">直接撥號到語音信箱。</string>
-  <string name="send_to_voicemail_view">如此便會直接撥號到語音信箱。</string>
-  <string name="shortcutContact">連絡人</string>
-  <string name="showAllGroups">所有連絡人</string>
-  <string name="showingGroupTitle">
-					<xliff:g id="groupName">%s</xliff:g>
-				</string>
-  <string name="simContacts_emptyLoading">正在從 SIM 卡載入\u2026</string>
-  <string name="simContacts_title">SIM 卡連絡人</string>
-  <string name="sms_entry_label">傳送簡訊/多媒體簡訊</string>
-  <string name="starredList">附加星號</string>
-  <string name="strequentList">我的最愛</string>
-  <string name="syncAllGroups">同步所有連絡人</string>
-  <string name="syncGroupChooserTitle">選取要同步的群組</string>
-  <string name="syncGroupPreference">同步群組</string>
-  <string name="syncGroupPreference_summary">選取要同步的群組</string>
-  <string name="unknown">無法辨識</string>
-  <string name="viewContactDesription">檢視連絡人</string>
-  <string name="viewContactTitle">連絡人詳細資料</string>
-  <string name="voicemail">語音信箱</string>
-  <string name="yesButton">確定</string>
-</resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index c09d213..450b3fa 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -15,145 +15,203 @@
 -->
 
 <resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
-    <!-- Strings for ContactsActivity and tabs -->
+    <!-- Title for the activity that shows contacts -->
     <string name="contactsList">Contacts</string>
+
+    <!-- Name of activity that allows users to create shortcuts on the home screen to a contact.
+         This shows up in a list of things like bookmark, folder, music playlist, etc -->
     <string name="shortcutContact">Contact</string>
+
+    <!-- Title for the activity that shows only starred contacts -->
     <string name="starredList">Starred</string>
+
+    <!-- Title for the activity that shows only frequently contacted contacts -->
     <string name="frequentList">Frequent</string>
+
+    <!-- Title for the activity that shows a mix of starred contacts and frequently contacted
+         contacts. -->
     <string name="strequentList">Favorites</string>
 
     <!-- The title bar when viewing the contact details activity -->
     <string name="viewContactTitle">Contact details</string>
     
-    <!-- Individual contact context menu item -->
+    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
+         viewing a contact. This string represents the built in way to view the contact. -->
     <string name="viewContactDesription">View contact</string>
     
-    <!-- Individual contact context menu item. The description of the activity that edits a contact -->
+    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
+         editing a contact. This string represents the built in way to edit the contact. -->
     <string name="editContactDescription">Edit contact</string>
 
-    <!-- The description of the activity that creates a contact -->
+    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
+         creating a new contact. This string represents the built in way to create the contact. -->
     <string name="insertContactDescription">Create contact</string>
-    <!-- title of drop-down menu after user presses the Search key -->
+
+    <!-- Hint text in the search box when the user hits the Search key while in the contacts app -->
     <string name="searchHint">Search contacts</string>
 
     <!-- Menu item to create a new contact -->
     <string name="menu_newContact">New contact</string>
-    <!-- Menu item to create a new contact that is a "favorite" contact -->
-    <string name="menu_newFavortie">New favorite</string>
-    <string name="menu_dialer">Dialer</string>
-    <!-- Individual contact context menu item. -->
+
+    <!-- Menu item used to view the details for a specific contact -->
     <string name="menu_viewContact">View contact</string>
-    <string name="menu_callNumber">Call <xliff:g id="contact">%s</xliff:g></string>
-    <string name="menu_editNumberBeforeCall">Edit number before call</string>
-    <!-- Individual contact context menu item. -->
+
+    <!-- Menu item used to call a contact, containing the name of the contact to call -->
+    <string name="menu_callNumber">Call <xliff:g id="name">%s</xliff:g></string>
+
+    <!-- Menu item used to add a star to a contact, which makes that contact show up at the top of favorites -->
     <string name="menu_addStar">Add to favorites</string>
-    <!-- Individual contact context menu item. -->
+
+    <!-- Menu item used to remove a star from a contact, making the contact no longer show up at the top of favorites -->
     <string name="menu_removeStar">Remove from favorites</string>
 
-    <!-- Strings for ViewContactActivity. -->
+    <!-- Optional menu item to encode the current contact as a QR Code using Barcode Scanner. -->
+    <string name="menu_showBarcode">Show barcode</string>
+
+    <!-- Menu item used to edit a specific contact -->
     <string name="menu_editContact">Edit contact</string>
-    <!-- Individual contact context menu item & View contact screen menu item. -->
+
+    <!-- Menu item used to delete a specific contact -->
     <string name="menu_deleteContact">Delete contact</string>
+
+    <!-- Menu item used to call a specific contact when viewing the details of that contact. -->
     <string name="menu_call">Call</string>
+
+    <!-- Menu item used to send an SMS or MMS message to a specific phone number or a contacts default phone number -->
     <string name="menu_sendSMS">Send SMS/MMS</string>
-    <!-- Email address context menu item. -->
+
+    <!-- Menu item used to send an email message to a specific email address -->
     <string name="menu_sendEmail">Send email</string>
-    <!-- Physical address context menu item. -->
+
+    <!-- Menu item used to view a contact's address on a map -->
     <string name="menu_viewAddress">Map address</string>
-    <!-- Phone number context menu item. -->
+
+    <!-- Menu item that makes a phone the default for a contact. The default number used when you
+         try to call a contact without specifying a specific number. -->
     <string name="menu_makeDefaultNumber">Make default number</string>
-    <!-- Confirmation dialog after users selects to delete a contact. -->
+
+    <!-- Confirmation dialog title after users selects to delete a contact. -->
     <string name="deleteConfirmation_title">Delete</string>
+
+    <!-- Confirmation dialog contents after users selects to delete a contact. -->
     <string name="deleteConfirmation">This contact will be deleted.</string>
-    <string name="yesButton">OK</string>
-    <string name="noButton">Cancel</string>
 
-    <!-- The label next to phone numbers in the contact details screen when clicking the number
-         will send an SMS to it. 
-    -->
-    <string name="sms_entry_label">Send SMS/MMS</string>
-
-    <!-- Strings for EditContact screen -->
+    <!-- Menu item to indicate you are done editing a contact and want to save the changes you've made -->
     <string name="menu_done">Save</string>
+
+    <!-- Menu item to indicate you want to stop editing a contact and NOT save the changes you've made -->
     <string name="menu_doNotSave">Discard changes</string>
 
+    <!-- Button to indicate you are done editing a contact and want to save the changes you've made -->
     <string name="button_save">Save</string>
+
+    <!-- Button to indicate you want to stop editing a contact and NOT save the changes you've made -->
     <string name="button_discard">Discard changes</string>
 
+    <!-- The title of the activity that edits and existing contact -->
     <string name="editContact_title_edit">Edit contact</string>
+
+    <!-- The title of the activity that creates a new contact -->
     <string name="editContact_title_insert">New contact</string>
 
+    <!-- Button that adds more info to a contact, like a new phone number, email address, or postal address -->
     <string name="menu_addItem">More info</string>
 
-    <string name="label_company">Company</string>
-    <string name="label_title">Job title</string>
+    <!-- The label describing the Notes field of a contact. This field allows free form text entry about a contact -->
     <string name="label_notes">Notes</string>
+
+    <!-- The label describing the custom ringtone for a contact -->
     <string name="label_ringtone">Ringtone</string>
-    <!-- Ghost data that appears in the field by default in light font. -->
+
+    <!-- Hint text for the contact name when editing -->
     <string name="ghostData_name">First and Last</string>
+
+    <!-- Hint text for the organization name when editing -->
     <string name="ghostData_company">Company</string>
+
+    <!-- Hint text for the organization position when editing -->
     <string name="ghostData_title">Position</string>
+
+    <!-- Hint text for an IM account when editing -->
     <string name="ghostData_im">IM name</string>
+
+    <!-- Hint text for the notes field when editing -->
     <string name="ghostData_notes">My note</string>
+
+    <!-- Hint text for the phone number field when editing -->
     <string name="ghostData_phone">Phone number</string>
+
+    <!-- Hint text for the email address field when editing -->
     <string name="ghostData_email">Email address</string>
+
+    <!-- Hint text for the postal address field when editing -->
     <string name="ghostData_postal">Postal address</string>
 
     <!-- Message displayed in a toast when you try to view the details of a contact that
          for some reason doesn't exist anymore. -->
     <string name="invalidContactMessage">The contact does not exist.</string>
 
+    <!-- When picking a contact from a list of all contacts there is an entry at the top of the
+         list that allows the user to create a new contact, which this string is used for -->
     <string name="pickerNewContactHeader">Create new contact</string>
-    <!-- New contact screen, dialog title when you select a label. -->
+
+    <!-- Dialog title when you select a label when creating or edit a contact -->
     <string name="selectLabel">Select label</string>
 
+    <!-- Header that expands to list all of the types of phone numbers when editing or creating a phone number for a contact -->
     <string name="phoneLabelsGroup">Phone</string>
+
+    <!-- Header that expands to list all of the types of email addresses when editing or creating an email address for a contact -->
     <string name="emailLabelsGroup">Email</string>
+
+    <!-- Header that expands to list all of the types of IM account when editing or creating an IM account for a contact -->
     <string name="imLabelsGroup">IM</string>
+
+    <!-- Header that expands to list all of the types of postal addresses when editing or creating an postal address for a contact -->
     <string name="postalLabelsGroup">Postal address</string>
+
+    <!-- Header that expands to list other types of data you can add to a contact, like notes and organizations -->
     <string name="otherLabelsGroup">Other</string>
 
+    <!-- The order of the items below is important, don't reorder without changing EditContactActivity.java -->
+    <skip/>
+    <!-- The labels that are under the otherLabelsGroup when editing a contact. -->
     <string-array name="otherLabels">
-        <!-- The order of these is important, don't reorder without changing EditContactActivity.java -->
+        <!-- An organization associated with a contact -->
         <item>Organization</item>
+        <!-- A note associated with a contact -->
         <item>Note</item>
     </string-array>
 
-
-    <!-- Dialog that appears if there are no pictures from which to create an icon -->
+    <!-- Title of the dialog that appears if there are no pictures from which to create an icon for a contact -->
     <string name="errorDialogTitle">No pictures</string>
-    <string name="photoPickerNotFoundText">No pictures are available on the phone.</string>
-    <string name="okButtonText">OK</string>
-    <string name="cancelButtonText">Cancel</string>
 
-    <!-- Strings for AttachImage. -->
+    <!-- Description in the dialog that appears if there are no pictures from which to create an icon for a contact -->
+    <string name="photoPickerNotFoundText">No pictures are available on the phone.</string>
+
+    <!-- Description of the activity used to set a photo in the pictures application as the icon for a contact -->
     <string name="attachToContact">Contact icon</string>
 
-    <!-- unreviewed strings -->
-    <string name="customLabelPickerTitle">Custom label</string>
-    <!-- The menu item to open the preferences -->
-    <string name="menu_preferences">Settings</string>
+    <!-- Title of the dialog used to set a custom label for a contact detail, like a phone number or email address.
+         For example, this may be used to set a phone number's label to "Vaction house" -->
+    <string name="customLabelPickerTitle">Custom label name</string>
+
     <!-- The menu item to open the list of groups to display -->
     <string name="menu_displayGroup">Display group</string>
 
-    <!-- The title of the preference to display which groups to sync -->
-    <string name="syncGroupPreference">Sync groups</string>
-    <!-- The summary of the preference to choose sync groups. -->
-    <string name="syncGroupPreference_summary">Select groups to synchronize</string>
+    <!-- The menu item that leads to the settings for contact syncing -->
+    <string name="syncGroupPreference">Edit sync groups</string>
     
-    <!-- The description of the preference that launches the SIM import activity -->
-    <string name="importFromSim">SIM contacts importer</string>
+    <!-- The menu item that launches the SIM card import activity -->
+    <string name="importFromSim">Import contacts</string>
 
-    <!-- Characters that are used for each of the fast-scroll widget that skips directly
-         to names starting with this letter.  If your language sorts differently than this,
-         please rearrange the alphabet here to be whatever is correct (e.g. Norwegian
-         has the three additional letters at the end). -->
-    <string name="alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
-    <!-- New contact screen, check box label. -->
+    <!-- Check box label that allows calls to the contact to be sent directly to voicemail -->
     <string name="send_to_voicemail_checkbox">Send calls directly to voicemail.</string>
-    <!-- View contact screen, string identifying state. -->
+
+    <!-- String letting the user know that calls from the contact they're viewing will be sent directly to voicemail -->
     <string name="send_to_voicemail_view">Calls are sent directly to voicemail.</string>
-    <!-- New contact screen, default ringtone value. -->
+
+    <!-- String used to indicate that a contact doesn't have a custom ringtone -->
     <string name="default_ringtone">Default</string>
 
     <!-- The button/menu item that allows you to add a picture to a contact -->
@@ -171,16 +229,11 @@
     <!-- The text displayed when the contacts list is empty while displaying favorite contacts -->
     <string name="noFavorites">No favorites.</string>
 
-    <!-- Title for group selection menu -->
-    <string name="select_group_title">Select group to display</string>
+    <!-- Title for group selection dialog. The dialog contains a list of contact groups that the
+         user can pick from, indicating they only want to see the contacts in that group. -->
+    <string name="select_group_title">Groups</string>
     
-    <!-- Group name for all contacts -->
-    <string name="allContacts">All contacts</string>
-    
-    <!-- Title for Contacts group that is currently showing -->
-    <string name="showingGroupTitle"><xliff:g id="groupName">%s</xliff:g></string>
-    
-    <!-- The text displayed when the contacts list is empty while displaying a single group -->
+    <!-- The text displayed when the contacts list is empty while displaying a single group of contacts -->
     <string name="groupEmpty">Your \"<xliff:g id="groupName">%s</xliff:g>\" group is empty.</string>
 
     <!-- The description of all groups when asking the user what they want to display -->
@@ -195,12 +248,6 @@
     <!-- The group type that displays only contacts with phone numbers -->
     <string name="groupNameWithPhones">Contacts with phone numbers</string>
     
-    <!-- Title of the dialog the user uses to choose which contacts groups to sync from the server -->
-    <string name="syncGroupChooserTitle">Select groups to sync</string>
-
-    <!-- The menu item allowing you to select which groups you want to sync. -->
-    <string name="selectGroupsToSync">Sync groups</string>
-
     <!-- Toast displayed when a contact is created -->
     <string name="contactCreatedToast">Contact created.</string>
     
@@ -228,43 +275,106 @@
     <!-- Separator in the contact details list describing that the items below are random other non-actionable information about a contact -->
     <string name="listSeparatorOtherInformation">Other information</string>
 
-
-
-    <!-- Launcher tab labels -->
+    <!-- The description text for the contacts tab. Space is limited for this string, so the shorter the better -->
     <string name="contactsIconLabel">Contacts</string>
-    <string name="contactsFavoritesLabel">Favorites</string>
-    <string name="dialerIconLabel">Dialer</string>
-    <string name="phoneIconLabel">Phone</string>
-    <string name="recentCallsIconLabel">Call log</string>
 
-    <!-- menu items for Dialer  -->
+    <!-- The description text for the favorites tab. Space is limited for this string, so the shorter the better -->
+    <string name="contactsFavoritesLabel">Favorites</string>
+
+    <!-- The description text for the dialer tab. Space is limited for this string, so the shorter the better -->
+    <string name="dialerIconLabel">Dialer</string>
+
+    <!-- The description text for the call log tab. Space is limited for this string, so the shorter the better -->
+    <string name="recentCallsIconLabel">Call log</string>
+    <string name="liveFolderAll">All contacts</string>
+    <string name="liveFolderFavorites">Starred contacts</string>
+    <string name="liveFolderPhone">Contacts with phone numbers</string>
+
+    <!-- Menu item used to send an SMS or MMS message to a phone number  -->
     <string name="menu_sendTextMessage">Send SMS message</string>
 
-    <!-- Recent calls strings -->
-    <string name="recentCalls_callNumber">Call <xliff:g id="who">%s</xliff:g></string>
+    <!-- Menu item used to call a contact from the call log -->
+    <string name="recentCalls_callNumber">Call <xliff:g id="name">%s</xliff:g></string>
+
+    <!-- Menu item used to copy a number from the call log to the dialer so it can be edited before calling it -->
     <string name="recentCalls_editNumberBeforeCall">Edit number before call</string>
+
+    <!-- Menu item used to add a number from the call log to contacts -->
     <string name="recentCalls_addToContact">Add to contacts</string>
+
+    <!-- Menu item used to remove a single call from the call log -->
     <string name="recentCalls_removeFromRecentList">Remove from call log</string>
+
+    <!-- Menu item used to remove all calls from the call log -->
     <string name="recentCalls_deleteAll">Clear call log</string>
+
+    <!-- Text displayed when the call log is empty -->
     <string name="recentCalls_empty">Call log is empty.</string>
 
-    <!-- IMEI strings -->
+    <!-- The title of a dialog that displays the IMEI of the phone -->
     <string name="imei">IMEI</string>
-    <string name="no_imei">Unknown IMEI</string>
 
-    <string name="doneButton">Done</string>
-
-    <string name="ok">OK</string>
-
+    <!-- String used for displaying calls to the voicemail number in the call log -->
     <string name="voicemail">Voicemail</string>
+
+    <!-- String used to display calls from unknown numbers in the call log -->
     <string name="unknown">Unknown</string>
+
+    <!-- String used to display calls from private numbers in the call log -->
     <string name="private_num">Private number</string>
 
     <!-- Displayed in the text entry box in the dialer when in landscape mode to guide the user
          to dial using the physical keyboard -->
     <string name="dialerKeyboardHintText">Use keyboard to dial</string>
 
-    <!-- ADN related strings -->
+    <!-- Hint text displayed in the "digits" field above the dialer's
+         dialpad, if there's already a call in progress.  (This hint
+         reminds the user that the dialer will add a new call, as opposed
+         to sending DTMF tones over the current call.) -->
+    <string name="dialerDialpadHintText">Dial to add a call</string>
+
+    <!-- Dialog text displayed when loading a phone number from the SIM card for speed dial -->
     <string name="simContacts_emptyLoading">Loading from SIM card\u2026</string>
+
+    <!-- Dialog title displayed when loading a phone number from the SIM card for speed dial -->
     <string name="simContacts_title">SIM card contacts</string>
+
+    <!-- Displayed when a user is prompted to setup a Google account for syncing -->
+    <string name="contactsSyncPlug"><font fgcolor="#ffffffff">Sync your Google contacts!</font>
+    \nAfter syncing to your phone, your contacts will be available to you wherever you go.</string>
+
+    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group -->
+    <string name="noContactsHelpText">"You don't have any contacts.\n\nTo add contacts, press <font fgcolor="#ffffffff"><b>Menu</b></font> and select:\n
+        \n<li><font fgcolor="#ffffffff"><b>Edit sync groups</b></font> to add from a new or existing Google account\n</li>
+        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
+        \n<li><font fgcolor="#ffffffff"><b>Import contacts</b></font> to add contacts from your SIM card\n</li>"
+    </string>
+    
+    <!-- Activity title for the activity that lets the user choose which groups of contacts to sync from the server -->
+    <string name="seclectSyncGroups_title">Select groups to sync</string>
+
+    <!-- Live folder label for all contacts -->
+    <string name="liveFolder_all_label">All Contacts</string>
+
+    <!-- Live folder label for only starred contacts -->
+    <string name="liveFolder_favorites_label">Starred</string>
+
+    <!-- Live folder label for all contacts with phone numbers -->
+    <string name="liveFolder_phones_label">Phones</string>    
+
+    <!-- Item label: jump to the in-call DTMF dialpad.
+         (Part of a list of options shown in the dialer when another call
+         is already in progress.) -->
+    <string name="dialer_useDtmfDialpad">Use touch tone keypad</string>
+
+    <!-- Item label: jump to the in-call UI.
+         (Part of a list of options shown in the dialer when another call
+         is already in progress.) -->
+    <string name="dialer_returnToInCallScreen">Return to call in progress</string>
+
+    <!-- Item label: use the Dialer's dialpad to add another call.
+         (Part of a list of options shown in the dialer when another call
+         is already in progress.) -->
+    <string name="dialer_addAnotherCall">Add call</string>
+
 </resources>
diff --git a/res/values/styles.xml b/res/values/styles.xml
deleted file mode 100644
index 0648441..0000000
--- a/res/values/styles.xml
+++ /dev/null
@@ -1,28 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2007 The Android Open Source Project
-
-     Licensed under the Apache License, Version 2.0 (the "License");
-     you may not use this file except in compliance with the License.
-     You may obtain a copy of the License at
-  
-          http://www.apache.org/licenses/LICENSE-2.0
-  
-     Unless required by applicable law or agreed to in writing, software
-     distributed under the License is distributed on an "AS IS" BASIS,
-     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-     See the License for the specific language governing permissions and
-     limitations under the License.
--->
-
-<resources>
-    <style name="TextAppearance.DialerLine1" parent="@android:style/TextAppearance.Widget.Button">
-        <item name="android:textSize">32sp</item>
-        <item name="android:textColor">@color/dialer_button_text</item>
-        <item name="android:textStyle">bold</item>
-    </style>
-
-    <style name="TextAppearance.DialerLine2" parent="@android:style/TextAppearance.Widget.Button">
-        <item name="android:textSize">18sp</item>
-        <item name="android:textColor">@color/dialer_button_text</item>
-    </style>
-</resources>
diff --git a/res/xml/preferences.xml b/res/xml/preferences.xml
deleted file mode 100644
index dd18137..0000000
--- a/res/xml/preferences.xml
+++ /dev/null
@@ -1,41 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<!-- Copyright (C) 2008 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.
--->
-
-<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
-
-    <PreferenceScreen
-            android:key="sync_groups"
-            android:title="@string/syncGroupPreference"
-            android:summary="@string/syncGroupPreference_summary">
-        <intent
-                android:action="android.intent.action.VIEW"
-                android:targetPackage="com.android.contacts"
-                android:targetClass="com.android.contacts.ContactsGroupSyncSelector"
-        />
-    </PreferenceScreen>
-
-    <PreferenceScreen
-        android:title="@string/importFromSim"
-    >
-
-        <intent
-            android:action="android.intent.action.VIEW"
-            android:mimeType="vnd.android.cursor.item/sim-contact"
-            android:targetPackage="com.android.phone"
-            android:targetClass="com.android.phone.SimContacts"
-        />
-    </PreferenceScreen>
-</PreferenceScreen>
diff --git a/src/com/android/contacts/AlphabetIndexer.java b/src/com/android/contacts/AlphabetIndexer.java
deleted file mode 100644
index 4e5fb0f..0000000
--- a/src/com/android/contacts/AlphabetIndexer.java
+++ /dev/null
@@ -1,197 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.contacts;
-
-import android.database.Cursor;
-import android.database.DataSetObserver;
-import android.util.SparseIntArray;
-
-/**
- * This class essentially helps in building an index of section boundaries of a
- * sorted column of a cursor. For instance, if a cursor contains a data set 
- * sorted by first name of a person or the title of a song, this class will 
- * perform a binary search to identify the first row that begins with a 
- * particular letter. The search is case-insensitive. The class caches the index 
- * such that subsequent queries for the same letter will return right away.
- */
-public class AlphabetIndexer extends DataSetObserver {
-
-    protected Cursor mDataCursor;
-    protected int mColumnIndex;
-    protected Object[] mAlphabetArray;
-    private SparseIntArray mAlphaMap;
-    private java.text.Collator mCollator;
-
-    /**
-     * Constructs the indexer.
-     * @param cursor the cursor containing the data set
-     * @param columnIndex the column number in the cursor that is sorted 
-     *        alphabetically
-     * @param sections the array of objects that represent the sections. The
-     * toString() method of each item is called and the first letter of the 
-     * String is used as the letter to search for.
-     */
-    public AlphabetIndexer(Cursor cursor, int columnIndex, Object[] sections) {
-        mDataCursor = cursor;
-        mColumnIndex = columnIndex;
-        mAlphabetArray = sections;
-        mAlphaMap = new SparseIntArray(26 /* Optimize for English */);
-        if (cursor != null) {
-            cursor.registerDataSetObserver(this);
-        }
-        // Get a Collator for the current locale for string comparisons.
-        mCollator = java.text.Collator.getInstance();
-        mCollator.setStrength(java.text.Collator.PRIMARY);
-    }
-
-    /**
-     * Sets a new cursor as the data set and resets the cache of indices.
-     * @param cursor the new cursor to use as the data set
-     */
-    public void setCursor(Cursor cursor) {
-        if (mDataCursor != null) {
-            mDataCursor.unregisterDataSetObserver(this);
-        }
-        mDataCursor = cursor;
-        if (cursor != null) {
-            mDataCursor.registerDataSetObserver(this);
-        }
-        mAlphaMap.clear();
-    }
-
-    /**
-     * Performs a binary search or cache lookup to find the first row that
-     * matches a given section's starting letter.
-     * @param sectionIndex the section to search for
-     * @return the row index of the first occurrence, or the nearest next letter.
-     * For instance, if searching for "T" and no "T" is found, then the first
-     * row starting with "U" or any higher letter is returned. If there is no
-     * data following "T" at all, then the list size is returned.
-     */
-    public int indexOf(int sectionIndex) {
-        final SparseIntArray alphaMap = mAlphaMap;
-        final Cursor cursor = mDataCursor;
-
-        if (cursor == null || mAlphabetArray == null) {
-            return 0;
-        }
-        
-        // Check bounds
-        if (sectionIndex <= 0) {
-            return 0;
-        }
-        if (sectionIndex >= mAlphabetArray.length) {
-            sectionIndex = mAlphabetArray.length - 1;
-        }
-
-        int savedCursorPos = cursor.getPosition();
-
-        int count = cursor.getCount();
-        int start = 0;
-        int end = count;
-        int pos;
-
-        String letter = mAlphabetArray[sectionIndex].toString();
-        letter = letter.toUpperCase();
-        int key = letter.charAt(0);
-        // Check map
-        if (Integer.MIN_VALUE != (pos = alphaMap.get(key, Integer.MIN_VALUE))) {
-            // Is it approximate? Using negative value to indicate that it's 
-            // an approximation and positive value when it is the accurate
-            // position.
-            if (pos < 0) {
-                pos = -pos;
-                end = pos;
-            } else {
-                // Not approximate, this is the confirmed start of section, return it
-                return pos;
-            }
-        }
-
-        // Do we have the position of the previous section?
-        if (sectionIndex > 0) {
-            int prevLetter =
-                    mAlphabetArray[sectionIndex - 1].toString().charAt(0);
-            int prevLetterPos = alphaMap.get(prevLetter, Integer.MIN_VALUE);
-            if (prevLetterPos != Integer.MIN_VALUE) {
-                start = Math.abs(prevLetterPos);
-            }
-        }
-
-        // Now that we have a possibly optimized start and end, let's binary search
-
-        pos = (end + start) / 2;
-
-        while (pos < end) {
-            // Get letter at pos
-            cursor.moveToPosition(pos);
-            String curName = cursor.getString(mColumnIndex);
-            if (curName == null) {
-                if (pos == 0) {
-                    break;
-                } else {
-                    pos--;
-                    continue;
-                }
-            }
-            int curLetter = Character.toUpperCase(curName.charAt(0));
-
-            if (curLetter != key) {
-                // Enter approximation in hash if a better solution doesn't exist
-                int curPos = alphaMap.get(curLetter, Integer.MIN_VALUE);
-                if (curPos == Integer.MIN_VALUE || Math.abs(curPos) > pos) {
-                    // Negative pos indicates that it is an approximation
-                    alphaMap.put(curLetter, -pos);
-                }
-                if (mCollator.compare(curName, letter) < 0) {
-                    start = pos + 1;
-                    if (start >= count) {
-                        pos = count;
-                        break;
-                    }
-                } else {
-                    end = pos;
-                }
-            } else {
-                // They're the same, but that doesn't mean it's the start
-                if (start == pos) {
-                    // This is it
-                    break;
-                } else {
-                    // Need to go further lower to find the starting row
-                    end = pos;
-                }
-            }
-            pos = (start + end) / 2;
-        }
-        alphaMap.put(key, pos);
-        cursor.moveToPosition(savedCursorPos);
-        return pos;
-    }
-
-    @Override
-    public void onChanged() {
-        super.onChanged();
-        mAlphaMap.clear();
-    }
-
-    @Override
-    public void onInvalidated() {
-        super.onInvalidated();
-        mAlphaMap.clear();
-    }
-}
diff --git a/src/com/android/contacts/AttachImage.java b/src/com/android/contacts/AttachImage.java
index 6346031..8c91722 100644
--- a/src/com/android/contacts/AttachImage.java
+++ b/src/com/android/contacts/AttachImage.java
@@ -28,22 +28,22 @@
 
 /**
  * Provides an external interface for other applications to attach images
- * to contacts. It will first present a contact picker and then run the 
+ * to contacts. It will first present a contact picker and then run the
  * image that is handed to it through the cropper to make the image the proper
  * size and give the user a chance to use the face detector.
  */
-class AttachImage extends Activity {
+public class AttachImage extends Activity {
     private static final int REQUEST_PICK_CONTACT = 1;
     private static final int REQUEST_CROP_PHOTO = 2;
 
     private static final String CONTACT_URI_KEY = "contact_uri";
 
     public AttachImage() {
-        
+
     }
 
     Uri mContactUri;
-    
+
     @Override
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
diff --git a/src/com/android/contacts/ContactsGroupSyncSelector.java b/src/com/android/contacts/ContactsGroupSyncSelector.java
index 1043299..6081c79 100644
--- a/src/com/android/contacts/ContactsGroupSyncSelector.java
+++ b/src/com/android/contacts/ContactsGroupSyncSelector.java
@@ -16,28 +16,27 @@
 
 package com.android.contacts;
 
+import com.google.android.googlelogin.GoogleLoginServiceConstants;
+import com.google.android.googlelogin.GoogleLoginServiceHelper;
+
+import android.app.ListActivity;
 import android.content.ContentResolver;
 import android.content.ContentUris;
 import android.content.ContentValues;
-import android.content.DialogInterface;
+import android.content.Intent;
 import android.database.Cursor;
 import android.os.Bundle;
 import android.provider.Contacts;
+import android.provider.Gmail;
 import android.provider.Contacts.Groups;
 import android.provider.Contacts.Settings;
 import android.text.TextUtils;
-import android.view.ContextThemeWrapper;
 import android.view.View;
 import android.view.ViewGroup;
-import android.widget.AdapterView;
 import android.widget.ArrayAdapter;
 import android.widget.ListView;
 
-import com.android.internal.app.AlertActivity;
-import com.android.internal.app.AlertController;
-
-public final class ContactsGroupSyncSelector extends AlertActivity implements 
-        ListView.OnItemClickListener, DialogInterface.OnClickListener {
+public final class ContactsGroupSyncSelector extends ListActivity implements View.OnClickListener {
 
     private static final String[] PROJECTION = new String[] {
             Groups._ID, // 0
@@ -50,9 +49,7 @@
     private static final int COLUMN_INDEX_SHOULD_SYNC = 2;
     private static final int COLUMN_INDEX_SYSTEM_ID = 3;
 
-    private ContentResolver mResolver;
-    private ListView mListView;
-    private GroupsAdapter mAdapter;
+    private static final int SUBACTIVITY_GET_ACCOUNT = 1;
 
     boolean[] mChecked;
     boolean mSyncAllGroups;
@@ -60,8 +57,7 @@
     
     private final class GroupsAdapter extends ArrayAdapter<CharSequence> {
         public GroupsAdapter(CharSequence[] items) {
-            super(new ContextThemeWrapper(ContactsGroupSyncSelector.this,
-                    android.R.style.Theme_Light),
+            super(ContactsGroupSyncSelector.this,
                     android.R.layout.simple_list_item_checked,
                     android.R.id.text1, items);
         }
@@ -95,8 +91,9 @@
     /**
      * Handles clicks on the list items
      */
-    public void onItemClick(AdapterView<?> parent, View view, int position, long id) {
-        boolean isChecked = mListView.isItemChecked(position);
+    @Override
+    protected void onListItemClick(ListView list, View view, int position, long id) {
+        boolean isChecked = list.isItemChecked(position);
         mChecked[position] = isChecked;
         if (position == 0) {
             mSyncAllGroups = isChecked;
@@ -105,58 +102,85 @@
     }
 
     /**
-     * Handles clicks on the OK button
+     * Handles clicks on the OK and cancel buttons
      */
-    public void onClick(DialogInterface dialog, int which) {
-        if (mSyncAllGroups) {
-            // For now we only support a single account and the UI doesn't know what
-            // the account name is, so we're using a global setting for SYNC_EVERYTHING.
-            // Some day when we add multiple accounts to the UI this should use the per
-            // account setting.
-            Settings.setSetting(mResolver, null, Settings.SYNC_EVERYTHING, "1");
-        } else {
-            final ContentResolver resolver = mResolver;
-            ContentValues values = new ContentValues();
-            int count = mChecked.length;
-            for (int i = 1; i < count; i++) {
-                values.clear();
-                values.put(Groups.SHOULD_SYNC, mChecked[i]);
-                resolver.update(ContentUris.withAppendedId(Groups.CONTENT_URI, mGroupIds[i]),
-                        values, null, null);
+    public void onClick(View view) {
+        switch (view.getId()) {
+            case R.id.cancel: {
+                finish();
+                break;
             }
-            // For now we only support a single account and the UI doesn't know what
-            // the account name is, so we're using a global setting for SYNC_EVERYTHING.
-            // Some day when we add multiple accounts to the UI this should use the per
-            // account setting.
-            Settings.setSetting(resolver, null, Settings.SYNC_EVERYTHING, "0");
+            
+            case R.id.ok: {
+                final ContentResolver resolver = getContentResolver();
+                if (mSyncAllGroups) {
+                    // For now we only support a single account and the UI doesn't know what
+                    // the account name is, so we're using a global setting for SYNC_EVERYTHING.
+                    // Some day when we add multiple accounts to the UI this should use the per
+                    // account setting.
+                    Settings.setSetting(resolver, null, Settings.SYNC_EVERYTHING, "1");
+                } else {
+                    ContentValues values = new ContentValues();
+                    int count = mChecked.length;
+                    for (int i = 1; i < count; i++) {
+                        values.clear();
+                        values.put(Groups.SHOULD_SYNC, mChecked[i]);
+                        resolver.update(ContentUris.withAppendedId(Groups.CONTENT_URI, mGroupIds[i]),
+                                values, null, null);
+                    }
+                    // For now we only support a single account and the UI doesn't know what
+                    // the account name is, so we're using a global setting for SYNC_EVERYTHING.
+                    // Some day when we add multiple accounts to the UI this should use the per
+                    // account setting.
+                    Settings.setSetting(resolver, null, Settings.SYNC_EVERYTHING, "0");
+                }
+                finish();
+                break;
+            }
         }
     }
 
     @Override
     protected void onCreate(Bundle savedState) {
         super.onCreate(savedState);
-        mResolver = getContentResolver();
 
-        // Set the alert parameters
-        AlertController.AlertParams params = mAlertParams;
-        params.mTitle = getText(R.string.syncGroupChooserTitle);
-        params.mIcon = getResources().getDrawable(R.drawable.ic_tab_unselected_contacts);
-        params.mPositiveButtonText = getText(R.string.okButtonText);
-        params.mPositiveButtonListener = this;
-        params.mNegativeButtonText = getText(R.string.cancelButtonText);
-        buildItems(params);
+        // Only look for an account on first run.
+        if (savedState == null) {
+            // This will request a Gmail account and if none are present, it will
+            // invoke SetupWizard to login or create one. The result is returned
+            // through onActivityResult().
+            Bundle bundle = new Bundle();
+            bundle.putCharSequence("optional_message", getText(R.string.contactsSyncPlug));
+            GoogleLoginServiceHelper.getCredentials(this, SUBACTIVITY_GET_ACCOUNT,
+                    bundle, GoogleLoginServiceConstants.PREFER_HOSTED, Gmail.GMAIL_AUTH_SERVICE,
+                    true);
+        }
 
-        // Takes the info in mAlertParams and creates the layout
-        setupAlert();
+        setContentView(R.layout.sync_settings);
 
-        mListView = mAlert.getListView();
-        mListView.setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
-        mListView.setOnItemClickListener(this);
-        adjustChecks();
+        findViewById(R.id.ok).setOnClickListener(this);
+        findViewById(R.id.cancel).setOnClickListener(this);
+        
+        getListView().setChoiceMode(ListView.CHOICE_MODE_MULTIPLE);
     }
 
-    private void buildItems(AlertController.AlertParams params) {
-        Cursor cursor = mResolver.query(Groups.CONTENT_URI, PROJECTION, null, null, Groups.NAME);
+    @Override
+    protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+        super.onActivityResult(requestCode, resultCode, intent);
+        if (requestCode == SUBACTIVITY_GET_ACCOUNT) {
+            if (resultCode == RESULT_OK) {
+                // There is an account setup, build the group list
+                buildItems();
+                adjustChecks();
+            } else {
+                finish();
+            }
+        }
+    }
+
+    private void buildItems() {
+        final ContentResolver resolver = getContentResolver();
+        Cursor cursor = resolver.query(Groups.CONTENT_URI, PROJECTION, null, null, Groups.NAME);
         if (cursor != null) {
             try {
                 int count = cursor.getCount() + 1;
@@ -183,13 +207,12 @@
                     }
                 }
                 mChecked = checked;
-                mSyncAllGroups = getShouldSyncEverything(mResolver);
+                mSyncAllGroups = getShouldSyncEverything(resolver);
                 checked[0] = mSyncAllGroups;
                 mGroupIds = groupIds;
     
                 // Setup the adapter
-                mAdapter = new GroupsAdapter(items);
-                params.mAdapter = mAdapter;
+                setListAdapter(new GroupsAdapter(items));
             } finally {
                 cursor.close();
             }
@@ -197,7 +220,7 @@
     }
 
     private void adjustChecks() {
-        ListView list = mListView;
+        final ListView list = getListView();
         if (mSyncAllGroups) {
             int count = list.getCount();
             for (int i = 0; i < count; i++) {
diff --git a/src/com/android/contacts/ContactsListActivity.java b/src/com/android/contacts/ContactsListActivity.java
index 0ffa786..5e1fd63 100644
--- a/src/com/android/contacts/ContactsListActivity.java
+++ b/src/com/android/contacts/ContactsListActivity.java
@@ -28,8 +28,8 @@
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.SharedPreferences;
-import android.database.Cursor;
 import android.database.CharArrayBuffer;
+import android.database.Cursor;
 import android.graphics.Bitmap;
 import android.net.Uri;
 import android.os.Bundle;
@@ -43,10 +43,10 @@
 import android.provider.Contacts.Phones;
 import android.provider.Contacts.Presence;
 import android.provider.Contacts.Intents.UI;
-import android.telephony.PhoneNumberUtils;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.ContextMenu;
+import android.view.Gravity;
 import android.view.KeyEvent;
 import android.view.LayoutInflater;
 import android.view.Menu;
@@ -55,11 +55,14 @@
 import android.view.ViewGroup;
 import android.view.ContextMenu.ContextMenuInfo;
 import android.widget.AdapterView;
+import android.widget.AlphabetIndexer;
 import android.widget.ListView;
 import android.widget.ResourceCursorAdapter;
+import android.widget.SectionIndexer;
 import android.widget.TextView;
 
 import java.util.ArrayList;
+import java.lang.ref.WeakReference;
 
 /**
  * Displays a list of contacts. Usually is embedded into the ContactsActivity.
@@ -125,6 +128,31 @@
 
     static final int DEFAULT_MODE = MODE_ALL_CONTACTS;
 
+    /**
+     * The type of data to display in the main contacts list. 
+     */
+    static final String PREF_DISPLAY_TYPE = "display_system_group";
+
+    /** Unknown display type. */
+    static final int DISPLAY_TYPE_UNKNOWN = -1;
+    /** Display all contacts */
+    static final int DISPLAY_TYPE_ALL = 0;
+    /** Display all contacts that have phone numbers */
+    static final int DISPLAY_TYPE_ALL_WITH_PHONES = 1;
+    /** Display a system group */
+    static final int DISPLAY_TYPE_SYSTEM_GROUP = 2;
+    /** Display a user group */
+    static final int DISPLAY_TYPE_USER_GROUP = 3;
+
+    /**
+     * Info about what to display. If {@link #PREF_DISPLAY_TYPE}
+     * is {@link #DISPLAY_TYPE_SYSTEM_GROUP} then this will be the system id.
+     * If {@link #PREF_DISPLAY_TYPE} is {@link #DISPLAY_TYPE_USER_GROUP} then this will
+     * be the group name.
+     */ 
+    static final String PREF_DISPLAY_INFO = "display_group";
+
+    
     static final String NAME_COLUMN = People.DISPLAY_NAME;
     
     static final String[] CONTACTS_PROJECTION = new String[] {
@@ -244,9 +272,6 @@
     protected void onCreate(Bundle icicle) {
         super.onCreate(icicle);
 
-        // Make sure the preferences are setup
-        PreferenceManager.setDefaultValues(this, R.xml.preferences, false);
-
         // Resolve the intent
         final Intent intent = getIntent();
 
@@ -255,7 +280,7 @@
         if (title != null) {
             setTitle(title);
         }
-
+        
         final String action = intent.getAction();
         mMode = MODE_UNKNOWN;
         
@@ -355,12 +380,6 @@
             mMode = DEFAULT_MODE;
         }
 
-/*
-        if (!mDefaultMode) {
-            findViewById(R.id.contact_group).banner.setVisibility(View.GONE);
-        }
-*/
-
         // Setup the UI
         final ListView list = getListView();
         list.setFocusable(true);
@@ -392,12 +411,14 @@
     }
 
     private void setEmptyText() {
-        TextView empty = (TextView) findViewById(android.R.id.empty);
+        TextView empty = (TextView) findViewById(R.id.emptyText);
+        // Center the text by default
+        int gravity = Gravity.CENTER;
         switch (mMode) {
             case MODE_GROUP:
                 if (Groups.GROUP_MY_CONTACTS.equals(mDisplayInfo)) {
-                    empty.setText(getString(R.string.groupEmpty,
-                            getText(R.string.groupNameMyContacts)));
+                    empty.setText(getText(R.string.noContactsHelpText));
+                    gravity = Gravity.NO_GRAVITY;
                 } else {
                     empty.setText(getString(R.string.groupEmpty, mDisplayInfo));
                 }
@@ -417,6 +438,7 @@
                 empty.setText(getText(R.string.noContacts));
                 break;
         }
+        empty.setGravity(gravity);
     }
 
     /**
@@ -449,18 +471,17 @@
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
         
         // Lookup the group to display
-        mDisplayType = prefs.getInt(ContactsPreferenceActivity.PREF_DISPLAY_TYPE,
-                ContactsPreferenceActivity.DISPLAY_TYPE_UNKNOWN);
+        mDisplayType = prefs.getInt(PREF_DISPLAY_TYPE, DISPLAY_TYPE_UNKNOWN);
         switch (mDisplayType) {
-            case ContactsPreferenceActivity.DISPLAY_TYPE_ALL_WITH_PHONES: {
+            case DISPLAY_TYPE_ALL_WITH_PHONES: {
                 mMode = MODE_WITH_PHONES;
                 mDisplayInfo = null;
                 break;
             }
 
-            case ContactsPreferenceActivity.DISPLAY_TYPE_SYSTEM_GROUP: {
+            case DISPLAY_TYPE_SYSTEM_GROUP: {
                 String systemId = prefs.getString(
-                        ContactsPreferenceActivity.PREF_DISPLAY_INFO, null);
+                        PREF_DISPLAY_INFO, null);
                 if (!TextUtils.isEmpty(systemId)) {
                     // Display the selected system group
                     mMode = MODE_GROUP;
@@ -470,14 +491,14 @@
                     // No valid group is present, display everything
                     mMode = MODE_WITH_PHONES;
                     mDisplayInfo = null;
-                    mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_ALL;
+                    mDisplayType = DISPLAY_TYPE_ALL;
                 }
                 break;
             }
 
-            case ContactsPreferenceActivity.DISPLAY_TYPE_USER_GROUP: {
+            case DISPLAY_TYPE_USER_GROUP: {
                 String displayGroup = prefs.getString(
-                        ContactsPreferenceActivity.PREF_DISPLAY_INFO, null);
+                        PREF_DISPLAY_INFO, null);
                 if (!TextUtils.isEmpty(displayGroup)) {
                     // Display the selected user group
                     mMode = MODE_GROUP;
@@ -487,12 +508,12 @@
                     // No valid group is present, display everything
                     mMode = MODE_WITH_PHONES;
                     mDisplayInfo = null;
-                    mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_ALL;
+                    mDisplayType = DISPLAY_TYPE_ALL;
                 }
                 break;
             }
 
-            case ContactsPreferenceActivity.DISPLAY_TYPE_ALL: {
+            case DISPLAY_TYPE_ALL: {
                 mMode = MODE_ALL_CONTACTS;
                 mDisplayInfo = null;
                 break;
@@ -501,7 +522,7 @@
             default: {
                 // We don't know what to display, default to My Contacts
                 mMode = MODE_GROUP;
-                mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_SYSTEM_GROUP;
+                mDisplayType = DISPLAY_TYPE_SYSTEM_GROUP;
                 buildSystemGroupUris(Groups.GROUP_MY_CONTACTS);
                 mDisplayInfo = Groups.GROUP_MY_CONTACTS;
                 break;
@@ -596,19 +617,33 @@
             return false;
         }
 
+        // New contact
         menu.add(0, MENU_NEW_CONTACT, 0, R.string.menu_newContact)
                 .setIcon(android.R.drawable.ic_menu_add)
                 .setIntent(new Intent(Intents.Insert.ACTION, People.CONTENT_URI))
                 .setAlphabeticShortcut('n');
-        if (isChild()) {
-            menu.add(0, 0, 0, R.string.menu_preferences)
-                    .setIcon(android.R.drawable.ic_menu_preferences)
-                    .setIntent(new Intent(this, ContactsPreferenceActivity.class));
-        }
+
+        // Display group
         if (mDefaultMode) {
             menu.add(0, MENU_DISPLAY_GROUP, 0, R.string.menu_displayGroup)
                     .setIcon(R.drawable.ic_menu_allfriends);
         }
+
+        // Sync settings
+        Intent syncIntent = new Intent(Intent.ACTION_VIEW);
+        syncIntent.setClass(this, ContactsGroupSyncSelector.class);
+        menu.add(0, 0, 0, R.string.syncGroupPreference)
+                .setIcon(R.drawable.ic_menu_refresh)
+                .setIntent(syncIntent);
+        
+        // SIM import
+        Intent importIntent = new Intent(Intent.ACTION_VIEW);
+        importIntent.setType("vnd.android.cursor.item/sim-contact");
+        importIntent.setClassName("com.android.phone", "com.android.phone.SimContacts");
+        menu.add(0, 0, 0, R.string.importFromSim)
+                .setIcon(R.drawable.ic_menu_import_contact)
+                .setIntent(importIntent);
+
         return super.onCreateOptionsMenu(menu);
     }
 
@@ -622,27 +657,27 @@
                 // Set the group to display
                 if (mDisplayGroupCurrentSelection == DISPLAY_GROUP_INDEX_ALL_CONTACTS) {
                     // Display all
-                    mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_ALL;
+                    mDisplayType = DISPLAY_TYPE_ALL;
                     mDisplayInfo = null;
                 } else if (mDisplayGroupCurrentSelection
                         == DISPLAY_GROUP_INDEX_ALL_CONTACTS_WITH_PHONES) {
                     // Display all with phone numbers
-                    mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_ALL_WITH_PHONES;
+                    mDisplayType = DISPLAY_TYPE_ALL_WITH_PHONES;
                     mDisplayInfo = null;
                 } else if (mDisplayGroupsIncludesMyContacts &&
                         mDisplayGroupCurrentSelection == DISPLAY_GROUP_INDEX_MY_CONTACTS) {
-                    mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_SYSTEM_GROUP;
+                    mDisplayType = DISPLAY_TYPE_SYSTEM_GROUP;
                     mDisplayInfo = Groups.GROUP_MY_CONTACTS;
                 } else {
-                    mDisplayType = ContactsPreferenceActivity.DISPLAY_TYPE_USER_GROUP;
+                    mDisplayType = DISPLAY_TYPE_USER_GROUP;
                     mDisplayInfo = mDisplayGroups[mDisplayGroupCurrentSelection].toString();
                 }
 
                 // Save the changes to the preferences
                 SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
                 prefs.edit()
-                        .putInt(ContactsPreferenceActivity.PREF_DISPLAY_TYPE, mDisplayType)
-                        .putString(ContactsPreferenceActivity.PREF_DISPLAY_INFO, mDisplayInfo)
+                        .putInt(PREF_DISPLAY_TYPE, mDisplayType)
+                        .putString(PREF_DISPLAY_INFO, mDisplayInfo)
                         .commit();
 
                 // Update the display state
@@ -778,8 +813,8 @@
                     .setTitle(R.string.deleteConfirmation_title)
                     .setIcon(android.R.drawable.ic_dialog_alert)
                     .setMessage(R.string.deleteConfirmation)
-                    .setNegativeButton(R.string.noButton, null)
-                    .setPositiveButton(R.string.yesButton, new DeleteClickListener(uri))
+                    .setNegativeButton(android.R.string.cancel, null)
+                    .setPositiveButton(android.R.string.ok, new DeleteClickListener(uri))
                     .setCancelable(false)
                     .show();
                 return true;
@@ -810,8 +845,8 @@
                         .setTitle(R.string.deleteConfirmation_title)
                         .setIcon(android.R.drawable.ic_dialog_alert)
                         .setMessage(R.string.deleteConfirmation)
-                        .setNegativeButton(R.string.noButton, null)
-                        .setPositiveButton(R.string.yesButton, new DeleteClickListener(uri))
+                        .setNegativeButton(android.R.string.cancel, null)
+                        .setPositiveButton(android.R.string.ok, new DeleteClickListener(uri))
                         .setCancelable(false)
                         .show();
                     return true;
@@ -1159,7 +1194,7 @@
                     // The My Contacts group
                     groups.add(DISPLAY_GROUP_INDEX_MY_CONTACTS,
                             getString(R.string.groupNameMyContacts));
-                    if (mDisplayType == ContactsPreferenceActivity.DISPLAY_TYPE_SYSTEM_GROUP
+                    if (mDisplayType == DISPLAY_TYPE_SYSTEM_GROUP
                             && Groups.GROUP_MY_CONTACTS.equals(mDisplayInfo)) {
                         currentIndex = DISPLAY_GROUP_INDEX_MY_CONTACTS;
                     }
@@ -1180,25 +1215,29 @@
         }
     }
 
-    private final class QueryHandler extends AsyncQueryHandler {
+    private static final class QueryHandler extends AsyncQueryHandler {
+        private final WeakReference<ContactsListActivity> mActivity;
+
         public QueryHandler(Context context) {
             super(context.getContentResolver());
+            mActivity = new WeakReference<ContactsListActivity>((ContactsListActivity) context);
         }
 
         @Override
         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
-            if (!isFinishing()) {
-                mAdapter.setLoading(false);
-                mAdapter.changeCursor(cursor);
+            final ContactsListActivity activity = mActivity.get();
+            if (activity != null && !activity.isFinishing()) {
+                activity.mAdapter.setLoading(false);
+                activity.mAdapter.changeCursor(cursor);
     
                 // Now that the cursor is populated again, it's possible to restore the list state
-                if (mListState != null) {
-                    mList.onRestoreInstanceState(mListState);
-                    if (mListHasFocus) {
-                        mList.requestFocus();
+                if (activity.mListState != null) {
+                    activity.mList.onRestoreInstanceState(activity.mListState);
+                    if (activity.mListHasFocus) {
+                        activity.mList.requestFocus();
                     }
-                    mListHasFocus = false;
-                    mListState = null;
+                    activity.mListHasFocus = false;
+                    activity.mListState = null;
                 }
             } else {
                 cursor.close();
@@ -1216,20 +1255,22 @@
     }
 
     private final class ContactItemListAdapter extends ResourceCursorAdapter 
-            implements FastScrollView.SectionIndexer {
+            implements SectionIndexer {
         
-        private String [] mAlphabet;
         private AlphabetIndexer mIndexer;
+        private String mAlphabet;
         private boolean mLoading = true;
         private CharSequence mUnknownNameText;
         private CharSequence[] mLocalizedLabels;
 
         public ContactItemListAdapter(Context context, int resource, Cursor cursor) {
             super(context, resource, cursor);
-            getAlphabet(context);
+            
+            mAlphabet = context.getString(com.android.internal.R.string.fast_scroll_alphabet);
             if (cursor != null) {
                 mIndexer = new AlphabetIndexer(cursor, NAME_COLUMN_INDEX, mAlphabet);
             }
+            
             mUnknownNameText = context.getText(android.R.string.unknownName);
             switch (mMode) {
                 case MODE_PICK_POSTAL:
@@ -1249,22 +1290,20 @@
 
         @Override
         public boolean isEmpty() {
-            if (mLoading) {
-                // We don't want the empty state to show when loading.
+            if ((mMode & MODE_MASK_CREATE_NEW) == MODE_MASK_CREATE_NEW) {
+                // This mode mask adds a header and we always want it to show up, even
+                // if the list is empty, so always claim the list is not empty.
                 return false;
             } else {
-                return super.isEmpty();
+                if (mLoading) {
+                    // We don't want the empty state to show when loading.
+                    return false;
+                } else {
+                    return super.isEmpty();
+                }
             }
         }
         
-        private void getAlphabet(Context context) {
-            String alphabetString = context.getResources().getString(R.string.alphabet);
-            mAlphabet = new String[alphabetString.length()];
-            for (int i = 0; i < mAlphabet.length; i++) {
-                mAlphabet[i] = String.valueOf(alphabetString.charAt(i));
-            }
-        }
-
         @Override
         public View newView(Context context, Cursor cursor, ViewGroup parent) {
             final View view = super.newView(context, cursor, parent);
@@ -1377,8 +1416,8 @@
             if (mMode == MODE_STREQUENT) {
                 return new String[] { " " };
             } else {
-                return mAlphabet;
-            }
+                return mIndexer.getSections();
+           }
         }
         
         public int getPositionForSection(int sectionIndex) {
@@ -1395,7 +1434,7 @@
                 mIndexer = new AlphabetIndexer(cursor, NAME_COLUMN_INDEX, mAlphabet);
             }
 
-            return mIndexer.indexOf(sectionIndex);
+            return mIndexer.getPositionForSection(sectionIndex);
         }
         
         public int getSectionForPosition(int position) {
diff --git a/src/com/android/contacts/ContactsLiveFolders.java b/src/com/android/contacts/ContactsLiveFolders.java
new file mode 100644
index 0000000..8ca199a
--- /dev/null
+++ b/src/com/android/contacts/ContactsLiveFolders.java
@@ -0,0 +1,112 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.contacts;
+
+import android.content.Intent;
+import android.content.Context;
+import android.net.Uri;
+import android.app.Activity;
+import android.os.Bundle;
+import android.provider.LiveFolders;
+import android.provider.Contacts;
+
+public class ContactsLiveFolders {
+    public static class StarredContacts extends Activity {
+        public static final Uri CONTENT_URI =
+                Uri.parse("content://contacts/live_folders/favorites");
+
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            final Intent intent = getIntent();
+            final String action = intent.getAction();
+
+            if (LiveFolders.ACTION_CREATE_LIVE_FOLDER.equals(action)) {
+                setResult(RESULT_OK, createLiveFolder(this, CONTENT_URI,
+                        getString(R.string.liveFolder_favorites_label),
+                        R.drawable.ic_launcher_contacts_starred));
+            } else {
+                setResult(RESULT_CANCELED);
+            }
+
+            finish();
+        }
+    }
+
+    public static class PhoneContacts extends Activity {
+        public static final Uri CONTENT_URI =
+                Uri.parse("content://contacts/live_folders/people_with_phones");
+
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            final Intent intent = getIntent();
+            final String action = intent.getAction();
+
+            if (LiveFolders.ACTION_CREATE_LIVE_FOLDER.equals(action)) {
+                setResult(RESULT_OK, createLiveFolder(this, CONTENT_URI,
+                        getString(R.string.liveFolder_phones_label),
+                        R.drawable.ic_launcher_contacts_phones));
+            } else {
+                setResult(RESULT_CANCELED);
+            }
+
+            finish();
+        }
+    }
+
+    public static class AllContacts extends Activity {
+        public static final Uri CONTENT_URI =
+                Uri.parse("content://contacts/live_folders/people");
+
+        @Override
+        protected void onCreate(Bundle savedInstanceState) {
+            super.onCreate(savedInstanceState);
+
+            final Intent intent = getIntent();
+            final String action = intent.getAction();
+
+            if (LiveFolders.ACTION_CREATE_LIVE_FOLDER.equals(action)) {
+                setResult(RESULT_OK, createLiveFolder(this, CONTENT_URI,
+                        getString(R.string.liveFolder_all_label),
+                        R.drawable.ic_launcher_contacts));
+            } else {
+                setResult(RESULT_CANCELED);
+            }
+
+            finish();
+        }
+    }
+
+    private static Intent createLiveFolder(Context context, Uri uri, String name,
+            int icon) {
+
+        final Intent intent = new Intent();
+
+        intent.setData(uri);
+        intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_BASE_INTENT, new Intent(Intent.ACTION_VIEW,
+                Contacts.People.CONTENT_URI));
+        intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_NAME, name);
+        intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_ICON,
+                Intent.ShortcutIconResource.fromContext(context, icon));
+        intent.putExtra(LiveFolders.EXTRA_LIVE_FOLDER_DISPLAY_MODE, LiveFolders.DISPLAY_MODE_LIST);
+
+        return intent;
+    }
+}
diff --git a/src/com/android/contacts/ContactsPreferenceActivity.java b/src/com/android/contacts/ContactsPreferenceActivity.java
deleted file mode 100644
index b625fe5..0000000
--- a/src/com/android/contacts/ContactsPreferenceActivity.java
+++ /dev/null
@@ -1,55 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.contacts;
-
-import android.os.Bundle;
-import android.preference.PreferenceActivity;
-
-public final class ContactsPreferenceActivity extends PreferenceActivity {
-    /**
-     * The type of data to display in the main contacts list. 
-     */
-    static final String PREF_DISPLAY_TYPE = "display_system_group";
-
-    /** Unknown display type. */
-    static final int DISPLAY_TYPE_UNKNOWN = -1;
-    /** Display all contacts */
-    static final int DISPLAY_TYPE_ALL = 0;
-    /** Display all contacts that have phone numbers */
-    static final int DISPLAY_TYPE_ALL_WITH_PHONES = 1;
-    /** Display a system group */
-    static final int DISPLAY_TYPE_SYSTEM_GROUP = 2;
-    /** Display a user group */
-    static final int DISPLAY_TYPE_USER_GROUP = 3;
-
-    /**
-     * Info about what to display. If {@link #PREF_DISPLAY_TYPE}
-     * is {@link #DISPLAY_TYPE_SYSTEM_GROUP} then this will be the system id.
-     * If {@link #PREF_DISPLAY_TYPE} is {@link #DISPLAY_TYPE_USER_GROUP} then this will
-     * be the group name.
-     */ 
-    static final String PREF_DISPLAY_INFO = "display_group";
-
-    @Override
-    protected void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        
-        // Load the preferences from an XML resource
-        addPreferencesFromResource(R.xml.preferences);
-    }
-
-}
diff --git a/src/com/android/contacts/EditContactActivity.java b/src/com/android/contacts/EditContactActivity.java
index c301473..3a7610d 100644
--- a/src/com/android/contacts/EditContactActivity.java
+++ b/src/com/android/contacts/EditContactActivity.java
@@ -86,6 +86,7 @@
 import android.view.View;
 import android.view.ViewGroup;
 import android.view.ViewParent;
+import android.view.inputmethod.EditorInfo;
 import android.widget.Button;
 import android.widget.CheckBox;
 import android.widget.EditText;
@@ -144,12 +145,6 @@
     public static final int MENU_ITEM_ADD = 5;
     public static final int MENU_ITEM_PHOTO = 6;
     
-    // Key listener types
-    final static int INPUT_TEXT = 1;
-    final static int INPUT_TEXT_WORDS = 2;
-    final static int INPUT_TEXT_SENTENCES = 3;
-    final static int INPUT_DIALER = 4;
-
     /** Used to represent an invalid type for a contact entry */
     private static final int INVALID_TYPE = -1;
     
@@ -171,7 +166,7 @@
     
     private EditText mNameView;
     private ImageView mPhotoImageView;
-    private Button mPhotoButton;
+    private View mPhotoButton;
     private CheckBox mSendToVoicemailCheckBox;
     private LinearLayout mLayout;
     private LayoutInflater mInflater;
@@ -258,7 +253,7 @@
                 mPhotoMenuItem.setIcon(android.R.drawable.ic_menu_delete);
             } else {
                 mPhotoMenuItem.setTitle(R.string.addPicture);
-                mPhotoMenuItem.setIcon(android.R.drawable.ic_menu_add);
+                mPhotoMenuItem.setIcon(R.drawable.ic_menu_add_picture);
             }
         }
     }
@@ -310,7 +305,7 @@
         mPhotoImageView = (ImageView) findViewById(R.id.photoImage);
         mPhotoImageView.setOnClickListener(this);
         mPhotoImageView.setVisibility(View.GONE);
-        mPhotoButton = (Button) findViewById(R.id.photoButton);
+        mPhotoButton = findViewById(R.id.photoButton);
         mPhotoButton.setOnClickListener(this);
         mSendToVoicemailCheckBox = (CheckBox) findViewById(R.id.send_to_voicemail);
 
@@ -532,7 +527,7 @@
             new AlertDialog.Builder(EditContactActivity.this)
                 .setTitle(R.string.errorDialogTitle)
                 .setMessage(R.string.photoPickerNotFoundText)
-                .setPositiveButton(R.string.okButtonText, null)
+                .setPositiveButton(android.R.string.ok, null)
                 .show();
         }
     }
@@ -607,8 +602,8 @@
                         .setTitle(R.string.deleteConfirmation_title)
                         .setIcon(android.R.drawable.ic_dialog_alert)
                         .setMessage(R.string.deleteConfirmation)
-                        .setNegativeButton(R.string.noButton, null)
-                        .setPositiveButton(R.string.yesButton, mDeleteContactDialogListener)
+                        .setNegativeButton(android.R.string.cancel, null)
+                        .setPositiveButton(android.R.string.ok, mDeleteContactDialogListener)
                         .setCancelable(false)
                         .create();
         }
@@ -713,7 +708,7 @@
                     case OTHER_ORGANIZATION:
                         entry = EditEntry.newOrganizationEntry(EditContactActivity.this,
                                 Uri.withAppendedPath(mUri, Organizations.CONTENT_DIRECTORY),
-                                ContactMethods.TYPE_WORK);
+                                Organizations.TYPE_WORK);
                         mOtherEntries.add(entry);
                         break;
 
@@ -874,7 +869,7 @@
         new AlertDialog.Builder(this)
                 .setView(label)
                 .setTitle(R.string.customLabelPickerTitle)
-                .setPositiveButton(R.string.okButtonText, new DialogInterface.OnClickListener() {
+                .setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
                     public void onClick(DialogInterface dialog, int which) {
                         entry.setLabel(EditContactActivity.this, ContactMethods.TYPE_CUSTOM,
                                 label.getText().toString());
@@ -885,7 +880,7 @@
                         }
                     }
                 })
-                .setNegativeButton(R.string.cancelButtonText, null)
+                .setNegativeButton(android.R.string.cancel, null)
                 .show();
     }
     
@@ -1004,10 +999,10 @@
 
         // Add the contact to the group that is being displayed in the contact list
         SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
-        int displayType = prefs.getInt(ContactsPreferenceActivity.PREF_DISPLAY_TYPE,
-                ContactsPreferenceActivity.DISPLAY_TYPE_UNKNOWN);
-        if (displayType == ContactsPreferenceActivity.DISPLAY_TYPE_USER_GROUP) {
-            String displayGroup = prefs.getString(ContactsPreferenceActivity.PREF_DISPLAY_INFO,
+        int displayType = prefs.getInt(ContactsListActivity.PREF_DISPLAY_TYPE,
+                ContactsListActivity.DISPLAY_TYPE_UNKNOWN);
+        if (displayType == ContactsListActivity.DISPLAY_TYPE_USER_GROUP) {
+            String displayGroup = prefs.getString(ContactsListActivity.PREF_DISPLAY_INFO,
                     null);
             if (!TextUtils.isEmpty(displayGroup)) {
                 People.addToGroup(mResolver, ContentUris.parseId(contactUri), displayGroup);
@@ -1311,42 +1306,20 @@
         }
 
         // Email entries from extras
-        CharSequence email = extras.getCharSequence(Insert.EMAIL);
-        int emailType = extras.getInt(Insert.EMAIL_TYPE, INVALID_TYPE);
-        if (!TextUtils.isEmpty(email) && emailType == INVALID_TYPE) {
-            emailType = DEFAULT_EMAIL_TYPE;
-            mPrimaryEmailAdded = true;
-        }
+        addEmailFromExtras(extras, methodsUri, Insert.EMAIL, Insert.EMAIL_TYPE,
+                Insert.EMAIL_ISPRIMARY);
+        addEmailFromExtras(extras, methodsUri, Insert.SECONDARY_EMAIL, Insert.SECONDARY_EMAIL_TYPE,
+                null);
+        addEmailFromExtras(extras, methodsUri, Insert.TERTIARY_EMAIL, Insert.TERTIARY_EMAIL_TYPE,
+                null);
    
-        if (emailType != INVALID_TYPE) {
-            entry = EditEntry.newEmailEntry(this, null, emailType, email.toString(), methodsUri, 0);
-            entry.isPrimary = extras.getBoolean(Insert.EMAIL_ISPRIMARY);
-            mEmailEntries.add(entry);
-
-            // Keep track of which primary types have been added
-            if (entry.isPrimary) {
-                mPrimaryEmailAdded = true;
-            }
-        }
-   
-        // Phone entries from extras 
-        CharSequence phoneNumber = extras.getCharSequence(Insert.PHONE);
-        int phoneType = extras.getInt(Insert.PHONE_TYPE, INVALID_TYPE);
-        if (!TextUtils.isEmpty(phoneNumber) && phoneType == INVALID_TYPE) {
-            phoneType = DEFAULT_PHONE_TYPE;
-        }
-   
-        if (phoneType != INVALID_TYPE) {
-            entry = EditEntry.newPhoneEntry(this, null, phoneType,
-                    phoneNumber.toString(), phonesUri, 0);
-            entry.isPrimary = extras.getBoolean(Insert.PHONE_ISPRIMARY);
-            mPhoneEntries.add(entry);
-
-            // Keep track of which primary types have been added
-            if (phoneType == Phones.TYPE_MOBILE) {
-                mMobilePhoneAdded = true;
-            }
-        }
+        // Phone entries from extras
+        addPhoneFromExtras(extras, phonesUri, Insert.PHONE, Insert.PHONE_TYPE,
+                Insert.PHONE_ISPRIMARY);
+        addPhoneFromExtras(extras, phonesUri, Insert.SECONDARY_PHONE, Insert.SECONDARY_PHONE_TYPE,
+                null);
+        addPhoneFromExtras(extras, phonesUri, Insert.TERTIARY_PHONE, Insert.TERTIARY_PHONE_TYPE,
+                null);
 
         // IM entries from extras
         CharSequence imHandle = extras.getCharSequence(Insert.IM_HANDLE);
@@ -1368,6 +1341,49 @@
         }
     }
 
+    private void addEmailFromExtras(Bundle extras, Uri methodsUri, String emailField,
+            String typeField, String primaryField) {
+        CharSequence email = extras.getCharSequence(emailField);
+        int emailType = extras.getInt(typeField, INVALID_TYPE);
+        if (!TextUtils.isEmpty(email) && emailType == INVALID_TYPE) {
+            emailType = DEFAULT_EMAIL_TYPE;
+            mPrimaryEmailAdded = true;
+        }
+
+        if (emailType != INVALID_TYPE) {
+            EditEntry entry = EditEntry.newEmailEntry(this, null, emailType, email.toString(),
+                    methodsUri, 0);
+            entry.isPrimary = (primaryField == null) ? false : extras.getBoolean(primaryField);
+            mEmailEntries.add(entry);
+
+            // Keep track of which primary types have been added
+            if (entry.isPrimary) {
+                mPrimaryEmailAdded = true;
+            }
+        }
+    }
+
+    private void addPhoneFromExtras(Bundle extras, Uri phonesUri, String phoneField,
+            String typeField, String primaryField) {
+        CharSequence phoneNumber = extras.getCharSequence(phoneField);
+        int phoneType = extras.getInt(typeField, INVALID_TYPE);
+        if (!TextUtils.isEmpty(phoneNumber) && phoneType == INVALID_TYPE) {
+            phoneType = DEFAULT_PHONE_TYPE;
+        }
+
+        if (phoneType != INVALID_TYPE) {
+            EditEntry entry = EditEntry.newPhoneEntry(this, null, phoneType,
+                    phoneNumber.toString(), phonesUri, 0);
+            entry.isPrimary = (primaryField == null) ? false : extras.getBoolean(primaryField);
+            mPhoneEntries.add(entry);
+
+            // Keep track of which primary types have been added
+            if (phoneType == Phones.TYPE_MOBILE) {
+                mMobilePhoneAdded = true;
+            }
+        }
+    }
+
     /**
      * Removes all existing views, builds new ones for all the entries, and adds them.
      */
@@ -1475,42 +1491,20 @@
                 data2.setLines(entry.lines);
                 data2.setMaxLines(entry.maxLines);
             }
-        } else if (entry.lines >= 0) {
-            data.setSingleLine();
-            if (data2 != null) {
-                data2.setSingleLine();
-            }
         }
-        switch (entry.keyListener) {
-            case INPUT_TEXT:
-                data.setKeyListener(TextKeyListener.getInstance());
-                if (data2 != null) {
-                    data2.setKeyListener(TextKeyListener.getInstance());
-                }
-                break;
-                
-            case INPUT_TEXT_WORDS:
-                data.setKeyListener(TextKeyListener.getInstance(true, Capitalize.WORDS));
-                if (data2 != null) {
-                    data2.setKeyListener(TextKeyListener.getInstance(true, Capitalize.WORDS));
-                }
-                break;
-                
-            case INPUT_TEXT_SENTENCES:
-                data.setKeyListener(TextKeyListener.getInstance(true, Capitalize.SENTENCES));
-                if (data2 != null) {
-                    data2.setKeyListener(TextKeyListener.getInstance(true, Capitalize.SENTENCES));
-                }
-                break;
-                
-            case INPUT_DIALER:
-                data.setKeyListener(DialerKeyListener.getInstance());
+        int contentType = entry.contentType;
+        if (contentType != EditorInfo.TYPE_NULL) {
+            data.setInputType(contentType);
+            if (data2 != null) {
+                data2.setInputType(contentType);
+            }
+            if ((contentType&EditorInfo.TYPE_MASK_CLASS)
+                    == EditorInfo.TYPE_CLASS_PHONE) {
                 data.addTextChangedListener(new PhoneNumberFormattingTextWatcher());
                 if (data2 != null) {
-                    data2.setKeyListener(DialerKeyListener.getInstance());
                     data2.addTextChangedListener(new PhoneNumberFormattingTextWatcher());
                 }
-                break;
+            }
         }
 
         // Hook up the delete button
@@ -1569,7 +1563,7 @@
         public String column;
         public String contentDirectory;
         public String data2;
-        public int keyListener;
+        public int contentType;
         public int type;
         /**
          * If 0 or 1, setSingleLine will be called. If negative, setSingleLine
@@ -1614,7 +1608,7 @@
             parcel.writeString(column);
             parcel.writeString(contentDirectory);
             parcel.writeString(data2);
-            parcel.writeInt(keyListener);
+            parcel.writeInt(contentType);
             parcel.writeInt(type);
             parcel.writeInt(lines);
             parcel.writeInt(isPrimary ? 1 : 0);
@@ -1637,7 +1631,7 @@
                 entry.column = in.readString();
                 entry.contentDirectory = in.readString();
                 entry.data2 = in.readString();
-                entry.keyListener = in.readInt();
+                entry.contentType = in.readInt();
                 entry.type = in.readInt();
                 entry.lines = in.readInt();
                 entry.isPrimary = in.readInt() == 1;
@@ -1834,7 +1828,8 @@
             entry.column = Organizations.COMPANY;
             entry.contentDirectory = Organizations.CONTENT_DIRECTORY;
             entry.kind = Contacts.KIND_ORGANIZATION;
-            entry.keyListener = INPUT_TEXT_WORDS;
+            entry.contentType = EditorInfo.TYPE_CLASS_TEXT
+                    | EditorInfo.TYPE_TEXT_FLAG_CAP_WORDS;
             return entry;
         }
 
@@ -1853,7 +1848,9 @@
             entry.lines = 2;
             entry.id = 0;
             entry.kind = KIND_CONTACT;
-            entry.keyListener = INPUT_TEXT_SENTENCES;
+            entry.contentType = EditorInfo.TYPE_CLASS_TEXT
+                    | EditorInfo.TYPE_TEXT_FLAG_CAP_SENTENCES
+                    | EditorInfo.TYPE_TEXT_FLAG_MULTI_LINE;
             entry.isStaticLabel = true;
             return entry;
         }
@@ -1894,7 +1891,7 @@
             entry.column = People.Phones.NUMBER;
             entry.contentDirectory = People.Phones.CONTENT_DIRECTORY;
             entry.kind = Contacts.KIND_PHONE;
-            entry.keyListener = INPUT_DIALER;
+            entry.contentType = EditorInfo.TYPE_CLASS_PHONE;
             return entry;
         }
 
@@ -1917,7 +1914,8 @@
             entry.column = ContactMethods.DATA;
             entry.contentDirectory = People.ContactMethods.CONTENT_DIRECTORY;
             entry.kind = Contacts.KIND_EMAIL;
-            entry.keyListener = INPUT_TEXT;
+            entry.contentType = EditorInfo.TYPE_CLASS_TEXT
+                    | EditorInfo.TYPE_TEXT_VARIATION_EMAIL_ADDRESS;
             return entry;
         }
 
@@ -1946,7 +1944,10 @@
             entry.column = ContactMethods.DATA;
             entry.contentDirectory = People.ContactMethods.CONTENT_DIRECTORY;
             entry.kind = Contacts.KIND_POSTAL;
-            entry.keyListener = INPUT_TEXT_WORDS;
+            entry.contentType = EditorInfo.TYPE_CLASS_TEXT
+                    | EditorInfo.TYPE_TEXT_VARIATION_POSTAL_ADDRESS
+                    | EditorInfo.TYPE_TEXT_FLAG_CAP_WORDS
+                    | EditorInfo.TYPE_TEXT_FLAG_MULTI_LINE;
             entry.maxLines = 4;
             entry.lines = 2;
             return entry;
@@ -1969,7 +1970,7 @@
             entry.column = ContactMethods.DATA;
             entry.contentDirectory = People.ContactMethods.CONTENT_DIRECTORY;
             entry.kind = Contacts.KIND_IM;
-            entry.keyListener = INPUT_TEXT;
+            entry.contentType = EditorInfo.TYPE_CLASS_TEXT;
             return entry;
         }
     }
diff --git a/src/com/android/contacts/FastScrollView.java b/src/com/android/contacts/FastScrollView.java
deleted file mode 100644
index f45e947..0000000
--- a/src/com/android/contacts/FastScrollView.java
+++ /dev/null
@@ -1,450 +0,0 @@
-/*
- * Copyright (C) 2008 The Android Open Source Project
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *      http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package com.android.contacts;
-
-import android.content.Context;
-import android.content.res.Resources;
-import android.graphics.Canvas;
-import android.graphics.Paint;
-import android.graphics.RectF;
-import android.graphics.drawable.Drawable;
-import android.os.Handler;
-import android.os.SystemClock;
-import android.util.AttributeSet;
-import android.view.MotionEvent;
-import android.view.View;
-import android.view.ViewGroup.OnHierarchyChangeListener;
-import android.widget.AbsListView;
-import android.widget.Adapter;
-import android.widget.BaseAdapter;
-import android.widget.FrameLayout;
-import android.widget.HeaderViewListAdapter;
-import android.widget.ListView;
-import android.widget.AbsListView.OnScrollListener;
-
-/**
- * FastScrollView is meant for embedding {@link ListView}s that contain a large number of 
- * items that can be indexed in some fashion. It displays a special scroll bar that allows jumping
- * quickly to indexed sections of the list in touch-mode. Only one child can be added to this 
- * view group and it must be a {@link ListView}, with an adapter that is derived from 
- * {@link BaseAdapter}.
- */
-public class FastScrollView extends FrameLayout 
-        implements OnScrollListener, OnHierarchyChangeListener {
-
-    private Drawable mCurrentThumb;
-    private Drawable mOverlayDrawable;
-
-    private int mThumbH;
-    private int mThumbW;
-    private int mThumbY;
-
-    private RectF mOverlayPos;
-    
-    // Hard coding these for now
-    private int mOverlaySize = 104;
-
-    private boolean mDragging;
-    private ListView mList;
-    private boolean mScrollCompleted;
-    private boolean mThumbVisible;
-    private int mVisibleItem;
-    private Paint mPaint;
-    private int mListOffset;
-    
-    private Object [] mSections;
-    private String mSectionText;
-    private boolean mDrawOverlay;
-    private ScrollFade mScrollFade;
-    
-    private Handler mHandler = new Handler();
-    
-    private BaseAdapter mListAdapter;
-
-    private boolean mChangedBounds;
-
-    interface SectionIndexer {
-        Object[] getSections();
-        
-        int getPositionForSection(int section);
-        
-        int getSectionForPosition(int position);
-    }
-    
-    public FastScrollView(Context context) {
-        super(context);
-
-        init(context);
-    }
-
-
-    public FastScrollView(Context context, AttributeSet attrs) {
-        super(context, attrs);
-        
-        init(context);
-    }
-
-    public FastScrollView(Context context, AttributeSet attrs, int defStyle) {
-        super(context, attrs, defStyle);
-
-        init(context);
-    }
-
-    private void useThumbDrawable(Drawable drawable) {
-        mCurrentThumb = drawable;
-        mThumbW = 64; //mCurrentThumb.getIntrinsicWidth();
-        mThumbH = 52; //mCurrentThumb.getIntrinsicHeight();
-        mChangedBounds = true;
-    }
-
-    private void init(Context context) {
-        // Get both the scrollbar states drawables
-        final Resources res = context.getResources();
-        useThumbDrawable(res.getDrawable(
-                com.android.internal.R.drawable.scrollbar_handle_accelerated_anim2));
-        
-        mOverlayDrawable = res.getDrawable(R.drawable.dialog_full_dark);
-        
-        mScrollCompleted = true;
-        setWillNotDraw(false);
-        
-        // Need to know when the ListView is added
-        setOnHierarchyChangeListener(this);
-        
-        mOverlayPos = new RectF();
-        mScrollFade = new ScrollFade();
-        mPaint = new Paint();
-        mPaint.setAntiAlias(true);
-        mPaint.setTextAlign(Paint.Align.CENTER);
-        mPaint.setTextSize(mOverlaySize / 2);
-        mPaint.setColor(0xFFFFFFFF);
-        mPaint.setStyle(Paint.Style.FILL_AND_STROKE);
-    }
-    
-    private void removeThumb() {
-        
-        mThumbVisible = false;
-        // Draw one last time to remove thumb
-        invalidate();
-    }
-    
-    @Override
-    public void draw(Canvas canvas) {
-        super.draw(canvas);
-        
-        if (!mThumbVisible) {
-            // No need to draw the rest
-            return;
-        }
-
-        final int y = mThumbY;
-        final int viewWidth = getWidth();
-        final FastScrollView.ScrollFade scrollFade = mScrollFade;
-
-        int alpha = -1;
-        if (scrollFade.mStarted) {
-            alpha = scrollFade.getAlpha();
-            if (alpha < ScrollFade.ALPHA_MAX / 2) {
-                mCurrentThumb.setAlpha(alpha * 2);
-            }
-            int left = viewWidth - (mThumbW * alpha) / ScrollFade.ALPHA_MAX;
-            mCurrentThumb.setBounds(left, 0, viewWidth, mThumbH);
-            mChangedBounds = true;
-        }
-
-        canvas.translate(0, y);
-        mCurrentThumb.draw(canvas);
-        canvas.translate(0, -y);
-
-        // If user is dragging the scroll bar, draw the alphabet overlay
-        if (mDragging && mDrawOverlay) {
-            mOverlayDrawable.draw(canvas);
-            final Paint paint = mPaint;
-            float descent = paint.descent();
-            final RectF rectF = mOverlayPos;
-            canvas.drawText(mSectionText, (int) (rectF.left + rectF.right) / 2,
-                    (int) (rectF.bottom + rectF.top) / 2 + mOverlaySize / 4 - descent, paint);
-        } else if (alpha == 0) {
-            scrollFade.mStarted = false;
-            removeThumb();
-        } else {
-            invalidate(viewWidth - mThumbW, y, viewWidth, y + mThumbH);            
-        }
-    }
-
-    @Override
-    protected void onSizeChanged(int w, int h, int oldw, int oldh) {
-        super.onSizeChanged(w, h, oldw, oldh);
-        if (mCurrentThumb != null) {
-            mCurrentThumb.setBounds(w - mThumbW, 0, w, mThumbH);
-        }
-        final RectF pos = mOverlayPos;
-        pos.left = (w - mOverlaySize) / 2;
-        pos.right = pos.left + mOverlaySize;
-        pos.top = h / 10; // 10% from top
-        pos.bottom = pos.top + mOverlaySize;
-        mOverlayDrawable.setBounds((int) pos.left, (int) pos.top,
-                (int) pos.right, (int) pos.bottom);
-    }
-    
-    public void onScrollStateChanged(AbsListView view, int scrollState) {
-    }
-    
-    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, 
-            int totalItemCount) {
-        
-        if (totalItemCount - visibleItemCount > 0 && !mDragging) {
-            mThumbY = ((getHeight() - mThumbH) * firstVisibleItem) / (totalItemCount - visibleItemCount);
-            if (mChangedBounds) {
-                final int viewWidth = getWidth();
-                mCurrentThumb.setBounds(viewWidth - mThumbW, 0, viewWidth, mThumbH);
-                mChangedBounds = false;
-            }
-        }
-        mScrollCompleted = true;
-        if (firstVisibleItem == mVisibleItem) {
-            return;
-        }
-        mVisibleItem = firstVisibleItem;
-        if (!mThumbVisible || mScrollFade.mStarted) {
-            mThumbVisible = true;
-            mCurrentThumb.setAlpha(ScrollFade.ALPHA_MAX);
-        }
-        mHandler.removeCallbacks(mScrollFade);
-        mScrollFade.mStarted = false;
-        if (!mDragging) {
-            mHandler.postDelayed(mScrollFade, 1500);
-        }
-    }
-
-    
-    private void getSections() {
-        Adapter adapter = mList.getAdapter();
-        if (adapter instanceof HeaderViewListAdapter) {
-            mListOffset = ((HeaderViewListAdapter)adapter).getHeadersCount();
-            adapter = ((HeaderViewListAdapter)adapter).getWrappedAdapter();
-        }
-        if (adapter instanceof SectionIndexer) {
-            mListAdapter = (BaseAdapter) adapter;
-            mSections = ((SectionIndexer) mListAdapter).getSections();
-        }
-    }
-    
-    public void onChildViewAdded(View parent, View child) {
-        if (child instanceof ListView) {
-            mList = (ListView)child;
-            
-            mList.setOnScrollListener(this);
-            getSections();
-        }
-    }
-
-    public void onChildViewRemoved(View parent, View child) {
-        if (child == mList) {
-            mList = null;
-            mListAdapter = null;
-            mSections = null;
-        }
-    }
-    
-    @Override
-    public boolean onInterceptTouchEvent(MotionEvent ev) {
-        if (mThumbVisible && ev.getAction() == MotionEvent.ACTION_DOWN) {
-            if (ev.getX() > getWidth() - mThumbW && ev.getY() >= mThumbY &&
-                    ev.getY() <= mThumbY + mThumbH) {
-                mDragging = true;
-                return true;
-            }            
-        }
-        return false;
-    }
-
-    private void scrollTo(float position) {
-        int count = mList.getCount();
-        mScrollCompleted = false;
-        final Object[] sections = mSections;
-        int sectionIndex;
-        if (sections != null && sections.length > 1) {
-            final int nSections = sections.length;
-            int section = (int) (position * nSections);
-            if (section >= nSections) {
-                section = nSections - 1;
-            }
-            sectionIndex = section;
-            final SectionIndexer baseAdapter = (SectionIndexer) mListAdapter;
-            int index = baseAdapter.getPositionForSection(section);
-            
-            // Given the expected section and index, the following code will
-            // try to account for missing sections (no names starting with..)
-            // It will compute the scroll space of surrounding empty sections
-            // and interpolate the currently visible letter's range across the
-            // available space, so that there is always some list movement while
-            // the user moves the thumb.
-            int nextIndex = count;
-            int prevIndex = index;
-            int prevSection = section;
-            int nextSection = section + 1;
-            // Assume the next section is unique
-            if (section < nSections - 1) {
-                nextIndex = baseAdapter.getPositionForSection(section + 1);
-            }
-            
-            // Find the previous index if we're slicing the previous section
-            if (nextIndex == index) {
-                // Non-existent letter
-                while (section > 0) {
-                    section--;
-                     prevIndex = baseAdapter.getPositionForSection(section);
-                     if (prevIndex != index) {
-                         prevSection = section;
-                         sectionIndex = section;
-                         break;
-                     }
-                }
-            }
-            // Find the next index, in case the assumed next index is not
-            // unique. For instance, if there is no P, then request for P's 
-            // position actually returns Q's. So we need to look ahead to make
-            // sure that there is really a Q at Q's position. If not, move 
-            // further down...
-            int nextNextSection = nextSection + 1;
-            while (nextNextSection < nSections &&
-                    baseAdapter.getPositionForSection(nextNextSection) == nextIndex) {
-                nextNextSection++;
-                nextSection++;
-            }
-            // Compute the beginning and ending scroll range percentage of the
-            // currently visible letter. This could be equal to or greater than
-            // (1 / nSections). 
-            float fPrev = (float) prevSection / nSections;
-            float fNext = (float) nextSection / nSections;
-            index = prevIndex + (int) ((nextIndex - prevIndex) * (position - fPrev) 
-                    / (fNext - fPrev));
-            // Don't overflow
-            if (index > count - 1) index = count - 1;
-            
-            mList.setSelectionFromTop(index + mListOffset, 0);
-        } else {
-            int index = (int) (position * count);
-            mList.setSelectionFromTop(index + mListOffset, 0);
-            sectionIndex = -1;
-        }
-
-        if (sectionIndex >= 0) {
-            String text = mSectionText = sections[sectionIndex].toString();
-            mDrawOverlay = (text.length() != 1 || text.charAt(0) != ' ') &&
-                    sectionIndex < sections.length;
-        } else {
-            mDrawOverlay = false;
-        }
-    }
-
-    private void cancelFling() {
-        // Cancel the list fling
-        MotionEvent cancelFling = MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0, 0, 0);
-        mList.onTouchEvent(cancelFling);
-        cancelFling.recycle();
-    }
-    
-    @Override
-    public boolean onTouchEvent(MotionEvent me) {
-        if (me.getAction() == MotionEvent.ACTION_DOWN) {
-            if (me.getX() > getWidth() - mThumbW
-                    && me.getY() >= mThumbY 
-                    && me.getY() <= mThumbY + mThumbH) {
-                
-                mDragging = true;
-                if (mListAdapter == null && mList != null) {
-                    getSections();
-                }
-
-                cancelFling();
-                return true;
-            }
-        } else if (me.getAction() == MotionEvent.ACTION_UP) {
-            if (mDragging) {
-                mDragging = false;
-                final Handler handler = mHandler;
-                handler.removeCallbacks(mScrollFade);
-                handler.postDelayed(mScrollFade, 1000);
-                return true;
-            }
-        } else if (me.getAction() == MotionEvent.ACTION_MOVE) {
-            if (mDragging) {
-                final int viewHeight = getHeight();
-                mThumbY = (int) me.getY() - mThumbH + 10;
-                if (mThumbY < 0) {
-                    mThumbY = 0;
-                } else if (mThumbY + mThumbH > viewHeight) {
-                    mThumbY = viewHeight - mThumbH;
-                }
-                // If the previous scrollTo is still pending
-                if (mScrollCompleted) {
-                    scrollTo((float) mThumbY / (viewHeight - mThumbH));
-                }
-                return true;
-            }
-        }
-        
-        return super.onTouchEvent(me);
-    }
-    
-    public class ScrollFade implements Runnable {
-        
-        long mStartTime;
-        long mFadeDuration;
-        boolean mStarted;
-        static final int ALPHA_MAX = 255;
-        static final long FADE_DURATION = 200;
-        
-        void startFade() {
-            mFadeDuration = FADE_DURATION;
-            mStartTime = SystemClock.uptimeMillis();
-            mStarted = true;
-        }
-        
-        int getAlpha() {
-            if (!mStarted) {
-                return ALPHA_MAX;
-            }
-            int alpha;
-            long now = SystemClock.uptimeMillis();
-            if (now > mStartTime + mFadeDuration) {
-                alpha = 0;
-            } else {
-                alpha = (int) (ALPHA_MAX - ((now - mStartTime) * ALPHA_MAX) / mFadeDuration); 
-            }
-            return alpha;
-        }
-        
-        public void run() {
-            if (!mStarted) {
-                startFade();
-                invalidate();
-            }
-            
-            if (getAlpha() > 0) {
-                final int y = mThumbY;
-                final int viewWidth = getWidth();
-                invalidate(viewWidth - mThumbW, y, viewWidth, y + mThumbH);
-            } else {
-                mStarted = false;
-                removeThumb();
-            }
-        }
-    }
-}
diff --git a/src/com/android/contacts/RecentCallsListActivity.java b/src/com/android/contacts/RecentCallsListActivity.java
index 32ecd97..550a385 100644
--- a/src/com/android/contacts/RecentCallsListActivity.java
+++ b/src/com/android/contacts/RecentCallsListActivity.java
@@ -32,13 +32,13 @@
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.os.SystemClock;
-import android.pim.DateUtils;
 import android.provider.CallLog.Calls;
 import android.provider.Contacts.People;
 import android.provider.Contacts.Phones;
 import android.provider.Contacts.Intents.Insert;
 import android.telephony.TelephonyManager;
 import android.text.TextUtils;
+import android.text.format.DateUtils;
 import android.util.Log;
 import android.view.ContextMenu;
 import android.view.KeyEvent;
@@ -60,14 +60,15 @@
 
 import java.util.HashMap;
 import java.util.LinkedList;
+import java.lang.ref.WeakReference;
 
 /**
  * Displays a list of call log entries.
  */
-public class RecentCallsListActivity extends ListActivity 
+public class RecentCallsListActivity extends ListActivity
         implements View.OnCreateContextMenuListener {
     private static final String TAG = "RecentCallsList";
-    
+
     /** The projection to use when querying the call log table */
     static final String[] CALL_LOG_PROJECTION = new String[] {
             Calls._ID,
@@ -79,7 +80,7 @@
             Calls.CACHED_NUMBER_TYPE,
             Calls.CACHED_NUMBER_LABEL
     };
-    
+
     static final int ID_COLUMN_INDEX = 0;
     static final int NUMBER_COLUMN_INDEX = 1;
     static final int DATE_COLUMN_INDEX = 2;
@@ -97,7 +98,7 @@
             Phones.LABEL,
             Phones.NUMBER
     };
-    
+
     static final int PERSON_ID_COLUMN_INDEX = 0;
     static final int NAME_COLUMN_INDEX = 1;
     static final int PHONE_TYPE_COLUMN_INDEX = 2;
@@ -107,20 +108,20 @@
     private static final int MENU_ITEM_DELETE = 1;
     private static final int MENU_ITEM_DELETE_ALL = 2;
     private static final int MENU_ITEM_VIEW_CONTACTS = 3;
-    
+
     private static final int QUERY_TOKEN = 53;
     private static final int UPDATE_TOKEN = 54;
 
     private RecentCallsAdapter mAdapter;
     private QueryHandler mQueryHandler;
     private String mVoiceMailNumber;
-    
+
     private CharSequence[] mLabelArray;
-    
+
     private Drawable mDrawableIncoming;
     private Drawable mDrawableOutgoing;
-    private Drawable mDrawableMissed;    
-    
+    private Drawable mDrawableMissed;
+
     private static final class ContactInfo {
         public long personId;
         public String name;
@@ -137,8 +138,8 @@
         TextView durationView;
         TextView dateView;
         ImageView iconView;
-    }    
-    
+    }
+
     private static final class CallerInfoQuery {
         String number;
         int position;
@@ -148,25 +149,26 @@
     }
 
     /** Adapter class to fill in data for the Call Log */
-    private final class RecentCallsAdapter extends ResourceCursorAdapter 
+    private final class RecentCallsAdapter extends ResourceCursorAdapter
             implements Runnable, ViewTreeObserver.OnPreDrawListener {
         HashMap<String,ContactInfo> mContactInfo;
-        private LinkedList<CallerInfoQuery> mRequests;
-        private boolean mDone;
+        private final LinkedList<CallerInfoQuery> mRequests;
+        private volatile boolean mDone;
         private boolean mLoading = true;
         ViewTreeObserver.OnPreDrawListener mPreDrawListener;
         private static final int REDRAW = 1;
         private static final int START_THREAD = 2;
         private boolean mFirst;
-        
+        private Thread mCallerIdThread;
+
         public boolean onPreDraw() {
             if (mFirst) {
                 mHandler.sendEmptyMessageDelayed(START_THREAD, 1000);
                 mFirst = false;
             }
-            return true;            
+            return true;
         }
-        
+
         private Handler mHandler = new Handler() {
             @Override
             public void handleMessage(Message msg) {
@@ -180,7 +182,7 @@
                 }
             }
         };
-        
+
         public RecentCallsAdapter() {
             super(RecentCallsListActivity.this, R.layout.recent_calls_list_item, null);
 
@@ -192,7 +194,7 @@
         void setLoading(boolean loading) {
             mLoading = loading;
         }
-        
+
         @Override
         public boolean isEmpty() {
             if (mLoading) {
@@ -209,13 +211,14 @@
 
         public void startRequestProcessing() {
             mDone = false;
-            Thread callerIdThread = new Thread(this);
-            callerIdThread.setPriority(Thread.MIN_PRIORITY);
-            callerIdThread.start();
+            mCallerIdThread = new Thread(this);
+            mCallerIdThread.setPriority(Thread.MIN_PRIORITY);
+            mCallerIdThread.start();
         }
 
         public void stopRequestProcessing() {
             mDone = true;
+            if (mCallerIdThread != null) mCallerIdThread.interrupt();
         }
 
         public void clearCache() {
@@ -226,7 +229,7 @@
 
         private void updateCallLog(CallerInfoQuery ciq, ContactInfo ci) {
             // Check if they are different. If not, don't update.
-            if (TextUtils.equals(ciq.name, ci.name) 
+            if (TextUtils.equals(ciq.name, ci.name)
                     && TextUtils.equals(ciq.numberLabel, ci.label)
                     && ciq.numberType == ci.type) {
                 return;
@@ -236,10 +239,10 @@
             values.put(Calls.CACHED_NUMBER_TYPE, ci.type);
             values.put(Calls.CACHED_NUMBER_LABEL, ci.label);
             RecentCallsListActivity.this.getContentResolver().update(
-                    Calls.CONTENT_URI, 
+                    Calls.CONTENT_URI,
                     values, Calls.NUMBER + "='" + ciq.number + "'", null);
         }
-        
+
         private void enqueueRequest(String number, int position,
                 String name, int numberType, String numberLabel) {
             CallerInfoQuery ciq = new CallerInfoQuery();
@@ -253,7 +256,7 @@
                 mRequests.notifyAll();
             }
         }
-        
+
         private void queryContactInfo(CallerInfoQuery ciq) {
             // First check if there was a prior request for the same number
             // that was already satisfied
@@ -265,9 +268,9 @@
                     }
                 }
             } else {
-                Cursor phonesCursor = 
+                Cursor phonesCursor =
                     RecentCallsListActivity.this.getContentResolver().query(
-                            Uri.withAppendedPath(Phones.CONTENT_FILTER_URL, 
+                            Uri.withAppendedPath(Phones.CONTENT_FILTER_URL,
                                     ciq.number),
                     PHONES_PROJECTION, null, null, null);
                 if (phonesCursor != null) {
@@ -278,7 +281,7 @@
                         info.type = phonesCursor.getInt(PHONE_TYPE_COLUMN_INDEX);
                         info.label = phonesCursor.getString(LABEL_COLUMN_INDEX);
                         info.number = phonesCursor.getString(MATCHED_NUMBER_COLUMN_INDEX);
-                        
+
                         mContactInfo.put(ciq.number, info);
                         // Inform list to update this item, if in view
                         synchronized (mRequests) {
@@ -310,7 +313,7 @@
                             mRequests.wait(1000);
                         } catch (InterruptedException ie) {
                             // Ignore and continue processing requests
-                        }                        
+                        }
                     }
                 }
                 if (ciq != null) {
@@ -318,11 +321,11 @@
                 }
             }
         }
-        
+
         @Override
         public View newView(Context context, Cursor cursor, ViewGroup parent) {
             View view = super.newView(context, cursor, parent);
-            
+
             // Get the views to bind to
             RecentCallsListItemViews views = new RecentCallsListItemViews();
             views.line1View = (TextView) view.findViewById(R.id.line1);
@@ -336,7 +339,7 @@
             return view;
         }
 
-        
+
         @Override
         public void bindView(View view, Context context, Cursor c) {
             final RecentCallsListItemViews views = (RecentCallsListItemViews) view.getTag();
@@ -345,7 +348,7 @@
             String callerName = c.getString(CALLER_NAME_COLUMN_INDEX);
             int callerNumberType = c.getInt(CALLER_NUMBERTYPE_COLUMN_INDEX);
             String callerNumberLabel = c.getString(CALLER_NUMBERLABEL_COLUMN_INDEX);
-            
+
             // Lookup contacts with this number
             ContactInfo info = mContactInfo.get(number);
             if (info == null) {
@@ -359,11 +362,11 @@
                 // Check if any data is different from the data cached in the
                 // calls db. If so, queue the request so that we can update
                 // the calls db.
-                if (!TextUtils.equals(info.name, callerName) 
+                if (!TextUtils.equals(info.name, callerName)
                         || info.type != callerNumberType
                         || !TextUtils.equals(info.label, callerNumberLabel)) {
                     // Something is amiss, so sync up.
-                    enqueueRequest(number, c.getPosition(), 
+                    enqueueRequest(number, c.getPosition(),
                             callerName, callerNumberType, callerNumberLabel);
                 }
             }
@@ -382,7 +385,7 @@
             // Set the text lines
             if (!TextUtils.isEmpty(name)) {
                 views.line1View.setText(name);
-                CharSequence numberLabel = Phones.getDisplayLabel(context, ntype, label, 
+                CharSequence numberLabel = Phones.getDisplayLabel(context, ntype, label,
                         mLabelArray);
                 if (!TextUtils.isEmpty(numberLabel)) {
                     views.line2View.setText(numberLabel);
@@ -447,7 +450,7 @@
                     views.iconView.setImageDrawable(mDrawableMissed);
                     break;
             }
-            // Listen for the first draw 
+            // Listen for the first draw
             if (mPreDrawListener == null) {
                 mFirst = true;
                 mPreDrawListener = this;
@@ -455,17 +458,23 @@
             }
         }
     }
-    
-    private final class QueryHandler extends AsyncQueryHandler {
+
+    private static final class QueryHandler extends AsyncQueryHandler {
+        private final WeakReference<RecentCallsListActivity> mActivity;
+
         public QueryHandler(Context context) {
             super(context.getContentResolver());
+            mActivity = new WeakReference<RecentCallsListActivity>(
+                    (RecentCallsListActivity) context);
         }
 
         @Override
         protected void onQueryComplete(int token, Object cookie, Cursor cursor) {
-            if (!isFinishing()) {
-                mAdapter.setLoading(false);
-                mAdapter.changeCursor(cursor);    
+            final RecentCallsListActivity activity = mActivity.get();
+            if (activity != null && !activity.isFinishing()) {
+                final RecentCallsListActivity.RecentCallsAdapter callsAdapter = activity.mAdapter;
+                callsAdapter.setLoading(false);
+                callsAdapter.changeCursor(cursor);
             } else {
                 cursor.close();
             }
@@ -477,12 +486,12 @@
         super.onCreate(state);
 
         setContentView(R.layout.recent_calls);
-        
+
         mDrawableIncoming = getResources().getDrawable(android.R.drawable.sym_call_incoming);
         mDrawableOutgoing = getResources().getDrawable(android.R.drawable.sym_call_outgoing);
         mDrawableMissed = getResources().getDrawable(android.R.drawable.sym_call_missed);
         mLabelArray = getResources().getTextArray(com.android.internal.R.array.phoneTypes);
-        
+
         // Typing here goes to the dialer
         setDefaultKeyMode(DEFAULT_KEYS_DIALER);
 
@@ -505,21 +514,25 @@
 
         startQuery();
         resetNewCallsFlag();
-        
+
         super.onResume();
         try {
-            ITelephony.Stub.asInterface(ServiceManager.getService("phone"))
-                    .cancelMissedCallsNotification();
+            ITelephony iTelephony = ITelephony.Stub.asInterface(ServiceManager.getService("phone"));
+            if (iTelephony != null) {
+                iTelephony.cancelMissedCallsNotification();
+            } else {
+                Log.w(TAG, "Telephony service is null, can't call cancelMissedCallsNotification");
+            }
         } catch (RemoteException e) {
             Log.e(TAG, "Failed to clear missed calls notification due to remote excetpion");
         }
         mAdapter.mPreDrawListener = null; // Let it restart the thread after next draw
     }
-    
+
     @Override
     protected void onPause() {
         super.onPause();
-        
+
         // Kill the requests thread
         mAdapter.stopRequestProcessing();
     }
@@ -527,6 +540,7 @@
     @Override
     protected void onDestroy() {
         super.onDestroy();
+        mAdapter.stopRequestProcessing();
         Cursor cursor = mAdapter.getCursor();
         if (cursor != null && !cursor.isClosed()) {
             cursor.close();
@@ -541,19 +555,19 @@
 
         ContentValues values = new ContentValues(1);
         values.put(Calls.NEW, "0");
-        mQueryHandler.startUpdate(UPDATE_TOKEN, null, Calls.CONTENT_URI, 
+        mQueryHandler.startUpdate(UPDATE_TOKEN, null, Calls.CONTENT_URI,
                 values, where.toString(), null);
     }
 
     private void startQuery() {
         mAdapter.setLoading(true);
-        
+
         // Cancel any pending queries
         mQueryHandler.cancelOperation(QUERY_TOKEN);
-        mQueryHandler.startQuery(QUERY_TOKEN, null, Calls.CONTENT_URI, 
+        mQueryHandler.startQuery(QUERY_TOKEN, null, Calls.CONTENT_URI,
                 CALL_LOG_PROJECTION, null, null, Calls.DEFAULT_SORT_ORDER);
     }
-    
+
     @Override
     public boolean onCreateOptionsMenu(Menu menu) {
         menu.add(0, MENU_ITEM_DELETE_ALL, 0, R.string.recentCalls_deleteAll)
@@ -589,7 +603,7 @@
         }
 
         ContactInfo info = mAdapter.getContactInfo(number);
-        boolean contactInfoPresent = (info != null && info != ContactInfo.EMPTY); 
+        boolean contactInfoPresent = (info != null && info != ContactInfo.EMPTY);
         if (contactInfoPresent) {
             menu.setHeaderTitle(info.name);
         } else {
@@ -631,7 +645,7 @@
             case MENU_ITEM_DELETE_ALL: {
                 getContentResolver().delete(Calls.CONTENT_URI, null, null);
                 //TODO The change notification should do this automatically, but it isn't working
-                // right now. Remove this when the change notification is working properly. 
+                // right now. Remove this when the change notification is working properly.
                 startQuery();
                 return true;
             }
@@ -704,17 +718,17 @@
                 } catch (RemoteException re) {
                     // Fall through and try to call the contact
                 }
-                
+
                 callEntry(getListView().getSelectedItemPosition());
                 return true;
         }
         return super.onKeyUp(keyCode, event);
     }
-    
+
     /*
      * Get the number from the Contacts, if available, since sometimes
      * the number provided by caller id may not be formatted properly
-     * depending on the carrier (roaming) in use at the time of the 
+     * depending on the carrier (roaming) in use at the time of the
      * incoming call.
      * Logic : If the caller-id number starts with a "+", use it
      *         Else if the number in the contacts starts with a "+", use that one
@@ -728,9 +742,9 @@
             matchingNumber = ci.number;
         } else {
             try {
-                Cursor phonesCursor = 
+                Cursor phonesCursor =
                     RecentCallsListActivity.this.getContentResolver().query(
-                            Uri.withAppendedPath(Phones.CONTENT_FILTER_URL, 
+                            Uri.withAppendedPath(Phones.CONTENT_FILTER_URL,
                                     number),
                     PHONES_PROJECTION, null, null, null);
                 if (phonesCursor != null) {
@@ -743,14 +757,14 @@
                 // Use the number from the call log
             }
         }
-        if (!TextUtils.isEmpty(matchingNumber) && 
-                (matchingNumber.startsWith("+") 
+        if (!TextUtils.isEmpty(matchingNumber) &&
+                (matchingNumber.startsWith("+")
                         || matchingNumber.length() > number.length())) {
             number = matchingNumber;
         }
         return number;
     }
-    
+
     private void callEntry(int position) {
         if (position < 0) {
             // In touch mode you may often not have something selected, so
@@ -769,8 +783,8 @@
             }
 
             int callType = cursor.getInt(CALL_TYPE_COLUMN_INDEX);
-            if (!number.startsWith("+") && 
-                    (callType == Calls.INCOMING_TYPE 
+            if (!number.startsWith("+") &&
+                    (callType == Calls.INCOMING_TYPE
                             || callType == Calls.MISSED_TYPE)) {
                 // If the caller-id matches a contact with a better qualified number, use it
                 number = getBetterNumberFromContacts(number);
diff --git a/src/com/android/contacts/SpecialCharSequenceMgr.java b/src/com/android/contacts/SpecialCharSequenceMgr.java
index e23d460..38bc93d 100644
--- a/src/com/android/contacts/SpecialCharSequenceMgr.java
+++ b/src/com/android/contacts/SpecialCharSequenceMgr.java
@@ -193,7 +193,7 @@
         AlertDialog alert = new AlertDialog.Builder(context)
                 .setTitle(R.string.imei)
                 .setMessage(imeiStr)
-                .setPositiveButton(R.string.ok, null)
+                .setPositiveButton(android.R.string.ok, null)
                 .setCancelable(false)
                 .show();
         alert.getWindow().setType(WindowManager.LayoutParams.TYPE_PRIORITY_PHONE);
diff --git a/src/com/android/contacts/TwelveKeyDialer.java b/src/com/android/contacts/TwelveKeyDialer.java
index caa77a1..41adc5a 100644
--- a/src/com/android/contacts/TwelveKeyDialer.java
+++ b/src/com/android/contacts/TwelveKeyDialer.java
@@ -18,10 +18,12 @@
 
 import android.app.Activity;
 import android.content.ActivityNotFoundException;
-
+import android.content.Context;
 import android.content.Intent;
 import android.content.res.Resources;
 import android.database.Cursor;
+import android.graphics.Bitmap;
+import android.graphics.BitmapFactory;
 import android.graphics.drawable.Drawable;
 import android.media.AudioManager;
 import android.media.ToneGenerator;
@@ -29,32 +31,45 @@
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
+import android.os.RemoteException;
+import android.os.ServiceManager;
 import android.os.SystemClock;
-import android.provider.Settings;
+import android.provider.Contacts.Intents.Insert;
 import android.provider.Contacts.People;
 import android.provider.Contacts.Phones;
 import android.provider.Contacts.PhonesColumns;
-import android.provider.Contacts.Intents.Insert;
+import android.provider.Settings;
 import android.telephony.PhoneNumberFormattingTextWatcher;
 import android.telephony.PhoneNumberUtils;
+import android.telephony.PhoneStateListener;
+import android.telephony.TelephonyManager;
 import android.text.Editable;
-import android.text.Selection;
 import android.text.TextUtils;
 import android.text.TextWatcher;
 import android.text.method.DialerKeyListener;
 import android.util.Log;
 import android.view.KeyEvent;
+import android.view.LayoutInflater;
 import android.view.Menu;
 import android.view.MenuItem;
 import android.view.View;
 import android.view.ViewConfiguration;
+import android.view.ViewGroup;
+import android.widget.AdapterView;
+import android.widget.BaseAdapter;
 import android.widget.EditText;
+import android.widget.ImageView;
+import android.widget.ListView;
+import android.widget.TextView;
+
+import com.android.internal.telephony.ITelephony;
 
 /**
  * Dialer activity that displays the typical twelve key interface.
  */
 public class TwelveKeyDialer extends Activity implements View.OnClickListener,
-        View.OnLongClickListener, View.OnKeyListener, TextWatcher {
+        View.OnLongClickListener, View.OnKeyListener,
+        AdapterView.OnItemClickListener, TextWatcher {
 
     private static final String TAG = "TwelveKeyDialer";
     
@@ -75,7 +90,11 @@
     private Drawable mDigitsEmptyBackground;
     private Drawable mDeleteBackground;
     private Drawable mDeleteEmptyBackground;
-    
+    private View mDigitsAndBackspace;
+    private View mDialpad;
+    private ListView mDialpadChooser;
+    private DialpadChooserAdapter mDialpadChooserAdapter;
+
     // determines if we want to playback local DTMF tones.
     private boolean mDTMFToneEnabled;
     
@@ -84,6 +103,29 @@
     /** Indicates if we are opening this dialer to add a call from the InCallScreen. */
     private boolean mIsAddCallMode;
 
+    PhoneStateListener mPhoneStateListener = new PhoneStateListener() {
+            /**
+             * Listen for phone state changes so that we can take down the
+             * "dialpad chooser" if the phone becomes idle while the
+             * chooser UI is visible.
+             */
+            @Override
+            public void onCallStateChanged(int state, String incomingNumber) {
+                // Log.i(TAG, "PhoneStateListener.onCallStateChanged: "
+                //       + state + ", '" + incomingNumber + "'");
+                if ((state == TelephonyManager.CALL_STATE_IDLE) && dialpadChooserVisible()) {
+                    // Log.i(TAG, "Call ended with dialpad chooser visible!  Taking it down...");
+                    // Note there's a race condition in the UI here: the
+                    // dialpad chooser could conceivably disappear (on its
+                    // own) at the exact moment the user was trying to select
+                    // one of the choices, which would be confusing.  (But at
+                    // least that's better than leaving the dialpad chooser
+                    // onscreen, but useless...)
+                    showDialpadChooser(false);
+                }
+            }
+        };
+
     public void beforeTextChanged(CharSequence s, int start, int count, int after) {
         // Do nothing
     }
@@ -148,6 +190,17 @@
         view.setOnLongClickListener(this);
         mDelete = view;
 
+        mDigitsAndBackspace = (View) findViewById(R.id.digitsAndBackspace);
+        mDialpad = (View) findViewById(R.id.dialpad);  // This is null in landscape mode
+
+        // Set up the "dialpad chooser" UI; see showDialpadChooser().
+        mDialpadChooser = (ListView) findViewById(R.id.dialpadChooser);
+        mDialpadChooser.setOnItemClickListener(this);
+        // Add a dummy "footer" view so that the divider under the bottom
+        // item will be visible.
+        // (We set android:footerDividersEnabled="true" on this ListView in XML.)
+        mDialpadChooser.addFooterView(new View(this), null, false);
+
         if (!resolveIntent() && icicle != null) {
             super.onRestoreInstanceState(icicle);
         }
@@ -206,10 +259,14 @@
         } else {
             intent = getIntent();
         }
+        // Log.i(TAG, "==> resolveIntent(): intent: " + intent);
 
         // by default we are not adding a call.
         mIsAddCallMode = false;
-        
+
+        // By default we don't show the "dialpad chooser" UI.
+        boolean needToShowDialpadChooser = false;
+
         // Resolve the intent
         final String action = intent.getAction();
         if (Intent.ACTION_DIAL.equals(action) || Intent.ACTION_VIEW.equals(action)) {
@@ -238,8 +295,26 @@
                     }
                 }
             }
+        } else if (Intent.ACTION_MAIN.equals(action)) {
+            // The MAIN action means we're bringing up a blank dialer
+            // (e.g. by selecting the Home shortcut, or tabbing over from
+            // Contacts or Call log.)
+            //
+            // At this point, IF there's already an active call, there's a
+            // good chance that the user got here accidentally (but really
+            // wanted the in-call dialpad instead).  So we bring up an
+            // intermediate UI to make the user confirm what they really
+            // want to do.
+            if (phoneIsInUse()) {
+                // Log.i(TAG, "resolveIntent(): phone is in use; showing dialpad chooser!");
+                needToShowDialpadChooser = true;
+            }
         }
 
+        // Bring up the "dialpad chooser" IFF we need to make the user
+        // confirm which dialpad they really want.
+        showDialpadChooser(needToShowDialpadChooser);
+
         return ignoreState;
     }
 
@@ -326,12 +401,42 @@
                 resolveIntent();
             }
         }
+
+        // While we're in the foreground, listen for phone state changes,
+        // purely so that we can take down the "dialpad chooser" if the
+        // phone becomes idle while the chooser UI is visible.
+        TelephonyManager telephonyManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
+        telephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_CALL_STATE);
+
+        // Potentially show hint text in the mDigits field when the user
+        // hasn't typed any digits yet.  (If there's already an active call,
+        // this hint text will remind the user that he's about to add a new
+        // call.)
+        //
+        // TODO: consider adding better UI for the case where *both* lines
+        // are currently in use.  (Right now we let the user try to add
+        // another call, but that call is guaranteed to fail.  Perhaps the
+        // entire dialer UI should be disabled instead.)
+        if (phoneIsInUse()) {
+            mDigits.setHint(R.string.dialerDialpadHintText);
+        } else {
+            // Common case; no hint necessary.
+            mDigits.setHint(null);
+
+            // Also, a sanity-check: the "dialpad chooser" UI should NEVER
+            // be visible if the phone is idle!
+            showDialpadChooser(false);
+        }
     }
 
     @Override
     protected void onPause() {
         super.onPause();
 
+        // Stop listening for phone state changes.
+        TelephonyManager telephonyManager = (TelephonyManager) getSystemService(TELEPHONY_SERVICE);
+        telephonyManager.listen(mPhoneStateListener, PhoneStateListener.LISTEN_NONE);
+
         synchronized(mToneGeneratorLock) {
             if (mToneGenerator != null) {
                 mToneStopper.removeMessages(STOP_TONE);
@@ -351,6 +456,11 @@
 
     @Override
     public boolean onPrepareOptionsMenu(Menu menu) {
+        // We never show a menu if the "choose dialpad" UI is up.
+        if (dialpadChooserVisible()) {
+            return false;
+        }
+
         CharSequence digits = mDigits.getText();
         if (digits == null || !TextUtils.isGraphic(digits)) {
             mAddToContactMenuItem.setVisible(false);
@@ -591,5 +701,217 @@
             mToneStopper.sendEmptyMessageDelayed(STOP_TONE, TONE_LENGTH_MS);
         }
     }
-}
 
+    /**
+     * Brings up the "dialpad chooser" UI in place of the usual Dialer
+     * elements (the textfield/button and the dialpad underneath).
+     *
+     * We show this UI if the user brings up the Dialer while a call is
+     * already in progress, since there's a good chance we got here
+     * accidentally (and the user really wanted the in-call dialpad instead).
+     * So in this situation we display an intermediate UI that lets the user
+     * explicitly choose between the in-call dialpad ("Use touch tone
+     * keypad") and the regular Dialer ("Add call").  (Or, the option "Return
+     * to call in progress" just goes back to the in-call UI with no dialpad
+     * at all.)
+     *
+     * @param enabled If true, show the "dialpad chooser" instead
+     *                of the regular Dialer UI
+     */
+    private void showDialpadChooser(boolean enabled) {
+        if (enabled) {
+            // Log.i(TAG, "Showing dialpad chooser!");
+            mDigitsAndBackspace.setVisibility(View.GONE);
+            if (mDialpad != null) mDialpad.setVisibility(View.GONE);
+            mDialpadChooser.setVisibility(View.VISIBLE);
+
+            // Instantiate the DialpadChooserAdapter and hook it up to the
+            // ListView.  We do this only once.
+            if (mDialpadChooserAdapter == null) {
+                mDialpadChooserAdapter = new DialpadChooserAdapter(this);
+                mDialpadChooser.setAdapter(mDialpadChooserAdapter);
+            }
+        } else {
+            // Log.i(TAG, "Displaying normal Dialer UI.");
+            mDigitsAndBackspace.setVisibility(View.VISIBLE);
+            if (mDialpad != null) mDialpad.setVisibility(View.VISIBLE);
+            mDialpadChooser.setVisibility(View.GONE);
+        }
+    }
+
+    /**
+     * @return true if we're currently showing the "dialpad chooser" UI.
+     */
+    private boolean dialpadChooserVisible() {
+        return mDialpadChooser.getVisibility() == View.VISIBLE;
+    }
+
+    /**
+     * Simple list adapter, binding to an icon + text label
+     * for each item in the "dialpad chooser" list.
+     */
+    private static class DialpadChooserAdapter extends BaseAdapter {
+        private LayoutInflater mInflater;
+
+        // Simple struct for a single "choice" item.
+        static class ChoiceItem {
+            String text;
+            Bitmap icon;
+            int id;
+
+            public ChoiceItem(String s, Bitmap b, int i) {
+                text = s;
+                icon = b;
+                id = i;
+            }
+        }
+
+        // IDs for the possible "choices":
+        static final int DIALPAD_CHOICE_USE_DTMF_DIALPAD = 101;
+        static final int DIALPAD_CHOICE_RETURN_TO_CALL = 102;
+        static final int DIALPAD_CHOICE_ADD_NEW_CALL = 103;
+
+        private static final int NUM_ITEMS = 3;
+        private ChoiceItem mChoiceItems[] = new ChoiceItem[NUM_ITEMS];
+
+        public DialpadChooserAdapter(Context context) {
+            // Cache the LayoutInflate to avoid asking for a new one each time.
+            mInflater = LayoutInflater.from(context);
+
+            // Initialize the possible choices.
+            // TODO: could this be specified entirely in XML?
+
+            // - "Use touch tone keypad"
+            mChoiceItems[0] = new ChoiceItem(
+                    context.getString(R.string.dialer_useDtmfDialpad),
+                    BitmapFactory.decodeResource(context.getResources(),
+                                                 R.drawable.ic_dialer_fork_tt_keypad),
+                    DIALPAD_CHOICE_USE_DTMF_DIALPAD);
+
+            // - "Return to call in progress"
+            mChoiceItems[1] = new ChoiceItem(
+                    context.getString(R.string.dialer_returnToInCallScreen),
+                    BitmapFactory.decodeResource(context.getResources(),
+                                                 R.drawable.ic_dialer_fork_current_call),
+                    DIALPAD_CHOICE_RETURN_TO_CALL);
+
+            // - "Add call"
+            mChoiceItems[2] = new ChoiceItem(
+                    context.getString(R.string.dialer_addAnotherCall),
+                    BitmapFactory.decodeResource(context.getResources(),
+                                                 R.drawable.ic_dialer_fork_add_call),
+                    DIALPAD_CHOICE_ADD_NEW_CALL);
+        }
+
+        public int getCount() {
+            return NUM_ITEMS;
+        }
+
+        /**
+         * Return the ChoiceItem for a given position.
+         */
+        public Object getItem(int position) {
+            return mChoiceItems[position];
+        }
+
+        /**
+         * Return a unique ID for each possible choice.
+         */
+        public long getItemId(int position) {
+            return position;
+        }
+
+        /**
+         * Make a view for each row.
+         */
+        public View getView(int position, View convertView, ViewGroup parent) {
+            // When convertView is non-null, we can reuse it (there's no need
+            // to reinflate it.)
+            if (convertView == null) {
+                convertView = mInflater.inflate(R.layout.dialpad_chooser_list_item, null);
+            }
+
+            TextView text = (TextView) convertView.findViewById(R.id.text);
+            text.setText(mChoiceItems[position].text);
+
+            ImageView icon = (ImageView) convertView.findViewById(R.id.icon);
+            icon.setImageBitmap(mChoiceItems[position].icon);
+
+            return convertView;
+        }
+    }
+
+    /**
+     * Handle clicks from the dialpad chooser.
+     */
+    public void onItemClick(AdapterView parent, View v, int position, long id) {
+        DialpadChooserAdapter.ChoiceItem item =
+                (DialpadChooserAdapter.ChoiceItem) parent.getItemAtPosition(position);
+        int itemId = item.id;
+        switch (itemId) {
+            case DialpadChooserAdapter.DIALPAD_CHOICE_USE_DTMF_DIALPAD:
+                // Log.i(TAG, "DIALPAD_CHOICE_USE_DTMF_DIALPAD");
+                // Fire off an intent to go back to the in-call UI
+                // with the dialpad visible.
+                returnToInCallScreen(true);
+                break;
+
+            case DialpadChooserAdapter.DIALPAD_CHOICE_RETURN_TO_CALL:
+                // Log.i(TAG, "DIALPAD_CHOICE_RETURN_TO_CALL");
+                // Fire off an intent to go back to the in-call UI
+                // (with the dialpad hidden).
+                returnToInCallScreen(false);
+                break;
+
+            case DialpadChooserAdapter.DIALPAD_CHOICE_ADD_NEW_CALL:
+                // Log.i(TAG, "DIALPAD_CHOICE_ADD_NEW_CALL");
+                // Ok, guess the user really did want to be here (in the
+                // regular Dialer) after all.  Bring back the normal Dialer UI.
+                showDialpadChooser(false);
+                break;
+
+            default:
+                Log.w(TAG, "onItemClick: unexpected itemId: " + itemId);
+                break;
+        }
+    }
+
+    /**
+     * Returns to the in-call UI (where there's presumably a call in
+     * progress) in response to the user selecting "use touch tone keypad"
+     * or "return to call" from the dialpad chooser.
+     */
+    private void returnToInCallScreen(boolean showDialpad) {
+        try {
+            ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
+            if (phone != null) phone.showCallScreenWithDialpad(showDialpad);
+        } catch (RemoteException e) {
+            Log.w(TAG, "phone.showCallScreenWithDialpad() failed", e);
+        }
+
+        // Finally, finish() ourselves so that we don't stay on the
+        // activity stack.
+        // Note that we do this whether or not the showCallScreenWithDialpad()
+        // call above had any effect or not!  (That call is a no-op if the
+        // phone is idle, which can happen if the current call ends while
+        // the dialpad chooser is up.  In this case we can't show the
+        // InCallScreen, and there's no point staying here in the Dialer,
+        // so we just take the user back where he came from...)
+        finish();
+    }
+
+    /**
+     * @return true if the phone is "in use", meaning that at least one line
+     *              is active (ie. off hook or ringing or dialing).
+     */
+    private boolean phoneIsInUse() {
+        boolean phoneInUse = false;
+        try {
+            ITelephony phone = ITelephony.Stub.asInterface(ServiceManager.checkService("phone"));
+            if (phone != null) phoneInUse = !phone.isIdle();
+        } catch (RemoteException e) {
+            Log.w(TAG, "phone.isIdle() failed", e);
+        }
+        return phoneInUse;
+    }
+}
diff --git a/src/com/android/contacts/ViewContactActivity.java b/src/com/android/contacts/ViewContactActivity.java
index c1e9bc5..9a11f76 100644
--- a/src/com/android/contacts/ViewContactActivity.java
+++ b/src/com/android/contacts/ViewContactActivity.java
@@ -55,6 +55,8 @@
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
 import android.content.res.Resources;
 import android.database.ContentObserver;
 import android.database.Cursor;
@@ -91,6 +93,7 @@
 import android.widget.Toast;
 
 import java.util.ArrayList;
+import java.util.List;
 
 /**
  * Displays the details of a specific contact.
@@ -99,11 +102,25 @@
         implements View.OnCreateContextMenuListener, View.OnClickListener,
         DialogInterface.OnClickListener {
     private static final String TAG = "ViewContact";
+    private static final String SHOW_BARCODE_INTENT = "com.google.zxing.client.android.ENCODE";
+
+    private static final String[] PHONE_KEYS = {
+        Contacts.Intents.Insert.PHONE,
+        Contacts.Intents.Insert.SECONDARY_PHONE,
+        Contacts.Intents.Insert.TERTIARY_PHONE
+    };
+
+    private static final String[] EMAIL_KEYS = {
+        Contacts.Intents.Insert.EMAIL,
+        Contacts.Intents.Insert.SECONDARY_EMAIL,
+        Contacts.Intents.Insert.TERTIARY_EMAIL
+    };
 
     private static final int DIALOG_CONFIRM_DELETE = 1;
 
     public static final int MENU_ITEM_DELETE = 1;
     public static final int MENU_ITEM_MAKE_DEFAULT = 2;
+    public static final int MENU_ITEM_SHOW_BARCODE = 3;
 
     private Uri mUri;
     private ContentResolver mResolver;
@@ -256,8 +273,8 @@
                         .setTitle(R.string.deleteConfirmation_title)
                         .setIcon(android.R.drawable.ic_dialog_alert)
                         .setMessage(R.string.deleteConfirmation)
-                        .setNegativeButton(R.string.noButton, null)
-                        .setPositiveButton(R.string.yesButton, this)
+                        .setNegativeButton(android.R.string.cancel, null)
+                        .setPositiveButton(android.R.string.ok, this)
                         .setCancelable(false)
                         .create();
         }
@@ -310,6 +327,29 @@
     }
 
     @Override
+    public boolean onPrepareOptionsMenu(Menu menu) {
+        super.onPrepareOptionsMenu(menu);
+        // Perform this check each time the menu is about to be shown, because the Barcode Scanner
+        // could be installed or uninstalled at any time.
+        if (isBarcodeScannerInstalled()) {
+            if (menu.findItem(MENU_ITEM_SHOW_BARCODE) == null) {
+                menu.add(0, MENU_ITEM_SHOW_BARCODE, 0, R.string.menu_showBarcode)
+                        .setIcon(R.drawable.ic_menu_show_barcode);
+            }
+        } else {
+            menu.removeItem(MENU_ITEM_SHOW_BARCODE);
+        }
+        return true;
+    }
+
+    private boolean isBarcodeScannerInstalled() {
+        final Intent intent = new Intent(SHOW_BARCODE_INTENT);
+        List<ResolveInfo> list = getPackageManager().queryIntentActivities(intent,
+                PackageManager.MATCH_DEFAULT_ONLY);
+        return list.size() > 0;
+    }
+
+    @Override
     public void onCreateContextMenu(ContextMenu menu, View view, ContextMenuInfo menuInfo) {
         AdapterView.AdapterContextMenuInfo info;
         try {
@@ -356,6 +396,44 @@
                 showDialog(DIALOG_CONFIRM_DELETE);
                 return true;
             }
+            case MENU_ITEM_SHOW_BARCODE:
+                if (mCursor.moveToFirst()) {
+                    Intent intent = new Intent(SHOW_BARCODE_INTENT);
+                    intent.putExtra("ENCODE_TYPE", "CONTACT_TYPE");
+                    Bundle bundle = new Bundle();
+                    String name = mCursor.getString(CONTACT_NAME_COLUMN);
+                    if (!TextUtils.isEmpty(name)) {
+                        bundle.putString(Contacts.Intents.Insert.NAME, name);
+                        // The 0th ViewEntry in each ArrayList below is a separator item
+                        int entriesToAdd = Math.min(mPhoneEntries.size() - 1, PHONE_KEYS.length);
+                        for (int x = 0; x < entriesToAdd; x++) {
+                            ViewEntry entry = mPhoneEntries.get(x + 1);
+                            bundle.putString(PHONE_KEYS[x], entry.data);
+                        }
+                        entriesToAdd = Math.min(mEmailEntries.size() - 1, EMAIL_KEYS.length);
+                        for (int x = 0; x < entriesToAdd; x++) {
+                            ViewEntry entry = mEmailEntries.get(x + 1);
+                            bundle.putString(EMAIL_KEYS[x], entry.data);
+                        }
+                        if (mPostalEntries.size() >= 2) {
+                            ViewEntry entry = mPostalEntries.get(1);
+                            bundle.putString(Contacts.Intents.Insert.POSTAL, entry.data);
+                        }
+                        intent.putExtra("ENCODE_DATA", bundle);
+                        try {
+                            startActivity(intent);
+                        } catch (ActivityNotFoundException e) {
+                            // The check in onPrepareOptionsMenu() should make this impossible, but
+                            // for safety I'm catching the exception rather than crashing. Ideally
+                            // I'd call Menu.removeItem() here too, but I don't see a way to get
+                            // the options menu.
+                            Log.e(TAG, "Show barcode menu item was clicked but Barcode Scanner " +
+                                    "was not installed.");
+                        }
+                        return true;
+                    }
+                }
+                break;
         }
         return super.onOptionsItemSelected(item);
     }
