diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index e59e060..ef5e072 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -145,6 +145,8 @@
                 >
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
+                <action android:name="android.settings.INPUT_METHOD_SETTINGS" />
+                <category android:name="android.intent.category.VOICE_LAUNCH" />
                 <category android:name="android.intent.category.DEFAULT" />
             </intent-filter>
         </activity>
@@ -157,16 +159,6 @@
             </intent-filter>
         </activity>
 
-        <activity android:name="InputMethodsSettings" android:icon="@drawable/app_settings"
-                android:label="@string/input_methods_settings_title"
-                >
-            <intent-filter>
-                <action android:name="android.intent.action.MAIN" />
-                <action android:name="android.settings.INPUT_METHOD_SETTINGS" />
-                <category android:name="android.intent.category.VOICE_LAUNCH" />
-            </intent-filter>
-        </activity>
-
         <activity android:name="UserDictionarySettings" android:icon="@drawable/app_settings"
                 android:label="@string/user_dict_settings_titlebar">
             <intent-filter>
diff --git a/res/values-cs/strings.xml b/res/values-cs/strings.xml
index de79429..3c7ad2d 100644
--- a/res/values-cs/strings.xml
+++ b/res/values-cs/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Odpojeno"</string>
     <string name="bluetooth_disconnecting">"Odpojování..."</string>
     <string name="bluetooth_connecting">"Připojování..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Párovat s tímto zařízením"</string>
     <string name="bluetooth_pairing">"Párování..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"Volba časového pásma"</string>
     <string name="display_preview_label">"Náhled:"</string>
     <string name="display_font_size_label">"Velikost písma:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Odeslat <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"Umožňuje vybrat aplikace pro synchronizaci"</string>
     <string name="display_settings">"Nastavení zobrazení"</string>
     <string name="animations_title">"Animace"</string>
-    <string name="animations_summary_on">"Zobrazit animace otevírání a zavírání oken"</string>
-    <string name="animations_summary_off">"Animuje otevírání a zavírání oken"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Jas"</string>
     <string name="brightness_summary">"Nastavte jas displeje"</string>
     <string name="screen_timeout">"Interval vypnutí obrazovky"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"Název AP nemůže být prázdný."</string>
     <string name="error_mcc_not3">"Pole MCC musí obsahovat alespoň 3 číslice."</string>
     <string name="error_mnc_not23">"Pole MNC musí obsahovat 2 nebo 3 číslice."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Obnovení továrních dat"</string>
     <string name="master_clear_summary">"Umožňuje odstranit všechna data v telefonu"</string>
     <string name="master_clear_desc">"Tato akce obnoví výchozí tovární nastavení telefonu. Všechna data a stažené aplikace budou smazány."</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"Přidat nebo odebrat slova z uživatelského slovníku"</string>
     <string name="user_dict_settings_add_menu_title">"Přidat"</string>
     <string name="user_dict_settings_add_dialog_title">"Přidat do slovníku"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Upravit"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Smazat"</string>
     <string name="user_dict_settings_empty_text">"V uživatelském slovníku nejsou žádná slova. Slovo můžete přidat pomocí nabídky."</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Klávesové zkratky"</string>
     <string name="input_methods_settings_title">"Zadávání textu"</string>
     <string name="input_methods_settings_summary">"Správa možností zadávání textu"</string>
-    <string name="input_methods_settings_label_format">"%s: nastavení"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Vývoj"</string>
     <string name="development_settings_summary">"Umožňuje nastavit možnosti pro vývoj aplikace"</string>
     <string name="enable_adb">"Ladění USB"</string>
diff --git a/res/values-de/strings.xml b/res/values-de/strings.xml
index 60deacd..93a782c 100644
--- a/res/values-de/strings.xml
+++ b/res/values-de/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Nicht verbunden"</string>
     <string name="bluetooth_disconnecting">"Verbindung wird getrennt..."</string>
     <string name="bluetooth_connecting">"Verbindung wird hergestellt..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Pairing mit diesem Gerät"</string>
     <string name="bluetooth_pairing">"Pairing…"</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"Zeitzone auswählen"</string>
     <string name="display_preview_label">"Vorschau:"</string>
     <string name="display_font_size_label">"Schriftgröße:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"<xliff:g id="BROADCAST">broadcast</xliff:g> senden"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"Auswählen, welche Anwendungen synchronisiert werden"</string>
     <string name="display_settings">"Display-Einstellungen"</string>
     <string name="animations_title">"Animation"</string>
-    <string name="animations_summary_on">"Animation beim Öffnen/Schließen von Fenstern anzeigen"</string>
-    <string name="animations_summary_off">"Animation beim Öffnen/Schließen von Fenstern anzeigen"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Helligkeit"</string>
     <string name="brightness_summary">"Helligkeit des Bildschirms anpassen"</string>
     <string name="screen_timeout">"Display-Timeout"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"Der APN darf nicht leer sein."</string>
     <string name="error_mcc_not3">"Das MCC-Feld muss 3 Zeichen enthalten."</string>
     <string name="error_mnc_not23">"Das MNC-Feld muss 2 oder 3 Zeichen enthalten."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Auf Werkszustand zurück"</string>
     <string name="master_clear_summary">"Löscht alle Daten auf dem Telefon"</string>
     <string name="master_clear_desc">"Durch diese Aktion wird das Telefon auf den Werkszustand zurückgesetzt. Alle Daten und heruntergeladenen Anwendungen werden gelöscht!"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"Hinzufügen &amp; Entfernen von Wörtern im Wörterbuch des Nutzers"</string>
     <string name="user_dict_settings_add_menu_title">"Hinzufügen"</string>
     <string name="user_dict_settings_add_dialog_title">"Zum Wörterbuch hinzufügen"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Bearbeiten"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Löschen"</string>
     <string name="user_dict_settings_empty_text">"Sie haben keine Wörter im Nutzerwörterbuch. Sie können über das Menü ein Wort hinzufügen."</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Tastenkombinationen"</string>
     <string name="input_methods_settings_title">"Texteingabe"</string>
     <string name="input_methods_settings_summary">"Optionen für Texteingabe verwalten"</string>
-    <string name="input_methods_settings_label_format">"%s Einstellungen"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Entwicklung"</string>
     <string name="development_settings_summary">"Optionen zur Anwendungsentwicklung festlegen"</string>
     <string name="enable_adb">"USB-Debugging"</string>
diff --git a/res/values-es/strings.xml b/res/values-es/strings.xml
index eb4c8b1..5cb12cb 100644
--- a/res/values-es/strings.xml
+++ b/res/values-es/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Desconectada"</string>
     <string name="bluetooth_disconnecting">"Desconectando..."</string>
     <string name="bluetooth_connecting">"Estableciendo conexión..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Sincronizar con este dispositivo"</string>
     <string name="bluetooth_pairing">"Sincronizando..."</string>
@@ -110,7 +110,7 @@
     <string name="choose_timezone">"Seleccionar zona horaria"</string>
     <string name="display_preview_label">"Vista previa:"</string>
     <string name="display_font_size_label">"Tamaño de fuente:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Enviar <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -365,8 +365,16 @@
     <string name="sync_settings_summary">"Seleccionar las aplicaciones que están sincronizadas"</string>
     <string name="display_settings">"Configuración de pantalla"</string>
     <string name="animations_title">"Animación"</string>
-    <string name="animations_summary_on">"Mostrar animación al abrir o cerrar ventanas"</string>
-    <string name="animations_summary_off">"Mostrar animación al abrir o cerrar ventanas"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Brillo"</string>
     <string name="brightness_summary">"Ajustar el brillo de la pantalla"</string>
     <string name="screen_timeout">"Tiempo de espera de pantalla"</string>
@@ -455,6 +463,12 @@
     <string name="error_apn_empty">"El campo de APN no puede estar vacío."</string>
     <string name="error_mcc_not3">"El campo MMC debe contener 3 dígitos."</string>
     <string name="error_mnc_not23">"El campo MNC debe contener 2 ó 3 dígitos."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Restablecer datos de fábrica"</string>
     <string name="master_clear_summary">"Borrar todos los datos del teléfono"</string>
     <string name="master_clear_desc">"Esta acción restablecerá el teléfono a su estado de fábrica inicial y borrará todos los datos y todas las aplicaciones descargadas."</string>
@@ -591,6 +605,8 @@
     <string name="user_dict_settings_summary">"Añadir y eliminar palabras del diccionario del usuario"</string>
     <string name="user_dict_settings_add_menu_title">"Añadir"</string>
     <string name="user_dict_settings_add_dialog_title">"Añadir al usuario"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Editar"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Suprimir"</string>
     <string name="user_dict_settings_empty_text">"No tienes ninguna palabra en el diccionario del usuario. Puedes añadir una palabra a través del menú."</string>
@@ -611,7 +627,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Accesos directos"</string>
     <string name="input_methods_settings_title">"Introducción de texto"</string>
     <string name="input_methods_settings_summary">"Administrar opciones de introducción de texto"</string>
-    <string name="input_methods_settings_label_format">"Configuración de %s"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Desarrollo"</string>
     <string name="development_settings_summary">"Establecer opciones de desarrollo de aplicaciones"</string>
     <string name="enable_adb">"Depuración USB"</string>
diff --git a/res/values-fr/strings.xml b/res/values-fr/strings.xml
index 3feed96..388dee9 100644
--- a/res/values-fr/strings.xml
+++ b/res/values-fr/strings.xml
@@ -85,18 +85,18 @@
     <string name="bluetooth_visibility">"Identifiable"</string>
     <string name="bluetooth_is_discoverable">"Identifiable pendant <xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g> secondes..."</string>
     <string name="bluetooth_not_discoverable">"Permettre l\'identification de l\'appareil"</string>
-    <string name="bluetooth_devices">"Périphériques Bluetooth"</string>
-    <string name="bluetooth_device_name">"Nom du périphérique"</string>
+    <string name="bluetooth_devices">"Appareils Bluetooth"</string>
+    <string name="bluetooth_device_name">"Nom de l\'appareil"</string>
     <string name="bluetooth_name_not_set">"Aucun nom n\'a été défini. Utilisation du nom du compte..."</string>
-    <string name="bluetooth_scan_for_devices">"Rechercher des périphériques"</string>
+    <string name="bluetooth_scan_for_devices">"Rechercher d\'appareils"</string>
     <string name="bluetooth_disconnect_blank">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> va être déconnecté."</string>
     <string name="bluetooth_connected">"Connecté"</string>
     <string name="bluetooth_disconnected">"Déconnecté"</string>
     <string name="bluetooth_disconnecting">"Déconnexion…"</string>
     <string name="bluetooth_connecting">"Connexion…"</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
-    <string name="bluetooth_not_connected">"Associer à ce périphérique"</string>
+    <string name="bluetooth_not_connected">"Associer à cet appareil"</string>
     <string name="bluetooth_pairing">"Association…"</string>
     <string name="bluetooth_paired">"Associé mais non connecté"</string>
     <string name="bluetooth_device">"mains libres/casque"</string>
@@ -110,7 +110,7 @@
     <string name="choose_timezone">"Choisir fuseau horaire"</string>
     <string name="display_preview_label">"Aperçu :"</string>
     <string name="display_font_size_label">"Taille de police :"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Envoyer <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g> :"</string>
@@ -179,7 +179,7 @@
     <string name="language_picker_title">"Paramètres régionaux"</string>
     <string name="select_your_language">"Choisir la langue"</string>
     <string name="activity_picker_label">"Sélectionner une activité"</string>
-    <string name="device_info_label">"Informations sur le périphérique"</string>
+    <string name="device_info_label">"Informations sur l\'appareil"</string>
     <string name="battery_info_label">"Informations sur la batterie"</string>
     <string name="battery_history_label">"Historique de la batterie"</string>
     <string name="display_label">"Afficher"</string>
@@ -215,13 +215,13 @@
     <string name="bluetooth_settings_title">"Paramètres Bluetooth"</string>
     <string name="bluetooth_settings_summary">"Gérer les connexions, configurer le nom et l\'identification de l\'appareil"</string>
     <string name="bluetooth_pin_entry">"Demande d\'association Bluetooth"</string>
-    <string name="bluetooth_device_info">"Informations sur le périphérique Bluetooth"</string>
+    <string name="bluetooth_device_info">"Informations sur l\'appareil Bluetooth"</string>
     <string name="bluetooth_enter_pin_msg">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>"\n\n"Saisissez le code PIN pour associer l\'appareil."\n"(Essayez avec 0000 ou 1234.)"</string>
     <string name="bluetooth_error_title">"Attention"</string>
     <string name="bluetooth_pairing_error_message">"Un problème est survenu lors de l\'association à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
-    <string name="bluetooth_pairing_pin_error_message">"Un problème est survenu lors de l\'association à <xliff:g id="DEVICE_NAME">%1$s</xliff:g> car le PIN saisi est incorrect."</string>
+    <string name="bluetooth_pairing_pin_error_message">"Un problème est survenu lors de l\'association à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>, car le PIN saisi est incorrect."</string>
     <string name="bluetooth_connecting_error_message">"Un problème est survenu lors de la connexion à <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
-    <string name="bluetooth_preference_scan_title">"Rechercher des périphériques"</string>
+    <string name="bluetooth_preference_scan_title">"Rechercher des appareils"</string>
     <string name="bluetooth_device_context_connect">"Se connecter"</string>
     <string name="bluetooth_device_context_disconnect">"Déconnecter"</string>
     <string name="bluetooth_device_context_pair_connect">"Associer et connecter"</string>
@@ -365,8 +365,16 @@
     <string name="sync_settings_summary">"Sélectionner les applications à synchroniser"</string>
     <string name="display_settings">"Afficher les paramètres"</string>
     <string name="animations_title">"Animation"</string>
-    <string name="animations_summary_on">"Animation lors de l\'ouverture et la fermeture de fenêtres"</string>
-    <string name="animations_summary_off">"Animation lors de l\'ouverture et la fermeture de fenêtres"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Luminosité"</string>
     <string name="brightness_summary">"Régler la luminosité de l\'écran"</string>
     <string name="screen_timeout">"Mise en veille de l\'écran"</string>
@@ -455,6 +463,12 @@
     <string name="error_apn_empty">"Le champ Nom de point d\'accès (APN) doit être renseigné."</string>
     <string name="error_mcc_not3">"Le champ MCC doit contenir 3 chiffres."</string>
     <string name="error_mnc_not23">"Le champ MNC doit contenir 2 ou 3 chiffres."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Réinit. valeurs d\'usine"</string>
     <string name="master_clear_summary">"Effacer toutes les données du téléphone"</string>
     <string name="master_clear_desc">"Cette action réinitialisera le téléphone à ses valeurs d\'usine et effacera toutes les données et applications téléchargées !"</string>
@@ -591,6 +605,8 @@
     <string name="user_dict_settings_summary">"Ajouter et retirer des mots du dictionnaire personnel"</string>
     <string name="user_dict_settings_add_menu_title">"Ajouter"</string>
     <string name="user_dict_settings_add_dialog_title">"Ajouter au dictionnaire"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Modifier"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Supprimer"</string>
     <string name="user_dict_settings_empty_text">"Votre dictionnaire personnel ne contient aucun mot. Vous pouvez ajouter un mot via le menu."</string>
@@ -611,7 +627,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Raccourcis"</string>
     <string name="input_methods_settings_title">"Saisie de texte"</string>
     <string name="input_methods_settings_summary">"Gérer les options de saisie de texte"</string>
-    <string name="input_methods_settings_label_format">"Paramètres %s"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Développement"</string>
     <string name="development_settings_summary">"Définir les options pour le développement de l\'application"</string>
     <string name="enable_adb">"Débogage USB"</string>
diff --git a/res/values-it/strings.xml b/res/values-it/strings.xml
index 6e10e36..ef452c3 100644
--- a/res/values-it/strings.xml
+++ b/res/values-it/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Disconnesso"</string>
     <string name="bluetooth_disconnecting">"Disconnessione..."</string>
     <string name="bluetooth_connecting">"Connessione..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Accoppia con il dispositivo"</string>
     <string name="bluetooth_pairing">"Accoppiamento..."</string>
@@ -110,7 +110,7 @@
     <string name="choose_timezone">"Seleziona fuso orario"</string>
     <string name="display_preview_label">"Anteprima:"</string>
     <string name="display_font_size_label">"Dimensioni carattere:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Invia <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -365,8 +365,16 @@
     <string name="sync_settings_summary">"Seleziona le applicazioni da sincronizzare"</string>
     <string name="display_settings">"Impostazioni display"</string>
     <string name="animations_title">"Animazione"</string>
-    <string name="animations_summary_on">"Mostra animazioni durante apertura/chiusura di finestre"</string>
-    <string name="animations_summary_off">"Mostra animazioni durante apertura/chiusura di finestre"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Luminosità"</string>
     <string name="brightness_summary">"Regola la luminosità dello schermo"</string>
     <string name="screen_timeout">"Timeout schermo"</string>
@@ -455,6 +463,12 @@
     <string name="error_apn_empty">"Il campo APN non può essere vuoto."</string>
     <string name="error_mcc_not3">"Il campo MCC deve contenere 3 cifre."</string>
     <string name="error_mnc_not23">"Il campo MNC deve contenere 2 o 3 cifre."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Ripristino dati di fabbrica"</string>
     <string name="master_clear_summary">"Cancella tutti i dati sul telefono"</string>
     <string name="master_clear_desc">"Questa azione consente di ripristinare i valori di fabbrica del telefono, cancellando tutti i dati e le applicazioni scaricate."</string>
@@ -481,7 +495,7 @@
     <string name="location_networks_disabled">"Visualizza la posizione nelle applicazioni (ad esempio Maps) utilizzando le reti wireless"</string>
     <string name="location_neighborhood_level">"Posizione determinata dalle reti mobili e/o Wi-Fi"</string>
     <string name="location_gps">"Attiva satelliti GPS"</string>
-    <string name="location_street_level">"Durante localizzazione, accuratezza a livello stradale (deselezionare per risparmiare batteria)"</string>
+    <string name="location_street_level">"Accuratezza a livello stradale (deseleziona per risparmiare batteria)"</string>
     <string name="location_gps_disabled">"Localizza a livello stradale (richiede più batteria e la vista del cielo)"</string>
     <string name="about_settings">"Info sul telefono"</string>
     <string name="about_settings_summary">"Visualizza informazioni legali, stato del telefono, versione del software"</string>
@@ -494,7 +508,7 @@
     <string name="settings_license_activity_unavailable">"Errore durante il caricamento delle licenze."</string>
     <string name="settings_license_activity_loading">"Caricamento..."</string>
     <string name="lock_settings_title">"Sequenza di sblocco schermo"</string>
-    <string name="lockpattern_change_lock_pattern_label">"Cambia sequenza di sblocco"</string>
+    <string name="lockpattern_change_lock_pattern_label">"Cambia sequenza sblocco"</string>
     <string name="lockpattern_need_to_unlock">"Conferma sequenza salvata"</string>
     <string name="lockpattern_need_to_unlock_wrong">"Riprova:"</string>
     <string name="lockpattern_recording_intro_header">"Inserisci una sequenza di sblocco"</string>
@@ -521,7 +535,7 @@
     <string name="skip_button_label">"Annulla"</string>
     <string name="next_button_label">"Avanti"</string>
     <string name="lock_title">"Protezione del telefono"</string>
-    <string name="lock_intro_message"><font size="17">"Proteggi il telefono dall\'uso non autorizzato creando una sequenza di sblocco dello schermo personale. "\n<font height="17">\n</font><b>"1"</b>"  Nella prossima schermata, osserva la creazione di una sequenza di esempio. "\n<font height="17">\n</font><b>"2"</b>"  Quando sei pronto, crea la tua sequenza di sblocco personale. Prova diverse sequenze collegando sempre almeno quattro punti. "\n<font height="17">\n</font><b>"3"</b>"  Inserisci di nuovo la sequenza per confermare. "\n<font height="17">\n</font><b>"Pronto per iniziare? Seleziona “Avanti”"</b>". "\n<font height="3">\n</font>"Se non desideri proteggere il telefono, seleziona “Annulla”."</font></string>
+    <string name="lock_intro_message"><font size="17">"Proteggi il telefono dall\'uso non autorizzato creando una sequenza di sblocco dello schermo personalizzata. "\n<font height="17">\n</font><b>"1"</b>"  Nella prossima schermata, osserva la creazione di una sequenza di esempio. "\n<font height="17">\n</font><b>"2"</b>"  Quando sei pronto, crea la tua sequenza di sblocco personale. Prova diverse sequenze collegando sempre almeno quattro punti. "\n<font height="17">\n</font><b>"3"</b>"  Inserisci di nuovo la sequenza per confermare. "\n<font height="17">\n</font><b>"Pronto per iniziare? Seleziona “Avanti”"</b>". "\n<font height="3">\n</font>"Se non desideri proteggere il telefono, seleziona “Annulla”."</font></string>
     <string name="lock_example_title">"Sequenza di esempio"</string>
     <string name="lock_example_message">"Collega almeno quattro punti."\n" "\n"Seleziona \"Avanti\" quando sei pronto a creare la tua sequenza."</string>
     <string name="manageapplications_settings_title">"Gestisci applicazioni"</string>
@@ -530,7 +544,7 @@
     <string name="applications_settings_summary">"Gestisci le applicazioni, imposta le scorciatoie di avvio rapido"</string>
     <string name="applications_settings_header">"Impostazioni applicazione"</string>
     <string name="install_applications">"Origini sconosciute"</string>
-    <string name="install_unknown_applications">"Consenti l\'installazione di applicazioni non commerciali"</string>
+    <string name="install_unknown_applications">"Consenti l\'installazione di applicazioni non presenti in Market"</string>
     <string name="install_all_warning">"Il telefono e i dati personali sono più vulnerabili agli attacchi da parte di applicazioni\n di origini sconosciute. L\'utente accetta di essere il solo responsabile degli eventuali\n danni al telefono o della perdita dei dati che potrebbero derivare dall\'utilizzo di\n queste applicazioni."</string>
     <string name="application_info_label">"Info applicazione"</string>
     <string name="storage_label">"Archiviazione"</string>
@@ -591,6 +605,8 @@
     <string name="user_dict_settings_summary">"Aggiungi e rimuovi parole dal dizionario utente"</string>
     <string name="user_dict_settings_add_menu_title">"Aggiungi"</string>
     <string name="user_dict_settings_add_dialog_title">"Aggiungi al dizionario"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Modifica"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Elimina"</string>
     <string name="user_dict_settings_empty_text">"Non sono presenti parole nel dizionario utente. Puoi aggiungere una parola mediante il menu."</string>
@@ -611,7 +627,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Scorciatoie"</string>
     <string name="input_methods_settings_title">"Inserimento testo"</string>
     <string name="input_methods_settings_summary">"Gestisci opzioni inserimento testo"</string>
-    <string name="input_methods_settings_label_format">"Impostazioni %s"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Sviluppo"</string>
     <string name="development_settings_summary">"Imposta opzioni per lo sviluppo di applicazioni"</string>
     <string name="enable_adb">"Debug USB"</string>
diff --git a/res/values-ja/arrays.xml b/res/values-ja/arrays.xml
index d73a3d7..c10aa86 100644
--- a/res/values-ja/arrays.xml
+++ b/res/values-ja/arrays.xml
@@ -30,7 +30,7 @@
     <item>"1分"</item>
     <item>"2分"</item>
     <item>"10分"</item>
-    <item>"タイムアウトなし"</item>
+    <item>"減光しない"</item>
   </string-array>
   <string-array name="wifi_security_entries">
     <item>"自動"</item>
@@ -52,8 +52,8 @@
   </string-array>
   <string-array name="wifi_sleep_policy_entries">
     <item>"画面がOFFになったとき"</item>
-    <item>"電源接続時はスリープしない"</item>
-    <item>"スリープしない"</item>
+    <item>"電源接続時はスリープにしない"</item>
+    <item>"スリープにしない"</item>
   </string-array>
     <!-- no translation found for battery_history_type_spinner:0 (2193799199027871385) -->
     <!-- no translation found for battery_history_type_spinner:1 (6401018715947316517) -->
diff --git a/res/values-ja/strings.xml b/res/values-ja/strings.xml
index b887234..7e358b2 100644
--- a/res/values-ja/strings.xml
+++ b/res/values-ja/strings.xml
@@ -30,7 +30,7 @@
     <string name="radioInfo_menu_disableDataOnBoot">"起動時にデータを無効にする"</string>
     <string name="radioInfo_service_in">"使用中"</string>
     <string name="radioInfo_service_out">"休止中または使用不可"</string>
-    <string name="radioInfo_service_emergency">"緊急呼のみ"</string>
+    <string name="radioInfo_service_emergency">"緊急通報のみ"</string>
     <string name="radioInfo_service_off">"無線通信をオフ"</string>
     <string name="radioInfo_roaming_in">"ローミング"</string>
     <string name="radioInfo_roaming_not">"ローミングなし"</string>
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"切断"</string>
     <string name="bluetooth_disconnecting">"切断中..."</string>
     <string name="bluetooth_connecting">"接続中..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"この端末をペアに設定する"</string>
     <string name="bluetooth_pairing">"ペアとして設定中..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"タイムゾーンの選択"</string>
     <string name="display_preview_label">"プレビュー:"</string>
     <string name="display_font_size_label">"フォントサイズ:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"<xliff:g id="BROADCAST">broadcast</xliff:g>を送信"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -211,7 +211,7 @@
     <string name="security_settings_summary">"現在地情報、画面ロック、SIMカードロック"</string>
     <string name="security_passwords_title">"パスワード"</string>
     <string name="bluetooth_quick_toggle_title">"Bluetooth"</string>
-    <string name="bluetooth_quick_toggle_summary">"Bluetoothをオン"</string>
+    <string name="bluetooth_quick_toggle_summary">"BluetoothをONにする"</string>
     <string name="bluetooth_settings">"Bluetooth設定"</string>
     <string name="bluetooth_settings_title">"Bluetooth設定"</string>
     <string name="bluetooth_settings_summary">"端末の名前、接続や検出設定"</string>
@@ -245,7 +245,7 @@
     <string name="bluetooth_headset_profile_summary_use_for">"携帯電話の音声に使用"</string>
     <string name="wifi">"Wi-Fi"</string>
     <string name="wifi_quick_toggle_title">"Wi-Fi"</string>
-    <string name="wifi_quick_toggle_summary">"Wi-Fiをオン"</string>
+    <string name="wifi_quick_toggle_summary">"Wi-FiをONにする"</string>
     <string name="wifi_settings">"Wi-Fi設定"</string>
     <string name="wifi_settings_category">"Wi-Fi設定"</string>
     <string name="wifi_settings_summary">"ワイヤレスアクセスポイントの設定"</string>
@@ -268,10 +268,10 @@
     <string name="wifi_security_verbose_wpa2">"WPA2により保護"</string>
     <string name="ip_address">"IPアドレス"</string>
     <string name="signal">"電波強度"</string>
-    <string name="wifi_starting">"オンにしています..."</string>
-    <string name="wifi_stopping">"オフにしています..."</string>
+    <string name="wifi_starting">"ONにしています..."</string>
+    <string name="wifi_stopping">"OFFにしています..."</string>
     <string name="wifi_error">"エラー"</string>
-    <string name="error_starting">"Wi-Fiを開始できません"</string>
+    <string name="error_starting">"Wi-Fiを使用できません"</string>
     <string name="error_stopping">"Wi-Fiを停止できません"</string>
     <string name="error_scanning">"ネットワークをスキャンできません"</string>
     <string name="error_connecting">"ネットワークに接続できません"</string>
@@ -283,7 +283,7 @@
     <string name="wifi_show_password">"パスワードを表示"</string>
     <string name="scan_wifi">"スキャン"</string>
     <string name="summary_not_in_range">"圏外"</string>
-    <string name="summary_remembered">"これまでの設定"</string>
+    <string name="summary_remembered">"接続履歴あり"</string>
     <string name="summary_connection_failed">"接続できませんでした。選択すると再試行します。"</string>
     <string name="wifi_access_points">"Wi-Fiネットワーク"</string>
     <string name="wifi_type_ssid">"ネットワークSSID"</string>
@@ -300,7 +300,7 @@
     <string name="wifi_ip_settings_menu_save">"保存"</string>
     <string name="wifi_ip_settings_menu_cancel">"キャンセル"</string>
     <string name="wifi_ip_settings_invalid_ip">"正しいIPアドレスを入力してください。"</string>
-    <string name="wifi_use_static_ip">"静的IPを使用"</string>
+    <string name="wifi_use_static_ip">"静的IPを使用する"</string>
     <string name="wifi_ip_address">"IPアドレス"</string>
     <string name="wifi_dns1">"DNS 1"</string>
     <string name="wifi_dns2">"DNS 2"</string>
@@ -310,12 +310,12 @@
     <string name="wifi_context_menu_forget">"ネットワークへの接続を解除"</string>
     <string name="wifi_context_menu_change_password">"パスワードを変更"</string>
     <string name="wifi_advanced_titlebar">"詳細設定"</string>
-    <string name="wifi_setting_num_channels_title">"規制領域"</string>
-    <string name="wifi_setting_num_channels_summary">"使用するチャンネルの番号を設定する"</string>
-    <string name="wifi_setting_num_channels_error">"規制領域の設定で問題が発生しました。"</string>
-    <string name="wifi_setting_num_channels_channel_phrase">"チャンネル数<xliff:g id="NUM_CHANNELS">%1$d</xliff:g>件"</string>
-    <string name="wifi_setting_sleep_policy_title">"Wi-Fiスリープポリシー"</string>
-    <string name="wifi_setting_sleep_policy_summary">"Wi-Fiからモバイルデータに切り替えるタイミングを指定する"</string>
+    <string name="wifi_setting_num_channels_title">"規制区域"</string>
+    <string name="wifi_setting_num_channels_summary">"使用するチャネル番号を設定する"</string>
+    <string name="wifi_setting_num_channels_error">"規制区域の設定に問題があります。"</string>
+    <string name="wifi_setting_num_channels_channel_phrase">"<xliff:g id="NUM_CHANNELS">%1$d</xliff:g>チャネル"</string>
+    <string name="wifi_setting_sleep_policy_title">"Wi-Fiのスリープ設定"</string>
+    <string name="wifi_setting_sleep_policy_summary">"Wi-Fiをスリープに切り替えるタイミング"</string>
     <string name="wifi_setting_sleep_policy_error">"スリープポリシーの設定で問題が発生しました。"</string>
     <string name="wifi_advanced_mac_address_title">"MACアドレス"</string>
     <string name="fragment_status_scanning">"スキャン中..."</string>
@@ -338,15 +338,15 @@
     <string name="sound_settings">"音の設定"</string>
     <string name="sound_and_display_settings_summary">"着信音、操作音、画面の明るさなど"</string>
     <string name="silent_mode_title">"マナーモード"</string>
-    <string name="silent_mode_summary">"メディア（音楽や動画）、アラーム以外は無音にします"</string>
+    <string name="silent_mode_summary">"音楽、動画メディア、アラーム以外は消音"</string>
     <string name="ringtone_title">"着信音"</string>
-    <string name="ringtone_summary">"端末既定の着信音設定"</string>
-    <string name="ring_volume_title">"着信音の音量"</string>
-    <string name="ring_volume_summary">"着信音と通知音の音量を設定する"</string>
+    <string name="ringtone_summary">"端末の基本着信音を選択"</string>
+    <string name="ring_volume_title">"着信音量"</string>
+    <string name="ring_volume_summary">"着信音と通知音の音量"</string>
     <string name="vibrate_title">"バイブレーション"</string>
-    <string name="vibrate_summary">"着信時のバイブレーションON"</string>
+    <string name="vibrate_summary">"着信時バイブレーションをONにする"</string>
     <string name="notification_sound_title">"通知音"</string>
-    <string name="notification_sound_summary">"端末既定の通知音設定"</string>
+    <string name="notification_sound_summary">"端末の基本通知音を選択"</string>
     <string name="incoming_call_volume_title">"着信音量"</string>
     <string name="notification_volume_title">"通知音量"</string>
     <string name="checkbox_notification_same_as_incoming_call">"通知音にも着信音量を適用"</string>
@@ -357,21 +357,29 @@
     <string name="dtmf_tone_enable_summary_on">"ダイヤルパッドの操作音をONにする"</string>
     <string name="dtmf_tone_enable_summary_off">"ダイヤルパッドの操作音をONにする"</string>
     <string name="sound_effects_enable_title">"選択時の操作音"</string>
-    <string name="sound_effects_enable_summary_on">"メニュー選択時に音を鳴らす"</string>
-    <string name="sound_effects_enable_summary_off">"メニュー選択時に音を鳴らす"</string>
+    <string name="sound_effects_enable_summary_on">"メニュー選択時の操作音をONにする"</string>
+    <string name="sound_effects_enable_summary_off">"メニュー選択時の操作音をONにする"</string>
     <string name="play_media_notification_sounds_enable_title">"SDカードの通知"</string>
-    <string name="play_media_notification_sounds_enable_summary_on">"SDカードの通知音を無効にする"</string>
-    <string name="play_media_notification_sounds_enable_summary_off">"SDカードの通知音を有効にします"</string>
+    <string name="play_media_notification_sounds_enable_summary_on">"SDカード通知音をOFFにする"</string>
+    <string name="play_media_notification_sounds_enable_summary_off">"SDカード通知音をONにする"</string>
     <string name="sync_settings">"データの同期"</string>
-    <string name="sync_settings_summary">"同期するアプリケーションを選択する"</string>
+    <string name="sync_settings_summary">"同期するアプリケーションの選択"</string>
     <string name="display_settings">"画面設定"</string>
     <string name="animations_title">"アニメーション表示"</string>
-    <string name="animations_summary_on">"ウィンドウの開閉をアニメーションで表示する"</string>
-    <string name="animations_summary_off">"ウィンドウの開閉をアニメーションで表示する"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"画面の明るさ"</string>
-    <string name="brightness_summary">"画面の明るさを調整します"</string>
-    <string name="screen_timeout">"画面のタイムアウト"</string>
-    <string name="screen_timeout_summary">"画面が自動的にOFFになるまでの時間を調整します"</string>
+    <string name="brightness_summary">"画面の明るさを調整する"</string>
+    <string name="screen_timeout">"バックライト消灯"</string>
+    <string name="screen_timeout_summary">"画面のバックライトを自動消灯するまでの時間"</string>
     <string name="sim_lock_settings">"SIMカードロック設定"</string>
     <string name="sim_lock_settings_category">"SIMカードロック設定"</string>
     <string name="sim_lock_settings_title">"SIMカードロック"</string>
@@ -406,7 +414,7 @@
     <string name="device_status">"端末の状態"</string>
     <string name="device_status_summary">"電話番号、端末識別番号、電波状態など"</string>
     <string name="storage_settings_title">"SDカード &amp; 端末容量"</string>
-    <string name="storage_settings_summary">"SDカードの取り外し、空き容量の表示など"</string>
+    <string name="storage_settings_summary">"SDカードの取り外し、空き容量の表示"</string>
     <string name="status_number">"電話番号"</string>
     <string name="status_network_type">"モバイルネットワークのタイプ"</string>
     <string name="status_data_state">"モバイルネットワークの状態"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"APNを空にできません。"</string>
     <string name="error_mcc_not3">"MCCのフィールドには3桁で指定してください。"</string>
     <string name="error_mnc_not23">"MNCのフィールドには2桁か3桁で指定してください。"</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"データの初期化"</string>
     <string name="master_clear_summary">"携帯電話内のすべてのデータを消去"</string>
     <string name="master_clear_desc">"この操作は携帯電話を出荷時の初期状態にリセットし、データとダウンロードしたアプリケーションをすべて消去します。"</string>
@@ -476,16 +490,16 @@
     <string name="call_settings_title">"通話設定"</string>
     <string name="call_settings_summary">"ボイスメール、電話転送、発信者番号などの設定"</string>
     <string name="network_settings_title">"モバイルネットワーク"</string>
-    <string name="network_settings_summary">"ローミング、ネットワーク、APNの設定"</string>
-    <string name="location_title">"現在地情報"</string>
+    <string name="network_settings_summary">"ローミング、ネットワーク、APN設定"</string>
+    <string name="location_title">"位置情報の検出"</string>
     <string name="location_network_based">"ワイヤレスネットワークを使用"</string>
-    <string name="location_networks_disabled">"ワイヤレスネットワークを使用するアプリケーション（地図など）で位置を表示する"</string>
+    <string name="location_networks_disabled">"無線ネットワークを使用するアプリケーション(地図など)で位置を表示する"</string>
     <string name="location_neighborhood_level">"Wi-Fi/モバイルネットワークで位置を検出する"</string>
-    <string name="location_gps">"GPS機能を有効にする"</string>
-    <string name="location_street_level">"高精度測位（電池を節約する場合はOFFを選択）"</string>
-    <string name="location_gps_disabled">"高精度測位（電池消費大、電波が良好な野外使用）"</string>
+    <string name="location_gps">"GPS機能をONにする"</string>
+    <string name="location_street_level">"高精度測位（電池の消費を節約する場合はOFFにしてください）"</string>
+    <string name="location_gps_disabled">"高精度測位（電池消費増、電波が良好な場所で使用）"</string>
     <string name="about_settings">"端末情報"</string>
-    <string name="about_settings_summary">"端末情報、法的情報、バージョン情報など"</string>
+    <string name="about_settings_summary">"端末情報、規約、バージョン情報"</string>
     <string name="legal_information">"法的情報"</string>
     <string name="contributors_title">"貢献者/連携パートナー"</string>
     <string name="copyright_title">"著作権"</string>
@@ -524,7 +538,7 @@
     <string name="lock_title">"携帯電話の保護"</string>
     <string name="lock_intro_message"><font size="17">"画面ロックの解除パターンを作成して携帯電話の不正使用を防ぐことができます。"\n<font height="17">\n</font><b>"1"</b>"  次の画面でパターン作成の例を参考にしてください。"\n<font height="17">\n</font><b>"2"</b>"  ロック解除パターンを決めたら、そのパターンを指でなぞって描きます。さまざまなパターンを作成できますが、最低4つの点を結んでください。"\n<font height="17">\n</font><b>"3"</b>"  確認のためもう一度そのパターンを入力します。"\n<font height="17">\n</font><b>"[次へ]を押すと次に進みます"</b>"。"\n<font height="3">\n</font>"パターンロックを設定しない場合は[キャンセル]を選択してください。"</font></string>
     <string name="lock_example_title">"パターン例"</string>
-    <string name="lock_example_message">"少なくとも4つの点を結んで下さい。"\n" "\n"独自のパターンを決めたら[次へ]を選択します。"</string>
+    <string name="lock_example_message">"少なくとも4つの点を結んで下さい。"\n" "\n"パターンを決めたら[次へ]を選択して進みます。"</string>
     <string name="manageapplications_settings_title">"アプリケーションの管理"</string>
     <string name="manageapplications_settings_summary">"インストール済みアプリケーションを管理/削除します"</string>
     <string name="applications_settings">"アプリケーション"</string>
@@ -535,7 +549,7 @@
     <string name="install_all_warning">"提供元不明のアプリケーションから携帯電話や個人情報データが攻撃を受ける可能性が高くなります。このようなアプリケーションの使用により生じうる携帯電話への損害やデータの損失について、お客様がすべての責任を負うことに同意するものとします。"</string>
     <string name="application_info_label">"アプリケーション情報"</string>
     <string name="storage_label">"メモリ"</string>
-    <string name="auto_launch_label">"いつも起動"</string>
+    <string name="auto_launch_label">"いつもこのアプリケーションを選択する操作"</string>
     <string name="permissions_label">"許可"</string>
     <string name="cache_header_label">"キャッシュ"</string>
     <string name="clear_cache_btn_text">"キャッシュをクリア"</string>
@@ -547,9 +561,9 @@
     <string name="data_size_label">"データ"</string>
     <string name="uninstall_text">"アンインストール"</string>
     <string name="clear_user_data_text">"データを消去"</string>
-    <string name="auto_launch_enable_text">"このアプリケーションはある操作で常に起動するように設定されています。"</string>
-    <string name="auto_launch_disable_text">"端末既定の設定なし"</string>
-    <string name="clear_activities">"既定操作を消去"</string>
+    <string name="auto_launch_enable_text">"特定の操作で使用する既定アプリケーションとして設定されています。"</string>
+    <string name="auto_launch_disable_text">"設定されている操作はありません。"</string>
+    <string name="clear_activities">"設定を消去"</string>
     <string name="unknown">"不明"</string>
     <string name="sort_order_alpha">"並べ替え"</string>
     <string name="sort_order_size">"サイズ順に並べ替え"</string>
@@ -573,7 +587,7 @@
     <string name="invalid_size_value">"パッケージのサイズを計算できません"</string>
     <string name="empty_list_msg">"サードパーティ製のアプリケーションはインストールされていません。"</string>
     <string name="language_settings">"地域/言語 &amp; 文字入力"</string>
-    <string name="language_settings_summary">"地域と言語、文字入力、自動修正の設定"</string>
+    <string name="language_settings_summary">"言語と地域、文字入力の設定"</string>
     <string name="language_category">"地域/言語設定"</string>
     <string name="text_category">"文字入力設定"</string>
     <string name="phone_language">"地域/言語を選択"</string>
@@ -583,15 +597,17 @@
     <string name="auto_caps">"自動大文字変換"</string>
     <string name="auto_caps_summary">"英語: 先頭文字を大文字に変換する"</string>
     <string name="auto_punctuate">"ピリオド自動挿入"</string>
-    <string name="hardkeyboard_category">"物理キーボードの設定"</string>
+    <string name="hardkeyboard_category">"キーボードの設定"</string>
     <string name="auto_punctuate_summary">"英語: Spaceキー2回でピリオド(.)を挿入"</string>
     <string name="show_password">"パスワードを表示"</string>
-    <string name="show_password_summary">"入力中のパスワードを表示する"</string>
+    <string name="show_password_summary">"入力時にパスワードを表示する"</string>
     <string name="user_dict_settings_titlebar">"ユーザー辞書"</string>
     <string name="user_dict_settings_title">"ユーザー辞書"</string>
     <string name="user_dict_settings_summary">"ユーザー辞書への語句の追加と削除"</string>
     <string name="user_dict_settings_add_menu_title">"追加"</string>
     <string name="user_dict_settings_add_dialog_title">"辞書に追加"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"編集"</string>
     <string name="user_dict_settings_context_menu_delete_title">"削除"</string>
     <string name="user_dict_settings_empty_text">"ユーザー辞書に何も登録されていません。語句はメニューから登録できます。"</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"ショートカット"</string>
     <string name="input_methods_settings_title">"文字入力"</string>
     <string name="input_methods_settings_summary">"テキスト入力オプションを管理"</string>
-    <string name="input_methods_settings_label_format">"%s設定"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"開発"</string>
     <string name="development_settings_summary">"アプリケーション開発オプション"</string>
     <string name="enable_adb">"USBデバッグ"</string>
diff --git a/res/values-ko/strings.xml b/res/values-ko/strings.xml
index f5d680f..e3f1de1 100644
--- a/res/values-ko/strings.xml
+++ b/res/values-ko/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"연결끊김"</string>
     <string name="bluetooth_disconnecting">"연결을 끊는 중..."</string>
     <string name="bluetooth_connecting">"연결 중..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"이 장치와 페어링"</string>
     <string name="bluetooth_pairing">"페어링 중..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"표준시간대 선택"</string>
     <string name="display_preview_label">"미리보기:"</string>
     <string name="display_font_size_label">"글꼴 크기:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"<xliff:g id="BROADCAST">broadcast</xliff:g> 보내기"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"동기화할 응용프로그램 선택"</string>
     <string name="display_settings">"디스플레이 설정"</string>
     <string name="animations_title">"애니메이션"</string>
-    <string name="animations_summary_on">"창을 열거나 닫을 때 애니메이션 표시"</string>
-    <string name="animations_summary_off">"창을 열거나 닫을 때 애니메이션 표시"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"밝기"</string>
     <string name="brightness_summary">"화면 밝기 조정"</string>
     <string name="screen_timeout">"화면 시간제한"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"APN을 비워둘 수 없습니다."</string>
     <string name="error_mcc_not3">"MCC 필드는 3자리 숫자여야 합니다."</string>
     <string name="error_mnc_not23">"MNC 필드는 2~3자리 숫자여야 합니다."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"공장 기본값 데이터 재설정"</string>
     <string name="master_clear_summary">"전화기의 모든 데이터 지우기"</string>
     <string name="master_clear_desc">"이 작업을 수행하면 전화기의 모든 데이터 및 다운로드한 응용프로그램이 지워지고 출고시 초기 상태로 재설정됩니다"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"사용자 사전에서 단어 추가 및 삭제"</string>
     <string name="user_dict_settings_add_menu_title">"추가"</string>
     <string name="user_dict_settings_add_dialog_title">"사전에 추가"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"편집"</string>
     <string name="user_dict_settings_context_menu_delete_title">"삭제"</string>
     <string name="user_dict_settings_empty_text">"사용자 사전에 단어가 없습니다. 메뉴를 통해 단어를 추가할 수 있습니다."</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"바로가기"</string>
     <string name="input_methods_settings_title">"텍스트 입력"</string>
     <string name="input_methods_settings_summary">"텍스트 입력 옵션 관리"</string>
-    <string name="input_methods_settings_label_format">"%s 설정"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"개발"</string>
     <string name="development_settings_summary">"응용프로그램 개발 옵션 설정"</string>
     <string name="enable_adb">"USB 디버깅"</string>
diff --git a/res/values-nb/strings.xml b/res/values-nb/strings.xml
index f9f01a6..3366c52 100644
--- a/res/values-nb/strings.xml
+++ b/res/values-nb/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Frakoblet"</string>
     <string name="bluetooth_disconnecting">"Kobler fra…"</string>
     <string name="bluetooth_connecting">"Kobler til…"</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Par med denne enheten"</string>
     <string name="bluetooth_pairing">"Parer…"</string>
@@ -110,7 +110,7 @@
     <string name="choose_timezone">"Velg tidssone"</string>
     <string name="display_preview_label">"Forhåndsvisning:"</string>
     <string name="display_font_size_label">"Skriftstørrelse:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Send <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -365,8 +365,16 @@
     <string name="sync_settings_summary">"Applikasjoner som skal synkroniseres"</string>
     <string name="display_settings">"Skjerminnstillinger"</string>
     <string name="animations_title">"Animasjon"</string>
-    <string name="animations_summary_on">"Vis animasjon når vinduer åpnes/lukkes"</string>
-    <string name="animations_summary_off">"Vis animasjon når vinduer åpnes/lukkes"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Lysstyrke"</string>
     <string name="brightness_summary">"Juster skjermens lysstyrke"</string>
     <string name="screen_timeout">"Skjermsparer"</string>
@@ -455,6 +463,12 @@
     <string name="error_apn_empty">"APNet kan ikke være tomt."</string>
     <string name="error_mcc_not3">"MCC-feltet må være på tre siffer."</string>
     <string name="error_mnc_not23">"MNC-feltet må være på to eller tre siffer."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Fabrikkinnstillinger"</string>
     <string name="master_clear_summary">"Fjern alle data fra telefonen"</string>
     <string name="master_clear_desc">"Dette vil nullstille telefonen til fabrikktilstanden, noe som fjerner alle data og nedlastede applikasjoner!"</string>
@@ -591,6 +605,8 @@
     <string name="user_dict_settings_summary">"Legg til og fjern ord fra ordlisten"</string>
     <string name="user_dict_settings_add_menu_title">"Legg til"</string>
     <string name="user_dict_settings_add_dialog_title">"Legg til ordliste"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Rediger"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Slett"</string>
     <string name="user_dict_settings_empty_text">"Ordlisten er tom. Du kan legge til ord i menyen."</string>
@@ -611,7 +627,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Snarveier"</string>
     <string name="input_methods_settings_title">"Skriving av tekst"</string>
     <string name="input_methods_settings_summary">"Innstillinger for skriving av tekst"</string>
-    <string name="input_methods_settings_label_format">"Innstillinger for %s"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Utvikling"</string>
     <string name="development_settings_summary">"Innstillinger for applikasjonsutvikling"</string>
     <string name="enable_adb">"USB-debugging"</string>
diff --git a/res/values-nl/strings.xml b/res/values-nl/strings.xml
index 4f1c6f9..d834db3 100644
--- a/res/values-nl/strings.xml
+++ b/res/values-nl/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Verbinding verbroken"</string>
     <string name="bluetooth_disconnecting">"Verbinding verbreken..."</string>
     <string name="bluetooth_connecting">"Verbinding maken..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Koppelen met dit apparaat"</string>
     <string name="bluetooth_pairing">"Koppelen..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"Tijdzone selecteren"</string>
     <string name="display_preview_label">"Voorbeeld:"</string>
     <string name="display_font_size_label">"Lettergrootte:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"<xliff:g id="BROADCAST">broadcast</xliff:g> verzenden"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"Selecteren welke toepassingen worden gesynchroniseerd"</string>
     <string name="display_settings">"Instellingen weergeven"</string>
     <string name="animations_title">"Animatie"</string>
-    <string name="animations_summary_on">"Animatie weergeven bij het openen/sluiten van vensters"</string>
-    <string name="animations_summary_off">"Animatie weergeven bij het openen/sluiten van vensters"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Helderheid"</string>
     <string name="brightness_summary">"Helderheid van het scherm aanpassen"</string>
     <string name="screen_timeout">"Time-out scherm"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"De APN mag niet leeg zijn."</string>
     <string name="error_mcc_not3">"MCC-veld moet 3 cijfers bevatten."</string>
     <string name="error_mnc_not23">"MNC-veld moet 2 of 3 cijfers bevatten."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Terugzetten op fabrieksinstellingen"</string>
     <string name="master_clear_summary">"Hiermee worden alle gegevens op de telefoon gewist"</string>
     <string name="master_clear_desc">"Met deze actie wordt de telefoon teruggezet op de fabrieksinstellingen. Alle gegevens en gedownloade toepassingen worden gewist!"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"Woorden toevoegen aan en verwijderen uit gebruikerswoordenboek"</string>
     <string name="user_dict_settings_add_menu_title">"Toevoegen"</string>
     <string name="user_dict_settings_add_dialog_title">"Toevoegen aan woordenboek"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Bewerken"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Verwijderen"</string>
     <string name="user_dict_settings_empty_text">"U heeft geen woorden in het gebruikerswoordenboek. U kunt een woord toevoegen via het menu."</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Sneltoetsen"</string>
     <string name="input_methods_settings_title">"Tekstinvoer"</string>
     <string name="input_methods_settings_summary">"Opties voor tekstinvoer beheren"</string>
-    <string name="input_methods_settings_label_format">"Instellingen voor %s"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Ontwikkeling"</string>
     <string name="development_settings_summary">"Opties instellen voor toepassingsontwikkeling"</string>
     <string name="enable_adb">"USB-foutopsporing"</string>
diff --git a/res/values-pl/strings.xml b/res/values-pl/strings.xml
index c6e7b07..21e0e01 100644
--- a/res/values-pl/strings.xml
+++ b/res/values-pl/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Rozłączona"</string>
     <string name="bluetooth_disconnecting">"Rozłączanie..."</string>
     <string name="bluetooth_connecting">"Łączenie..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Paruj z tym urządzeniem"</string>
     <string name="bluetooth_pairing">"Parowanie..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"Wybierz strefę czasową"</string>
     <string name="display_preview_label">"Podgląd:"</string>
     <string name="display_font_size_label">"Rozmiar czcionki:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Wyślij <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"Wybierz, które aplikacje są synchronizowane"</string>
     <string name="display_settings">"Ustawienia wyświetlacza"</string>
     <string name="animations_title">"Animacja"</string>
-    <string name="animations_summary_on">"Pokazuj animację podczas otwierania i zamykania okien"</string>
-    <string name="animations_summary_off">"Pokazuj animację podczas otwierania i zamykania okien"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Jasność ekranu"</string>
     <string name="brightness_summary">"Dostosuj jasność ekranu"</string>
     <string name="screen_timeout">"Wygaszanie ekranu"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"Pole APN nie może być puste."</string>
     <string name="error_mcc_not3">"Pole MMC musi zawierać 3 cyfry."</string>
     <string name="error_mnc_not23">"Pole MNC musi zawierać 2 lub 3 cyfry."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Ustawienia fabryczne"</string>
     <string name="master_clear_summary">"Wymazuje wszystkie dane w telefonie"</string>
     <string name="master_clear_desc">"Ta czynność spowoduje przywrócenie w telefonie ustawień fabrycznych i wymazanie wszystkich danych oraz pobranych aplikacji!"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"Dodaj i usuń słowa w słowniku użytkownika"</string>
     <string name="user_dict_settings_add_menu_title">"Dodaj"</string>
     <string name="user_dict_settings_add_dialog_title">"Dodaj do słownika"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Edytuj"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Usuń"</string>
     <string name="user_dict_settings_empty_text">"Nie masz żadnych słów w słowniku użytkownika. Możesz dodać słowo poprzez menu."</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Skróty"</string>
     <string name="input_methods_settings_title">"Wprowadzanie tekstu"</string>
     <string name="input_methods_settings_summary">"Zarządzaj opcjami wprowadzania tekstu"</string>
-    <string name="input_methods_settings_label_format">"%s – ustawienia"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Programowanie"</string>
     <string name="development_settings_summary">"Ustaw opcje związane z programowaniem aplikacji"</string>
     <string name="enable_adb">"Debugowanie USB"</string>
diff --git a/res/values-ru/strings.xml b/res/values-ru/strings.xml
index fa835ab..365e64d 100644
--- a/res/values-ru/strings.xml
+++ b/res/values-ru/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"Отключено"</string>
     <string name="bluetooth_disconnecting">"Отключение…"</string>
     <string name="bluetooth_connecting">"Идет подключение…"</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"Создать пару с этим устройством"</string>
     <string name="bluetooth_pairing">"Идет создание пары..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"Выбрать часовой пояс"</string>
     <string name="display_preview_label">"Предварительный просмотр:"</string>
     <string name="display_font_size_label">"Размер шрифта:"</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"Отправить <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"Выбрать синхронизируемые приложения"</string>
     <string name="display_settings">"Настройки экрана"</string>
     <string name="animations_title">"Анимация"</string>
-    <string name="animations_summary_on">"Показывать анимацию при открытии и закрытии окон"</string>
-    <string name="animations_summary_off">"Показывать анимацию при открытии и закрытии окон"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"Яркость"</string>
     <string name="brightness_summary">"Настроить яркость экрана"</string>
     <string name="screen_timeout">"Время до отключения экрана"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"APN не может быть пустым."</string>
     <string name="error_mcc_not3">"Поле MCC должно содержать 3 цифры."</string>
     <string name="error_mnc_not23">"Поле MNC должно содержать 2 или 3 цифры."</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"Сброс заводских данных"</string>
     <string name="master_clear_summary">"Удаление всех данных с телефона"</string>
     <string name="master_clear_desc">"Это действие сбросит телефон до исходного заводского состояния, удалив все данные и загруженные приложения!"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"Добавить или удалить слова из пользовательского словаря"</string>
     <string name="user_dict_settings_add_menu_title">"Добавить"</string>
     <string name="user_dict_settings_add_dialog_title">"Добавление в словарь"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"Изменить"</string>
     <string name="user_dict_settings_context_menu_delete_title">"Удалить"</string>
     <string name="user_dict_settings_empty_text">"В пользовательском словаре отсутствуют слова. Добавить слово можно с помощью меню."</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"Ярлыки"</string>
     <string name="input_methods_settings_title">"Ввод текста"</string>
     <string name="input_methods_settings_summary">"Управление параметрами ввода текста"</string>
-    <string name="input_methods_settings_label_format">"Настройки %s"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"Разработка"</string>
     <string name="development_settings_summary">"Выбрать параметры разработки приложений"</string>
     <string name="enable_adb">"Отладка USB"</string>
diff --git a/res/values-zh-rCN/strings.xml b/res/values-zh-rCN/strings.xml
index 4ad3d9e..afa5e52 100644
--- a/res/values-zh-rCN/strings.xml
+++ b/res/values-zh-rCN/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"已断开连接"</string>
     <string name="bluetooth_disconnecting">"正在断开连接..."</string>
     <string name="bluetooth_connecting">"正在连接..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"与此设备配对"</string>
     <string name="bluetooth_pairing">"正在配对..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"选择时区"</string>
     <string name="display_preview_label">"预览："</string>
     <string name="display_font_size_label">"字体大小："</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"发送<xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>："</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"选择同步哪些应用程序"</string>
     <string name="display_settings">"显示设置"</string>
     <string name="animations_title">"动画"</string>
-    <string name="animations_summary_on">"打开/关闭窗口时显示动画"</string>
-    <string name="animations_summary_off">"打开/关闭窗口时显示动画"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"亮度"</string>
     <string name="brightness_summary">"调整屏幕亮度"</string>
     <string name="screen_timeout">"屏幕待机"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"APN 不能为空。"</string>
     <string name="error_mcc_not3">"MCC 字段必须为 3 位数。"</string>
     <string name="error_mnc_not23">"MNC 字段必须为 2 位数或 3 位数。"</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"已重设出厂数据"</string>
     <string name="master_clear_summary">"清除手机上的所有数据"</string>
     <string name="master_clear_desc">"此操作会将手机重设为其初始出厂状态，即清除所有数据和下载的应用程序！"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"向用户词典中添加字词以及从用户词典中删除字词"</string>
     <string name="user_dict_settings_add_menu_title">"添加"</string>
     <string name="user_dict_settings_add_dialog_title">"添加到词典"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"编辑"</string>
     <string name="user_dict_settings_context_menu_delete_title">"删除"</string>
     <string name="user_dict_settings_empty_text">"用户词典中没有您定义的字词。您可以通过菜单添加字词。"</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"快捷键"</string>
     <string name="input_methods_settings_title">"文本输入"</string>
     <string name="input_methods_settings_summary">"管理文本输入选项"</string>
-    <string name="input_methods_settings_label_format">"%s 设置"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"开发"</string>
     <string name="development_settings_summary">"设置应用程序开发选项"</string>
     <string name="enable_adb">"USB 调试"</string>
diff --git a/res/values-zh-rTW/strings.xml b/res/values-zh-rTW/strings.xml
index a076eb8..5ced4ce 100644
--- a/res/values-zh-rTW/strings.xml
+++ b/res/values-zh-rTW/strings.xml
@@ -94,7 +94,7 @@
     <string name="bluetooth_disconnected">"連線中斷"</string>
     <string name="bluetooth_disconnecting">"連線中斷..."</string>
     <string name="bluetooth_connecting">"連線中..."</string>
-    <!-- no translation found for bluetooth_unknown (1905151516611093010) -->
+    <!-- no translation found for bluetooth_unknown (644716244548801421) -->
     <skip />
     <string name="bluetooth_not_connected">"與此裝置配對"</string>
     <string name="bluetooth_pairing">"配對中..."</string>
@@ -111,7 +111,7 @@
     <string name="choose_timezone">"選取時區"</string>
     <string name="display_preview_label">"預覽："</string>
     <string name="display_font_size_label">"字型大小："</string>
-    <!-- no translation found for intent_sender_data_label (8363026381459131554) -->
+    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
     <skip />
     <string name="intent_sender_sendbroadcast_text">"傳送 <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
     <string name="intent_sender_action_label">"<xliff:g id="ACTION">Action</xliff:g>："</string>
@@ -366,8 +366,16 @@
     <string name="sync_settings_summary">"選取要同步處理的應用程式"</string>
     <string name="display_settings">"顯示設定"</string>
     <string name="animations_title">"動畫"</string>
-    <string name="animations_summary_on">"開啟/關閉視窗時顯示動畫"</string>
-    <string name="animations_summary_off">"開啟/關閉視窗時顯示動畫"</string>
+    <!-- no translation found for animations_summary_on (8843613112130484436) -->
+    <skip />
+    <!-- no translation found for animations_summary_off (2777026828025551983) -->
+    <skip />
+    <!-- no translation found for accelerometer_title (6183763368844793276) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_on (1133737282813048021) -->
+    <skip />
+    <!-- no translation found for accelerometer_summary_off (5485489363715740761) -->
+    <skip />
     <string name="brightness">"亮度"</string>
     <string name="brightness_summary">"調整螢幕亮度"</string>
     <string name="screen_timeout">"螢幕逾時"</string>
@@ -456,6 +464,12 @@
     <string name="error_apn_empty">"APN 不能空白。"</string>
     <string name="error_mcc_not3">"MCC 欄位必須為 3 位。"</string>
     <string name="error_mnc_not23">"MNC 欄位至少要 2 或 3 位。"</string>
+    <!-- no translation found for restore_default_apn (2724583218635739913) -->
+    <skip />
+    <!-- no translation found for menu_restore (8260067415075573273) -->
+    <skip />
+    <!-- no translation found for restore_default_apn_completed (3990449939234957281) -->
+    <skip />
     <string name="master_clear_title">"出廠資料重設"</string>
     <string name="master_clear_summary">"清除手機上所有資料"</string>
     <string name="master_clear_desc">"此項操作會將手機回復至出廠設定，清除所有資料與下載的應用程式！"</string>
@@ -592,6 +606,8 @@
     <string name="user_dict_settings_summary">"在使用者字典中新增及移除字詞"</string>
     <string name="user_dict_settings_add_menu_title">"新增"</string>
     <string name="user_dict_settings_add_dialog_title">"新增至字典"</string>
+    <!-- no translation found for user_dict_settings_edit_dialog_title (8967476444840548674) -->
+    <skip />
     <string name="user_dict_settings_context_menu_edit_title">"編輯"</string>
     <string name="user_dict_settings_context_menu_delete_title">"刪除"</string>
     <string name="user_dict_settings_empty_text">"您的使用者字典中沒有任何字詞。您可以透過選單新增字詞。"</string>
@@ -612,7 +628,14 @@
     <string name="quick_launch_display_mode_shortcuts">"捷徑"</string>
     <string name="input_methods_settings_title">"文字輸入法"</string>
     <string name="input_methods_settings_summary">"管理輸入法選項"</string>
-    <string name="input_methods_settings_label_format">"%s 設定"</string>
+    <!-- no translation found for input_methods_settings_label_format (6002887604815693322) -->
+    <skip />
+    <!-- no translation found for onscreen_keyboard_settings_summary (4919680715154885028) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_title (8169889453770863227) -->
+    <skip />
+    <!-- no translation found for builtin_keyboard_settings_summary (6404687907454621637) -->
+    <skip />
     <string name="development_settings_title">"開發"</string>
     <string name="development_settings_summary">"設定應用程式開發的選項"</string>
     <string name="enable_adb">"USB 除錯中"</string>
diff --git a/res/values/arrays.xml b/res/values/arrays.xml
index d9480c2..6cfa7f0 100644
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@@ -47,9 +47,9 @@
         <!-- Do not translate.  This is fed directly to the formatter. -->
         <item>dd-MM-yyyy</item>
         <!-- Do not translate.  This is fed directly to the formatter. -->
-        <item>MMM dd, yyyy</item>
+        <item>MMM d, yyyy</item>
         <!-- Do not translate.  This is fed directly to the formatter. -->
-        <item>dd-MMM-yyyy</item>
+        <item>d-MMM-yyyy</item>
         <!-- Do not translate.  This is fed directly to the formatter. -->
         <item>yyyy-MM-dd</item>
     </string-array>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 356dbef..55a153b 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -812,9 +812,9 @@
     <!-- Sound & display settings screen, animations check box label -->
     <string name="animations_title">Animation</string>
     <!-- Sound & display settings screen, animations option summary text when check box is selected -->
-    <string name="animations_summary_on">Show screen transition animations</string>
+    <string name="animations_summary_on">Show animation when opening &amp; closing windows</string>
     <!-- Sound & display settings screen, animations option summary text when check box is clear -->
-    <string name="animations_summary_off">Show screen transition animations</string>
+    <string name="animations_summary_off">Show animation when opening &amp; closing windows</string>
     <!-- Sound & display settings screen, accelerometer-based rotation check box label -->
     <string name="accelerometer_title">Orientation</string>
     <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is selected -->
@@ -1314,6 +1314,13 @@
     <string name="show_password">Visible passwords</string>
     <!-- On Security & location settings screen, setting check box summary. Summary for the visible passwords setting. -->
     <string name="show_password_summary">Show password as you type</string>
+    <!-- Warning message about security implications of enabling an input method, displayed as a dialog
+         message when the user selects to enable an IME. -->
+    <string name="ime_security_warning">This input method may be able to collect
+    all the text you type, including personal data like passwords and credit
+    card numbers.  It comes from the application
+    <xliff:g id="ime_application_name">%1$s</xliff:g>.
+    Enable this input method?</string>
     
     <!-- User dictionary settings --><skip />
     <!-- User dictionary settings, The titlebar text of the User dictionary settings screen. -->
diff --git a/src/com/android/settings/AppWidgetPickActivity.java b/src/com/android/settings/AppWidgetPickActivity.java
index 0a63712..acc9382 100644
--- a/src/com/android/settings/AppWidgetPickActivity.java
+++ b/src/com/android/settings/AppWidgetPickActivity.java
@@ -24,6 +24,7 @@
 import android.content.pm.PackageManager;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
+import android.os.Parcelable;
 import android.view.View;
 import android.widget.ListView;
 import android.util.Log;
@@ -40,6 +41,9 @@
 
     AppWidgetManager mAppWidgetManager;
     int mAppWidgetId;
+    ArrayList mCustomInfo;
+    ArrayList mCustomExtras;
+    Drawable mDefaultIcon = null;
     
     public AppWidgetPickActivity() {
         mAppWidgetManager = AppWidgetManager.getInstance(this);
@@ -47,12 +51,67 @@
 
     @Override
     public void onCreate(Bundle icicle) {
-        super.onCreate(icicle);
-
         Bundle extras = getIntent().getExtras();
+        if (extras == null) {
+            setResultData(RESULT_CANCELED, null);
+            finish();
+        }
+
         mAppWidgetId = extras.getInt(AppWidgetManager.EXTRA_APPWIDGET_ID);
 
-        setResultData(RESULT_CANCELED);
+        // get and validate the extras they gave us
+        ArrayList<Parcelable> customInfo = null;
+        ArrayList<AppWidgetProviderInfo> customExtras = null;
+        try_custom_items: {
+            customInfo = extras.getParcelableArrayList(AppWidgetManager.EXTRA_CUSTOM_INFO);
+            if (customInfo == null || customInfo.size() == 0) {
+                Log.i(TAG, "EXTRA_CUSTOM_INFO not present.");
+                break try_custom_items;
+            }
+
+            int customInfoSize = customInfo.size();
+            for (int i=0; i<customInfoSize; i++) {
+                Parcelable p = customInfo.get(i);
+                if (p == null || !(p instanceof AppWidgetProviderInfo)) {
+                    customInfo = null;
+                    Log.e(TAG, "error using EXTRA_CUSTOM_INFO index=" + i);
+                    break try_custom_items;
+                }
+            }
+
+            customExtras = extras.getParcelableArrayList(AppWidgetManager.EXTRA_CUSTOM_EXTRAS);
+            if (customExtras == null) {
+                customInfo = null;
+                Log.e(TAG, "EXTRA_CUSTOM_INFO without EXTRA_CUSTOM_EXTRAS");
+                break try_custom_items;
+            }
+
+            int customExtrasSize = customExtras.size();
+            if (customInfoSize != customExtrasSize) {
+                Log.e(TAG, "list size mismatch: EXTRA_CUSTOM_INFO: " + customInfoSize
+                        + " EXTRA_CUSTOM_EXTRAS: " + customExtrasSize);
+                break try_custom_items;
+            }
+
+
+            for (int i=0; i<customExtrasSize; i++) {
+                Parcelable p = customExtras.get(i);
+                if (p == null || !(p instanceof Bundle)) {
+                    customInfo = null;
+                    customExtras = null;
+                    Log.e(TAG, "error using EXTRA_CUSTOM_EXTRAS index=" + i);
+                    break try_custom_items;
+                }
+            }
+
+            mCustomInfo = customInfo;
+            mCustomExtras = customExtras;
+        }
+
+        // After the stuff with mCustomInfo
+        super.onCreate(icicle);
+
+        setResultData(RESULT_CANCELED, null);
     }
 
     @Override
@@ -60,41 +119,42 @@
     {
         Intent intent = intentForPosition(position);
         int result;
-        try {
-            mAppWidgetManager.bindAppWidgetId(mAppWidgetId, intent.getComponent());
-            result = RESULT_OK;
-        } catch (IllegalArgumentException e) {
-            // This is thrown if they're already bound, or otherwise somehow
-            // bogus.  Set the result to canceled, and exit.  The app *should*
-            // clean up at this point.  We could pass the error along, but
-            // it's not clear that that's useful -- the widget will simply not
-            // appear.
-            result = RESULT_CANCELED;
+        if (intent.getExtras() != null) {
+            // If there are any extras, it's because this entry is custom.
+            // Don't try to bind it, just pass it back to the app.
+            setResultData(RESULT_OK, intent);
+        } else {
+            try {
+                mAppWidgetManager.bindAppWidgetId(mAppWidgetId, intent.getComponent());
+                result = RESULT_OK;
+            } catch (IllegalArgumentException e) {
+                // This is thrown if they're already bound, or otherwise somehow
+                // bogus.  Set the result to canceled, and exit.  The app *should*
+                // clean up at this point.  We could pass the error along, but
+                // it's not clear that that's useful -- the widget will simply not
+                // appear.
+                result = RESULT_CANCELED;
+            }
+            setResultData(result, null);
         }
-        setResultData(result);
         finish();
     }
-    
-    @Override
-    public List<ListItem> makeListItems() {
-        List<AppWidgetProviderInfo> installed = mAppWidgetManager.getInstalledProviders();
-        PackageManager pm = getPackageManager();
 
-        Drawable defaultIcon = null;
-        IconResizer resizer = new IconResizer();
-
-        ArrayList<ListItem> result = new ArrayList();
-        final int N = installed.size();
+    void makeItems(List<AppWidgetProviderInfo> items, ArrayList<Bundle> extras,
+            ArrayList<ListItem> result, IconResizer resizer, PackageManager pm) {
+        final int N = items.size();
         for (int i=0; i<N; i++) {
-            AppWidgetProviderInfo info = installed.get(i);
+            AppWidgetProviderInfo info = items.get(i);
 
             LauncherActivity.ListItem item = new LauncherActivity.ListItem();
             item.packageName = info.provider.getPackageName();
             item.className = info.provider.getClassName();
-            
+            if (extras != null) {
+                item.extras = extras.get(i);
+            }
             item.label = info.label;
             if (info.icon != 0) {
-                Drawable d = pm.getDrawable( item.packageName, info.icon, null);
+                Drawable d = pm.getDrawable(item.packageName, info.icon, null);
                 if (d != null) {
                     item.icon = resizer.createIconThumbnail(d);
                 } else {
@@ -104,26 +164,46 @@
             }
             if (item.icon == null) {
                 // (including error case above)
-                if (defaultIcon == null) {
+                if (mDefaultIcon == null) {
                     // TODO: Load standard icon.
                 }
-                item.icon = defaultIcon;
+                item.icon = mDefaultIcon;
             }
             
             result.add(item);
         }
+    }
+    
+    @Override
+    public List<ListItem> makeListItems() {
+        List<AppWidgetProviderInfo> installed = mAppWidgetManager.getInstalledProviders();
+        PackageManager pm = getPackageManager();
 
+        IconResizer resizer = new IconResizer();
+        ArrayList<ListItem> result = new ArrayList();
+
+        // the ones from the package manager
+        makeItems(installed, null, result, resizer, pm);
+
+        // the ones provided in the intent we were launched with
+        if (mCustomInfo != null) {
+            Log.d(TAG, "Using " + mCustomInfo.size() + " custom items");
+            makeItems(mCustomInfo, mCustomExtras, result, resizer, pm);
+        }
+
+        // sort the results by name
         Collections.sort(result, new Comparator<ListItem>() {
                 Collator mCollator = Collator.getInstance();
                 public int compare(ListItem lhs, ListItem rhs) {
                     return mCollator.compare(lhs.label, rhs.label);
                 }
             });
+
         return result;
     }
 
-    void setResultData(int code) {
-        Intent result = new Intent();
+    void setResultData(int code, Intent intent) {
+        Intent result = intent != null ? intent : new Intent();
         result.putExtra(AppWidgetManager.EXTRA_APPWIDGET_ID, mAppWidgetId);
         setResult(code, result);
     }
diff --git a/src/com/android/settings/BrightnessPreference.java b/src/com/android/settings/BrightnessPreference.java
index a9851cc..9f55463 100644
--- a/src/com/android/settings/BrightnessPreference.java
+++ b/src/com/android/settings/BrightnessPreference.java
@@ -93,7 +93,7 @@
             IHardwareService hardware = IHardwareService.Stub.asInterface(
                     ServiceManager.getService("hardware"));
             if (hardware != null) {
-                hardware.setScreenBacklight(brightness);
+                hardware.setBacklights(brightness);
             }
         } catch (RemoteException doe) {
             
diff --git a/src/com/android/settings/ChooseLockPattern.java b/src/com/android/settings/ChooseLockPattern.java
index 3ddd669..d0c3758 100644
--- a/src/com/android/settings/ChooseLockPattern.java
+++ b/src/com/android/settings/ChooseLockPattern.java
@@ -481,8 +481,15 @@
     }
 
     private void saveChosenPatternAndFinish() {
+        final boolean lockVirgin = !mLockPatternUtils.isPatternEverChosen();
+
         mLockPatternUtils.saveLockPattern(mChosenPattern);
         mLockPatternUtils.setLockPatternEnabled(true);
+
+        if (lockVirgin) {
+            mLockPatternUtils.setVisiblePatternEnabled(true);
+            mLockPatternUtils.setTactileFeedbackEnabled(false);
+        }
         
         setResult(RESULT_FINISHED);
         finish();
diff --git a/src/com/android/settings/InputMethodsSettings.java b/src/com/android/settings/InputMethodsSettings.java
deleted file mode 100644
index 51b770d..0000000
--- a/src/com/android/settings/InputMethodsSettings.java
+++ /dev/null
@@ -1,191 +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.settings;
-
-import java.util.HashSet;
-import java.util.List;
-
-import android.content.Context;
-import android.content.Intent;
-import android.os.Bundle;
-import android.os.RemoteException;
-import android.os.SystemProperties;
-import android.preference.Preference;
-import android.preference.PreferenceActivity;
-import android.preference.PreferenceScreen;
-import android.preference.CheckBoxPreference;
-import android.provider.Settings;
-import android.text.TextUtils;
-import android.view.inputmethod.InputMethodInfo;
-import android.view.inputmethod.InputMethodManager;
-
-/*
- * Displays preferences for input methods.
- */
-public class InputMethodsSettings extends PreferenceActivity {
-    private List<InputMethodInfo> mInputMethodProperties;
-
-    final TextUtils.SimpleStringSplitter mStringColonSplitter
-            = new TextUtils.SimpleStringSplitter(':');
-    
-    private String mLastInputMethodId;
-    private String mLastTickedInputMethodId;
-
-    static public String getInputMethodIdFromKey(String key) {
-        return key;
-    }
-
-    @Override
-    protected void onCreate(Bundle icicle) {
-        super.onCreate(icicle);
-
-        addPreferencesFromResource(R.xml.input_methods_prefs);
-
-        InputMethodManager imm = (InputMethodManager) getSystemService(Context.INPUT_METHOD_SERVICE);
-
-        mInputMethodProperties = imm.getInputMethodList();
-
-        mLastInputMethodId = Settings.Secure.getString(getContentResolver(),
-            Settings.Secure.DEFAULT_INPUT_METHOD);
-
-        int N = (mInputMethodProperties == null ? 0 : mInputMethodProperties
-                .size());
-        for (int i = 0; i < N; ++i) {
-            InputMethodInfo property = mInputMethodProperties.get(i);
-            String prefKey = property.getId();
-
-            CharSequence label = property.loadLabel(getPackageManager());
-            
-            // Add a check box.
-            CheckBoxPreference chkbxPref = new CheckBoxPreference(this);
-            chkbxPref.setKey(prefKey);
-            chkbxPref.setTitle(label);
-            getPreferenceScreen().addPreference(chkbxPref);
-
-            // If setting activity is available, add a setting screen entry.
-            if (null != property.getSettingsActivity()) {
-                PreferenceScreen prefScreen = new PreferenceScreen(this, null);
-                prefScreen.setKey(property.getSettingsActivity());
-                prefScreen.setTitle(getResources().getString(
-                        R.string.input_methods_settings_label_format, label));
-                getPreferenceScreen().addPreference(prefScreen);
-            }
-        }
-    }
-
-    @Override
-    protected void onResume() {
-        super.onResume();
-
-        final HashSet<String> enabled = new HashSet<String>();
-        String enabledStr = Settings.Secure.getString(getContentResolver(),
-                Settings.Secure.ENABLED_INPUT_METHODS);
-        if (enabledStr != null) {
-            final TextUtils.SimpleStringSplitter splitter = mStringColonSplitter;
-            splitter.setString(enabledStr);
-            while (splitter.hasNext()) {
-                enabled.add(splitter.next());
-            }
-        }
-        
-        // Update the statuses of the Check Boxes.
-        int N = mInputMethodProperties.size();
-        for (int i = 0; i < N; ++i) {
-            final String id = mInputMethodProperties.get(i).getId();
-            CheckBoxPreference pref = (CheckBoxPreference) findPreference(mInputMethodProperties
-                    .get(i).getId());
-            pref.setChecked(enabled.contains(id));
-        }
-        mLastTickedInputMethodId = null;
-    }
-
-    @Override
-    protected void onPause() {
-        super.onPause();
-
-        StringBuilder builder = new StringBuilder(256);
-        
-        boolean haveLastInputMethod = false;
-        
-        int firstEnabled = -1;
-        int N = mInputMethodProperties.size();
-        for (int i = 0; i < N; ++i) {
-            final String id = mInputMethodProperties.get(i).getId();
-            CheckBoxPreference pref = (CheckBoxPreference) findPreference(id);
-            boolean hasIt = id.equals(mLastInputMethodId);
-            if (pref.isChecked()) {
-                if (builder.length() > 0) builder.append(':');
-                builder.append(id);
-                if (firstEnabled < 0) {
-                    firstEnabled = i;
-                }
-                if (hasIt) haveLastInputMethod = true;
-            } else if (hasIt) {
-                mLastInputMethodId = mLastTickedInputMethodId;
-            }
-        }
-
-        // If the last input method is unset, set it as the first enabled one.
-        if (null == mLastInputMethodId || "".equals(mLastInputMethodId)) {
-            if (firstEnabled >= 0) {
-                mLastInputMethodId = mInputMethodProperties.get(firstEnabled).getId();
-            } else {
-                mLastInputMethodId = null;
-            }
-        }
-        
-        Settings.Secure.putString(getContentResolver(),
-            Settings.Secure.ENABLED_INPUT_METHODS, builder.toString());
-        Settings.Secure.putString(getContentResolver(),
-            Settings.Secure.DEFAULT_INPUT_METHOD, mLastInputMethodId);
-    }
-
-    @Override
-    public boolean onPreferenceTreeClick(PreferenceScreen preferenceScreen,
-            Preference preference) {
-
-        // Those monkeys kept committing suicide, so we add this property
-        // to disable this functionality
-        if (!TextUtils.isEmpty(SystemProperties.get("ro.monkey"))) {
-            return false;
-        }
-
-        if (preference instanceof CheckBoxPreference) {
-            CheckBoxPreference chkPref = (CheckBoxPreference) preference;
-            String id = getInputMethodIdFromKey(chkPref.getKey());
-            if (chkPref.isChecked()) {
-                mLastTickedInputMethodId = id;
-            } else if (id.equals(mLastTickedInputMethodId)) {
-                mLastTickedInputMethodId = null;
-            }
-        } else if (preference instanceof PreferenceScreen) {
-            if (preference.getIntent() == null) {
-                PreferenceScreen pref = (PreferenceScreen) preference;
-                String activityName = pref.getKey();
-                String packageName = activityName.substring(0, activityName
-                        .lastIndexOf("."));
-                if (activityName.length() > 0) {
-                    Intent i = new Intent(Intent.ACTION_MAIN);
-                    i.setClassName(packageName, activityName);
-                    startActivity(i);
-                }
-            }
-        }
-
-        return false;
-    }
-}
diff --git a/src/com/android/settings/LanguageSettings.java b/src/com/android/settings/LanguageSettings.java
index dd447be..cbab390 100644
--- a/src/com/android/settings/LanguageSettings.java
+++ b/src/com/android/settings/LanguageSettings.java
@@ -16,8 +16,12 @@
 
 package com.android.settings;
 
+import android.app.AlertDialog;
+import android.app.Dialog;
 import android.content.Context;
+import android.content.DialogInterface;
 import android.content.Intent;
+import android.content.pm.ApplicationInfo;
 import android.content.res.Configuration;
 import android.os.Bundle;
 import android.os.Environment;
@@ -29,6 +33,7 @@
 import android.preference.PreferenceScreen;
 import android.provider.Settings;
 import android.text.TextUtils;
+import android.view.View.OnClickListener;
 import android.view.inputmethod.InputMethodInfo;
 import android.view.inputmethod.InputMethodManager;
 
@@ -74,12 +79,12 @@
             mHaveHardKeyboard = true;
         }
         mCheckboxes = new ArrayList<CheckBoxPreference>();
-        mRootDirectory = Environment.getRootDirectory().getAbsolutePath();
         onCreateIMM();
     }
     
     private boolean isSystemIme(InputMethodInfo property) {
-        return property.getServiceInfo().applicationInfo.sourceDir.startsWith(mRootDirectory);
+        return (property.getServiceInfo().applicationInfo.flags
+                & ApplicationInfo.FLAG_SYSTEM) != 0;
     }
     
     private void onCreateIMM() {
@@ -161,8 +166,6 @@
 
         StringBuilder builder = new StringBuilder(256);
         
-        boolean haveLastInputMethod = false;
-        
         int firstEnabled = -1;
         int N = mInputMethodProperties.size();
         for (int i = 0; i < N; ++i) {
@@ -178,7 +181,6 @@
                 if (firstEnabled < 0) {
                     firstEnabled = i;
                 }
-                if (hasIt) haveLastInputMethod = true;
             } else if (hasIt) {
                 mLastInputMethodId = mLastTickedInputMethodId;
             }
@@ -196,7 +198,8 @@
         Settings.Secure.putString(getContentResolver(),
             Settings.Secure.ENABLED_INPUT_METHODS, builder.toString());
         Settings.Secure.putString(getContentResolver(),
-            Settings.Secure.DEFAULT_INPUT_METHOD, mLastInputMethodId);
+            Settings.Secure.DEFAULT_INPUT_METHOD,
+            mLastInputMethodId != null ? mLastInputMethodId : "");
     }
 
     @Override
@@ -210,10 +213,49 @@
         }
 
         if (preference instanceof CheckBoxPreference) {
-            CheckBoxPreference chkPref = (CheckBoxPreference) preference;
-            String id = getInputMethodIdFromKey(chkPref.getKey());
+            final CheckBoxPreference chkPref = (CheckBoxPreference) preference;
+            final String id = getInputMethodIdFromKey(chkPref.getKey());
             if (chkPref.isChecked()) {
-                mLastTickedInputMethodId = id;
+                InputMethodInfo selImi = null;
+                final int N = mInputMethodProperties.size();
+                for (int i=0; i<N; i++) {
+                    InputMethodInfo imi = mInputMethodProperties.get(i);
+                    if (id.equals(imi.getId())) {
+                        selImi = imi;
+                        if (isSystemIme(imi)) {
+                            // This is a built-in IME, so no need to warn.
+                            mLastTickedInputMethodId = id;
+                            return super.onPreferenceTreeClick(preferenceScreen, preference);
+                        }
+                    }
+                }
+                chkPref.setChecked(false);
+                if (selImi == null) {
+                    return super.onPreferenceTreeClick(preferenceScreen, preference);
+                }
+                AlertDialog d = (new AlertDialog.Builder(this))
+                        .setTitle(android.R.string.dialog_alert_title)
+                        .setIcon(android.R.drawable.ic_dialog_alert)
+                        .setMessage(getString(R.string.ime_security_warning,
+                                selImi.getServiceInfo().applicationInfo.loadLabel(
+                                        getPackageManager())))
+                        .setCancelable(true)
+                        .setPositiveButton(android.R.string.ok,
+                                new DialogInterface.OnClickListener() {
+                                    public void onClick(DialogInterface dialog, int which) {
+                                        chkPref.setChecked(true);
+                                        mLastTickedInputMethodId = id;
+                                    }
+                            
+                        })
+                        .setNegativeButton(android.R.string.cancel,
+                                new DialogInterface.OnClickListener() {
+                                    public void onClick(DialogInterface dialog, int which) {
+                                    }
+                            
+                        })
+                        .create();
+                d.show();
             } else if (id.equals(mLastTickedInputMethodId)) {
                 mLastTickedInputMethodId = null;
             }
diff --git a/src/com/android/settings/ManageApplications.java b/src/com/android/settings/ManageApplications.java
index 7402727..7f2e2ce 100644
--- a/src/com/android/settings/ManageApplications.java
+++ b/src/com/android/settings/ManageApplications.java
@@ -59,6 +59,7 @@
 import java.util.Collections;
 import java.util.Comparator;
 import java.util.HashMap;
+import java.util.HashSet;
 import java.util.Iterator;
 import java.util.List;
 import java.util.Map;
@@ -138,8 +139,9 @@
     private static final int REORDER_LIST = HANDLER_MESSAGE_BASE+4;
     private static final int ADD_PKG_START = HANDLER_MESSAGE_BASE+5;
     private static final int ADD_PKG_DONE = HANDLER_MESSAGE_BASE+6;
-    private static final int REFRESH_ICONS = HANDLER_MESSAGE_BASE+7;
-    private static final int NEXT_LOAD_STEP = HANDLER_MESSAGE_BASE+8;
+    private static final int REFRESH_APP_RESOURCE = HANDLER_MESSAGE_BASE+7;
+    private static final int REFRESH_DONE = HANDLER_MESSAGE_BASE+8;
+    private static final int NEXT_LOAD_STEP = HANDLER_MESSAGE_BASE+9;
     
     // observer object used for computing pkg sizes
     private PkgSizeObserver mObserver;
@@ -248,37 +250,10 @@
             switch (msg.what) {
             case INIT_PKG_INFO:
                 if(localLOGV) Log.i(TAG, "Message INIT_PKG_INFO");
+                List<ApplicationInfo> newList = getInstalledApps(FILTER_APPS_ALL);
                 if (!mJustCreated) {
                     // Add or delete newly created packages by comparing lists
-                    List<ApplicationInfo> newList = getInstalledApps(FILTER_APPS_ALL);
-                    int oldCount = mAppPropCache.size();
-                    boolean idxArr[] = new boolean[oldCount];
-                    for ( int i = 0; i < oldCount; i++) {
-                        idxArr[i] = false;
-                    }
-                        
-                    if (newList != null) {
-                        for (ApplicationInfo app : newList) {
-                            AppInfo aInfo = mAppPropCache.get(app.packageName);
-                            if ( aInfo == null) {
-                                // New package. post an ADD_PKG message
-                                if(localLOGV) Log.i(TAG, "Adding pkg: "+app.packageName);
-                                updatePackageList(Intent.ACTION_PACKAGE_ADDED, app.packageName);
-                            } else {
-                                idxArr[aInfo.index] = true;
-                            }
-                        }
-                        Set<String> keyList = mAppPropCache.keySet();
-                        for (String key : keyList) {
-                            AppInfo aInfo = mAppPropCache.get(key);
-                            int idx = aInfo.index;
-                            if (!idxArr[idx]) {
-                                String pkg = aInfo.pkgName; 
-                                if(localLOGV) Log.i(TAG, "Deleting pkg: " + pkg);
-                                updatePackageList(Intent.ACTION_PACKAGE_REMOVED, pkg);
-                            }
-                        }
-                    }
+                    updateAppList(newList);
                 }
                 // Retrieve the package list and init some structures
                 initAppList(mFilterApps);
@@ -308,46 +283,11 @@
                     mObserver.invokeGetSizeInfo(mAppInfoAdapter.getApplicationInfo(
                             mComputeIndex), 
                             COMPUTE_PKG_SIZE_DONE);
-                } else {
-                    // check for added/removed packages
-                    Set<String> keys =  mAddRemoveMap.keySet();
-                    Iterator<String> iter = keys.iterator();
-                    List<String> removeList = new ArrayList<String>();
-                    boolean added = false;
-                    boolean removed = false;
-                    while (iter.hasNext()) {
-                        String key = iter.next();
-                        if (mAddRemoveMap.get(key) == Boolean.TRUE) {
-                            // add
-                            try {
-                                info = mPm.getApplicationInfo(key, 0);
-                                mAppInfoAdapter.addApplicationInfo(info);
-                                added = true;
-                            } catch (NameNotFoundException e) {
-                                Log.w(TAG, "Invalid added package:"+key+" Ignoring entry");
-                            }   
-                        } else {
-                            // remove
-                            removeList.add(key);
-                            removed = true;
-                        }
-                    }
-                    // remove uninstalled packages from list
-                    if (removed) {
-                        mAppInfoAdapter.removeFromList(removeList);
-                    }
-                    // handle newly installed packages
-                    if (added) {
-                        mObserver.invokeGetSizeInfo(mAppInfoAdapter.getApplicationInfo(
-                                mComputeIndex), 
-                                COMPUTE_PKG_SIZE_DONE);
-                    } else {
-                        // end computation here
-                        mComputeSizes = true;
-                        mFirst = true;
-                        mAppInfoAdapter.sortList(mSortOrder);
-                        mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
-                    }
+                } else {                    
+                    // End computation here
+                    mComputeSizes = true;
+                    mFirst = true;
+                    mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
                 }
                 break;
             case REMOVE_PKG:
@@ -381,8 +321,7 @@
                 } else if(menuOption != mFilterApps) {
                     // Option to filter list
                     mFilterApps = menuOption;
-                    boolean ret = mAppInfoAdapter.resetAppList(mFilterApps, 
-                            getInstalledApps(mFilterApps));
+                    boolean ret = mAppInfoAdapter.resetAppList(mFilterApps);
                     if(!ret) {
                         // Reset cache
                         mAppPropCache = null;
@@ -398,7 +337,7 @@
                     Log.w(TAG, "Ignoring message:ADD_PKG_START for null pkgName");
                     break;
                 }
-                if (!mComputeSizes) {
+                if (!mComputeSizes || !mLoadLabels) {
                     Boolean currB = mAddRemoveMap.get(pkgName);
                     if (currB == null || (currB.equals(Boolean.FALSE))) {
                         mAddRemoveMap.put(pkgName, Boolean.TRUE);
@@ -406,11 +345,11 @@
                     break;
                 }
                 try {
-                        info = mPm.getApplicationInfo(pkgName, 0);
-                    } catch (NameNotFoundException e) {
-                        Log.w(TAG, "Couldnt find application info for:"+pkgName);
-                        break;
-                    }
+                    info = mPm.getApplicationInfo(pkgName, 0);
+                } catch (NameNotFoundException e) {
+                    Log.w(TAG, "Couldnt find application info for:"+pkgName);
+                    break;
+                }
                 mObserver.invokeGetSizeInfo(info, ADD_PKG_DONE);
                 break;
             case ADD_PKG_DONE:
@@ -422,19 +361,33 @@
                 ps = data.getParcelable(ATTR_APP_PKG_STATS);
                 mAppInfoAdapter.addToList(pkgName, ps);
                 break;
-            case REFRESH_ICONS:
-                Map<String, AppInfo> iconMap = (Map<String, AppInfo>) msg.obj;
-                if(iconMap == null) {
+            case REFRESH_APP_RESOURCE:
+                AppInfo aInfo = (AppInfo) msg.obj;
+                if(aInfo == null) {
                     Log.w(TAG, "Error loading icons for applications");
                 } else {
-                    mAppInfoAdapter.updateAppsResourceInfo(iconMap);   
+                    mAppInfoAdapter.updateAppsResourceInfo(aInfo);   
                 }
+                break;
+            case REFRESH_DONE:
                 mLoadLabels = true;
                 mHandler.sendEmptyMessage(NEXT_LOAD_STEP);
                 break;
             case NEXT_LOAD_STEP:
                 if (mComputeSizes && mLoadLabels) {
                     doneLoadingData();
+                    // Check for added/removed packages
+                    Set<String> keys =  mAddRemoveMap.keySet();
+                    for (String key : keys) {
+                        if (mAddRemoveMap.get(key) == Boolean.TRUE) {
+                            // Add the package
+                            updatePackageList(Intent.ACTION_PACKAGE_ADDED, key);
+                        } else {
+                            // Remove the package
+                            updatePackageList(Intent.ACTION_PACKAGE_REMOVED, key);
+                        }
+                    }
+                    mAddRemoveMap.clear();
                 } else if (!mComputeSizes && !mLoadLabels) {
                      // Either load the package labels or initiate get size info
                     if (mSizesFirst) {
@@ -446,12 +399,13 @@
                     // Create list view from the adapter here. Wait till the sort order
                     // of list is defined. its either by label or by size. so atleast one of the
                     // first steps should be complete before filling the list
+                    mAppInfoAdapter.sortList(mSortOrder);
                     if (mJustCreated) {
                         // Set the adapter here.
                         mJustCreated = false;
                         mListView.setAdapter(mAppInfoAdapter);
                         dismissLoadingMsg();
-                    }
+                    } 
                     if (!mComputeSizes) {
                         initComputeSizes();
                     } else if (!mLoadLabels) {
@@ -465,7 +419,49 @@
         }
     };
     
-    
+    /*
+     * This method compares the current cache against a new list of
+     * installed applications and tries to update the list with add or remove
+     * messages.
+     */
+    private boolean updateAppList(List<ApplicationInfo> newList) {
+        if ((newList == null) || (mAppPropCache == null)) {
+            return false;
+        }
+        Set<String> existingList = new HashSet<String>();
+        boolean ret = false;
+        // Loop over new list and find out common elements between old and new lists
+        for (ApplicationInfo info : newList) {
+            String pkgName = info.packageName;
+            AppInfo aInfo = mAppPropCache.get(pkgName);
+            if (aInfo != null) {
+                existingList.add(pkgName);
+            } else {
+                // New package. update info by refreshing
+                if (localLOGV) Log.i(TAG, "New pkg :"+pkgName+" installed when paused");
+                updatePackageList(Intent.ACTION_PACKAGE_ADDED, pkgName);
+                ret = true;
+            }
+        }
+        // Loop over old list and figure out state entries
+        List<String> deletedList = null;
+        Set<String> staleList = mAppPropCache.keySet();
+        for (String pkgName : staleList) {
+            if (!existingList.contains(pkgName)) {
+                if (localLOGV) Log.i(TAG, "Pkg :"+pkgName+" deleted when paused");
+                if (deletedList == null) {
+                    deletedList = new ArrayList<String>();
+                    deletedList.add(pkgName);
+                }
+                ret = true;
+            }
+        }
+        // Delete right away
+        if (deletedList != null) {
+            mAppInfoAdapter.removeFromList(deletedList);
+        }
+        return ret;
+    }
     
     private void doneLoadingData() {
         setProgressBarIndeterminateVisibility(false);
@@ -524,16 +520,68 @@
         }
     }
     
+    /*
+     * Utility method used to figure out list of apps based on filterOption
+     * If the framework supports an additional flag to indicate running apps
+     *  we can get away with some code here.
+     */
+    List<ApplicationInfo> getFilteredApps(List<ApplicationInfo> pAppList, int filterOption) {
+        List<ApplicationInfo> retList = new ArrayList<ApplicationInfo>();
+        if(pAppList == null) {
+            return retList;
+        }
+        if (filterOption == FILTER_APPS_THIRD_PARTY) {
+            List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
+            for (ApplicationInfo appInfo : pAppList) {
+                boolean flag = false;
+                if ((appInfo.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
+                    // Updated system app
+                    flag = true;
+                } else if ((appInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
+                    // Non-system app
+                    flag = true;
+                }
+                if (flag) {
+                    appList.add(appInfo);
+                }
+            }
+            return appList;
+        } else if (filterOption == FILTER_APPS_RUNNING) {
+            List<ApplicationInfo> appList =new ArrayList<ApplicationInfo> ();
+            List<ActivityManager.RunningAppProcessInfo> procList = getRunningAppProcessesList();
+            if ((procList == null) || (procList.size() == 0)) {
+                return appList;
+            }
+            // Retrieve running processes from ActivityManager
+            HashMap<String, ActivityManager.RunningAppProcessInfo> runningMap = 
+                new HashMap<String, ActivityManager.RunningAppProcessInfo>();
+            for (ActivityManager.RunningAppProcessInfo appProcInfo : procList) {
+                if ((appProcInfo != null)  && (appProcInfo.pkgList != null)){
+                    int size = appProcInfo.pkgList.length;
+                    for (int i = 0; i < size; i++) {
+                        runningMap.put(appProcInfo.pkgList[i], appProcInfo);
+                    }
+                }
+            }
+            // Query list to find running processes in current list
+            for (ApplicationInfo appInfo : pAppList) {
+                if (runningMap.get(appInfo.packageName) != null) {
+                    appList.add(appInfo);
+                }
+            }
+            return appList;
+        } else {
+            return pAppList;
+        }
+    }
+    
     private List<ActivityManager.RunningAppProcessInfo> getRunningAppProcessesList() {
         ActivityManager am = (ActivityManager)getSystemService(Context.ACTIVITY_SERVICE);
         return am.getRunningAppProcesses();
     }
     
-    // some initialization code used when kicking off the size computation
     private void initAppList(int filterOption) {
-        // Initialize lists
-        List<ApplicationInfo> appList = getInstalledApps(filterOption);
-        initAppList(appList, filterOption);
+        initAppList(null, filterOption);
     }
     
      // some initialization code used when kicking off the size computation
@@ -544,7 +592,7 @@
         mLoadLabels = false;
         // Initialize lists
         mAddRemoveMap = new TreeMap<String, Boolean>();
-        mAppInfoAdapter.resetAppList(filterOption, appList);
+        mAppInfoAdapter.initMapFromList(appList, filterOption);
     }
     
     // Utility method to start a thread to read application labels and icons
@@ -552,6 +600,7 @@
         //load resources now
         if(mResourceThread.isAlive()) {
             mResourceThread.interrupt();
+            mResourceThread = new ResourceLoaderThread();
         }
         mResourceThread.loadAllResources(mAppInfoAdapter.getAppList());
     }
@@ -605,13 +654,13 @@
                 for (ApplicationInfo appInfo : mAppList) {
                     CharSequence appName = appInfo.loadLabel(mPm);
                     Drawable appIcon = appInfo.loadIcon(mPm);
-                    iconMap.put(appInfo.packageName, 
-                            new AppInfo(appInfo.packageName, appName, appIcon));
+                    Message msg = mHandler.obtainMessage(REFRESH_APP_RESOURCE);
+                    msg.obj = new AppInfo(appInfo.packageName, appName, appIcon);
+                    mHandler.sendMessage(msg);
                 }
             }
-            Message msg = mHandler.obtainMessage(REFRESH_ICONS);
-            msg.obj = iconMap;
-            mHandler.sendMessage(msg);
+            Message doneMsg = mHandler.obtainMessage(REFRESH_DONE);
+            mHandler.sendMessage(doneMsg);
         }
     }
     
@@ -700,6 +749,7 @@
      */
     class AppInfoAdapter extends BaseAdapter {
         private Map<String, AppInfo> mAppPropMap;
+        private List<ApplicationInfo> mAppList;
         private List<ApplicationInfo> mAppLocalList;
         ApplicationInfo.DisplayNameComparator mAlphaComparator;
         AppInfoComparator mSizeComparator;
@@ -710,34 +760,51 @@
             }
             return mAppPropCache.get(packageName);
         }
-        
-        public AppInfoAdapter(Context c, List<ApplicationInfo> appList) {
-            mAppLocalList = appList;
-            boolean useCache = false;
-            int sortOrder = SORT_ORDER_ALPHA;
-            int imax = mAppLocalList.size();
-            if(mAppPropCache != null) {
-                useCache = true;
-                // Activity has been resumed. can use the cache to populate values initially
-                mAppPropMap = mAppPropCache;
-                sortOrder = mSortOrder;
+
+        // Make sure the cache or map contains entries for all elements
+        // in appList for a valid sort.
+        public void initMapFromList(List<ApplicationInfo> appList, int filterOption) {
+            if (appList == null) {
+                // Just refresh the list
+                appList = mAppList;
+            } else {
+                mAppList = appList;
             }
+            mAppLocalList = getFilteredApps(appList, filterOption);
+            int sortOrder = SORT_ORDER_ALPHA;
+            if (mAppPropCache != null) {
+                // Retain previous sort order
+                sortOrder = mSortOrder;
+                mAppPropMap = mAppPropCache;
+            } else {
+                // Recreate property map
+                mAppPropMap = new TreeMap<String, AppInfo>();
+            }
+            // Re init the comparators
+            mAlphaComparator = null;
+            mSizeComparator = null;
+            
             sortAppList(sortOrder);
-            // Recreate property map
-            mAppPropMap = new TreeMap<String, AppInfo>();
+            int imax = appList.size();
             for (int i = 0; i < imax; i++) {
-                ApplicationInfo info = mAppLocalList.get(i);
-                AppInfo aInfo = getFromCache(info.packageName);
+                ApplicationInfo info  = appList.get(i);
+                AppInfo aInfo = mAppPropMap.get(info.packageName);
                 if(aInfo == null){
                     aInfo = new AppInfo(info.packageName, i, 
-                            info.packageName, mDefaultAppIcon, null);   
+                            info.packageName, mDefaultAppIcon, null);
+                    if (localLOGV) Log.i(TAG, "Creating entry pkg:"+info.packageName+" to map");
                 } else {
                     aInfo.index = i;
+                    if (localLOGV) Log.i(TAG, "Adding pkg:"+info.packageName+" to map");
                 }
                 mAppPropMap.put(info.packageName, aInfo);
             }
         }
         
+        public AppInfoAdapter(Context c, List<ApplicationInfo> appList) {
+            initMapFromList(appList, mFilterApps);
+        }
+        
         public int getCount() {
             return mAppLocalList.size();
         }
@@ -772,14 +839,6 @@
             }
             return mAppLocalList.get(position);
         }
-        
-        public void addApplicationInfo(ApplicationInfo info) {
-            if(info == null) {
-                Log.w(TAG, "Ignoring null add in List Adapter");
-                return;
-            }
-            mAppLocalList.add(info);
-        }
 
         public long getItemId(int position) {
             int imax = mAppLocalList.size();
@@ -843,9 +902,8 @@
         
         private void adjustIndex() {
             int imax = mAppLocalList.size();
-            ApplicationInfo info;
             for (int i = 0; i < imax; i++) {
-                info = mAppLocalList.get(i);
+                ApplicationInfo info = mAppLocalList.get(i);
                 mAppPropMap.get(info.packageName).index = i;
             }
         }
@@ -855,21 +913,28 @@
         }
         
         public void sortList(int sortOrder) {
+            if (localLOGV) Log.i(TAG, "sortOrder = "+sortOrder);
             sortAppList(sortOrder);
             adjustIndex();
             notifyDataSetChanged();
         }
         
-        public boolean resetAppList(int filterOption, List<ApplicationInfo> appList) {
-           // Create application list based on the filter value
-           mAppLocalList = appList;
+        /*
+         * Reset the application list associated with this adapter.
+         * @param filterOption Sort the list based on this value
+         * @param appList the actual application list that is used to reset
+         * @return Return a boolean value to indicate inconsistency
+         */
+        public boolean resetAppList(int filterOption) {
+           // Change application list based on filter option
+           mAppLocalList = getFilteredApps(mAppList, filterOption);
            // Check for all properties in map before sorting. Populate values from cache
            for(ApplicationInfo applicationInfo : mAppLocalList) {
                AppInfo appInfo = mAppPropMap.get(applicationInfo.packageName);
                if(appInfo == null) {
                    AppInfo rInfo = getFromCache(applicationInfo.packageName);
                    if(rInfo == null) {
-                       // Need to load resources again. Inconsistency somewhere
+                       // Need to load resources again. Inconsistency somewhere          
                        return false;
                    }
                    mAppPropMap.put(applicationInfo.packageName, rInfo);
@@ -912,7 +977,7 @@
                 return true;
             }
             boolean changed = false;
-            for (ApplicationInfo info : mAppLocalList) {
+            for (ApplicationInfo info : mAppList) {
                 AppInfo pInfo = iconMap.get(info.packageName);
                 if(pInfo != null) {
                     AppInfo aInfo = mAppPropMap.get(info.packageName);
@@ -930,27 +995,39 @@
             return true;
         }
         
+        public boolean updateAppsResourceInfo(AppInfo pInfo) {
+            if(pInfo == null) {
+                Log.w(TAG, "Null info when refreshing icon in List Adapter");
+                return false;
+            }
+            AppInfo aInfo = mAppPropMap.get(pInfo.pkgName);
+            if (aInfo != null) {
+                aInfo.refreshIcon(pInfo);
+                notifyDataSetChanged();
+                return true;
+            }
+            return false;
+        }
+        
         private boolean shouldBeInList(int filterOption, ApplicationInfo info) {
             // Match filter here
-            boolean addToCurrList = false;
             if (filterOption == FILTER_APPS_RUNNING) {
                 List<ApplicationInfo> runningList = getInstalledApps(FILTER_APPS_RUNNING);
                 for (ApplicationInfo running : runningList) {
                     if (running.packageName.equalsIgnoreCase(info.packageName)) {
-                        addToCurrList = true;
-                        break;
+                        return true;
                     }
                 }
             } else if (filterOption == FILTER_APPS_THIRD_PARTY) {
                 if ((info.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
-                    addToCurrList = true;
+                    return true;
                 } else if ((info.flags & ApplicationInfo.FLAG_UPDATED_SYSTEM_APP) != 0) {
-                    addToCurrList = true;
+                    return true;
                 }
             } else {
                 return true;
             }
-            return addToCurrList;
+            return false;
         }
         
         /*
@@ -961,20 +1038,15 @@
          * @param ps PackageStats of new package
          */
         public void addToList(String pkgName, PackageStats ps) {
-            if(pkgName == null) {
-                Log.w(TAG, "Adding null pkg to List Adapter");
+            if((pkgName == null) || (ps == null)) {
+                if (pkgName == null) {
+                    Log.w(TAG, "Adding null pkg to List Adapter");
+                } else {
+                    Log.w(TAG, "Adding pkg : "+pkgName+" with invalid PackageStats");
+                }
                 return;
             }
             boolean notInList = true;
-            int newIdx = getIndex(pkgName);
-            if (newIdx != -1) {
-                notInList = false;
-                if (mAppPropMap.get(pkgName) != null) {
-                    // weird. just ignore entry
-                    Log.i(TAG, "Package:"+pkgName+" already added");
-                    return;
-                }
-            }
             // Get ApplicationInfo
             ApplicationInfo info = null;
             try {
@@ -988,14 +1060,17 @@
                 Log.i(TAG, "Null ApplicationInfo for package:"+pkgName);
                 return;
             }
-            // Add entry to map
-            mAppPropMap.put(pkgName, new AppInfo(pkgName, newIdx,
+            // Add entry to local list
+            mAppList.add(info);
+            // Add entry to map. Note that the index gets adjusted later on based on
+            // whether the newly added package is part of displayed list
+            mAppPropMap.put(pkgName, new AppInfo(pkgName, -1,
                     info.loadLabel(mPm), info.loadIcon(mPm), ps));
             // Add to list
             if (notInList && (shouldBeInList(mFilterApps, info))) {
                 // Binary search returns a negative index (ie -index) of the position where
                 // this might be inserted. 
-                newIdx = Collections.binarySearch(mAppLocalList, info, 
+                int newIdx = Collections.binarySearch(mAppLocalList, info, 
                         getAppComparator(mSortOrder));
                 if(newIdx >= 0) {
                     Log.i(TAG, "Strange. Package:"+pkgName+" is not new");
@@ -1010,11 +1085,30 @@
             }
         }
         
+        private void removePkgListBase(List<String> pkgNames) {
+            for (String pkg : pkgNames) {
+                removePkgBase(pkg);
+            }
+        }
+        
+        private void removePkgBase(String pkgName) {
+            int imax = mAppList.size();
+            for (int i = 0; i < imax; i++) {
+                ApplicationInfo app = mAppList.get(i);
+                if (app.packageName.equalsIgnoreCase(pkgName)) {
+                    if (localLOGV) Log.i(TAG, "Removing pkg: "+pkgName+" from base list");
+                    mAppList.remove(i);
+                    return;
+                }
+            }
+        }
+        
         public void removeFromList(List<String> pkgNames) {
             if(pkgNames == null) {
                 Log.w(TAG, "Removing null pkg list from List Adapter");
                 return;
             }
+            removePkgListBase(pkgNames);
             int imax = mAppLocalList.size();
             boolean found = false;
             ApplicationInfo info;
@@ -1042,7 +1136,7 @@
             }
             // Sort idxArr
             Arrays.sort(idxArr);
-            // remove the packages based on decending indices
+            // remove the packages based on descending indices
             for (k = kmax-1; k >= 0; k--) {
                 // Check if package has been found in the list of existing apps first
                 if(idxArr[k] == -1) {
@@ -1051,13 +1145,13 @@
                 info = mAppLocalList.get(idxArr[k]);
                 mAppLocalList.remove(idxArr[k]);
                 mAppPropMap.remove(info.packageName);
-                if (localLOGV) Log.i(TAG, "Removed pkg:"+info.packageName+ " list");
+                if (localLOGV) Log.i(TAG, "Removed pkg:"+info.packageName+ " from display list");
             }
             if (found) {
                 adjustIndex();
                 notifyDataSetChanged();
             }
-        }   
+        }
         
         public void updateAppSize(String pkgName, PackageStats ps) {
             if(pkgName == null) {
@@ -1213,6 +1307,7 @@
         requestWindowFeature(Window.FEATURE_PROGRESS);
         requestWindowFeature(Window.FEATURE_INDETERMINATE_PROGRESS);
         setContentView(R.layout.compute_sizes);
+        showLoadingMsg();
         mDefaultAppIcon =Resources.getSystem().getDrawable(
                 com.android.internal.R.drawable.sym_def_app_icon);
         mInvalidSizeStr = getText(R.string.invalid_size_value);
@@ -1231,7 +1326,6 @@
         lv.setItemsCanFocus(true);
         lv.setOnItemClickListener(this);
         mListView = lv;
-        showLoadingMsg();
     }
     
     @Override
@@ -1263,9 +1357,9 @@
         super.onStart();
         // Create a thread to load resources
         mResourceThread = new ResourceLoaderThread();
-        sendMessageToHandler(INIT_PKG_INFO);
         // register receiver
         mReceiver.registerReceiver();
+        sendMessageToHandler(INIT_PKG_INFO);
     }
 
     @Override
diff --git a/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java b/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java
index f1a2a1e4..d458c5f 100644
--- a/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java
+++ b/src/com/android/settings/bluetooth/BluetoothDiscoverableEnabler.java
@@ -92,7 +92,6 @@
         }
 
         IntentFilter filter = new IntentFilter(BluetoothIntent.SCAN_MODE_CHANGED_ACTION);
-        filter.addAction(BluetoothIntent.DISABLED_ACTION);
         mContext.registerReceiver(mReceiver, filter);
         mCheckBoxPreference.setOnPreferenceChangeListener(this);
         
diff --git a/src/com/android/settings/bluetooth/BluetoothEnabler.java b/src/com/android/settings/bluetooth/BluetoothEnabler.java
index 661700f..82961b8 100644
--- a/src/com/android/settings/bluetooth/BluetoothEnabler.java
+++ b/src/com/android/settings/bluetooth/BluetoothEnabler.java
@@ -17,8 +17,9 @@
 package com.android.settings.bluetooth;
 
 import com.android.settings.R;
-import com.android.settings.bluetooth.LocalBluetoothManager.ExtendedBluetoothState;
 
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ -70,15 +71,15 @@
             return;
         }
         
-        ExtendedBluetoothState state = mLocalManager.getBluetoothState();
+        int state = mLocalManager.getBluetoothState();
         // This is the widget enabled state, not the preference toggled state
-        mCheckBoxPreference.setEnabled(state == ExtendedBluetoothState.ENABLED ||
-                state == ExtendedBluetoothState.DISABLED);
+        mCheckBoxPreference.setEnabled(state == BluetoothDevice.BLUETOOTH_STATE_ON ||
+                state == BluetoothDevice.BLUETOOTH_STATE_OFF);
         // BT state is not a sticky broadcast, so set it manually
         handleStateChanged(state);
         
         mContext.registerReceiver(mReceiver, 
-                new IntentFilter(LocalBluetoothManager.EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION));
+                new IntentFilter(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION));
         mCheckBoxPreference.setOnPreferenceChangeListener(this);
     }
     
@@ -106,22 +107,24 @@
         mLocalManager.setBluetoothEnabled(enable);
     }
     
-    private void handleStateChanged(ExtendedBluetoothState state) {
+    private void handleStateChanged(int state) {
 
-        if (state == ExtendedBluetoothState.DISABLED || state == ExtendedBluetoothState.ENABLED) {
-            mCheckBoxPreference.setChecked(state == ExtendedBluetoothState.ENABLED);
-            mCheckBoxPreference
-                    .setSummary(state == ExtendedBluetoothState.DISABLED ? mOriginalSummary : null);
+        if (state == BluetoothDevice.BLUETOOTH_STATE_OFF ||
+                state == BluetoothDevice.BLUETOOTH_STATE_ON) {
+            mCheckBoxPreference.setChecked(state == BluetoothDevice.BLUETOOTH_STATE_ON);
+            mCheckBoxPreference.setSummary(state == BluetoothDevice.BLUETOOTH_STATE_OFF ?
+                                           mOriginalSummary :
+                                           null);
             
             mCheckBoxPreference.setEnabled(isEnabledByDependency());
             
-        } else if (state == ExtendedBluetoothState.ENABLING ||
-                state == ExtendedBluetoothState.DISABLING) {
-            mCheckBoxPreference.setSummary(state == ExtendedBluetoothState.ENABLING
+        } else if (state == BluetoothDevice.BLUETOOTH_STATE_TURNING_ON ||
+                state == BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF) {
+            mCheckBoxPreference.setSummary(state == BluetoothDevice.BLUETOOTH_STATE_TURNING_ON
                     ? R.string.wifi_starting
                     : R.string.wifi_stopping);
             
-        } else if (state == ExtendedBluetoothState.UNKNOWN) {
+        } else {
             mCheckBoxPreference.setChecked(false);
             mCheckBoxPreference.setSummary(R.string.wifi_error);
             mCheckBoxPreference.setEnabled(true);
diff --git a/src/com/android/settings/bluetooth/BluetoothEventRedirector.java b/src/com/android/settings/bluetooth/BluetoothEventRedirector.java
index 2ad5726..71b91d3 100644
--- a/src/com/android/settings/bluetooth/BluetoothEventRedirector.java
+++ b/src/com/android/settings/bluetooth/BluetoothEventRedirector.java
@@ -16,8 +16,6 @@
 
 package com.android.settings.bluetooth;
 
-import com.android.settings.bluetooth.LocalBluetoothManager.ExtendedBluetoothState;
-
 import android.bluetooth.BluetoothA2dp;
 import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothHeadset;
@@ -50,12 +48,10 @@
             String action = intent.getAction();
             String address = intent.getStringExtra(BluetoothIntent.ADDRESS);
                 
-            if (action.equals(BluetoothIntent.ENABLED_ACTION)) {
-                mManager.setBluetoothStateInt(ExtendedBluetoothState.ENABLED);
-                
-            } else if (action.equals(BluetoothIntent.DISABLED_ACTION)) {
-                mManager.setBluetoothStateInt(ExtendedBluetoothState.DISABLED);
-                    
+            if (action.equals(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION)) {
+                int state = intent.getIntExtra(BluetoothIntent.BLUETOOTH_STATE,
+                                        BluetoothError.ERROR);
+                mManager.setBluetoothStateInt(state);
             } else if (action.equals(BluetoothIntent.DISCOVERY_STARTED_ACTION)) {
                 mManager.onScanningStateChanged(true);
                 
@@ -86,25 +82,29 @@
                 }
                 
             } else if (action.equals(BluetoothIntent.HEADSET_STATE_CHANGED_ACTION)) {
-                mManager.getLocalDeviceManager().onProfileStateChanged(address);
-
                 int newState = intent.getIntExtra(BluetoothIntent.HEADSET_STATE, 0);
                 int oldState = intent.getIntExtra(BluetoothIntent.HEADSET_PREVIOUS_STATE, 0);
                 if (newState == BluetoothHeadset.STATE_DISCONNECTED &&
                         oldState == BluetoothHeadset.STATE_CONNECTING) {
                     Log.i(TAG, "Failed to connect BT headset");
                 }
-                
-            } else if (action.equals(BluetoothA2dp.SINK_STATE_CHANGED_ACTION)) {
-                mManager.getLocalDeviceManager().onProfileStateChanged(address);
 
+                boolean transientState = !(newState == BluetoothHeadset.STATE_CONNECTED
+                                || newState == BluetoothHeadset.STATE_DISCONNECTED);
+                mManager.getLocalDeviceManager().onProfileStateChanged(address,transientState);
+
+            } else if (action.equals(BluetoothA2dp.SINK_STATE_CHANGED_ACTION)) {
                 int newState = intent.getIntExtra(BluetoothA2dp.SINK_STATE, 0);
                 int oldState = intent.getIntExtra(BluetoothA2dp.SINK_PREVIOUS_STATE, 0);
                 if (newState == BluetoothA2dp.STATE_DISCONNECTED &&
                         oldState == BluetoothA2dp.STATE_CONNECTING) {
                     Log.i(TAG, "Failed to connect BT A2DP");
                 }
-                
+
+                boolean transientState = !(newState == BluetoothA2dp.STATE_CONNECTED
+                        || newState == BluetoothA2dp.STATE_DISCONNECTED);
+                mManager.getLocalDeviceManager().onProfileStateChanged(address, transientState);
+
             } else if (action.equals(BluetoothIntent.REMOTE_DEVICE_CLASS_UPDATED_ACTION)) {
                 mManager.getLocalDeviceManager().onBtClassChanged(address);
                 
@@ -120,8 +120,7 @@
         IntentFilter filter = new IntentFilter();
         
         // Bluetooth on/off broadcasts
-        filter.addAction(BluetoothIntent.ENABLED_ACTION);
-        filter.addAction(BluetoothIntent.DISABLED_ACTION);
+        filter.addAction(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION);
         
         // Discovery broadcasts
         filter.addAction(BluetoothIntent.DISCOVERY_STARTED_ACTION);
diff --git a/src/com/android/settings/bluetooth/BluetoothNamePreference.java b/src/com/android/settings/bluetooth/BluetoothNamePreference.java
index 3065b26..40bab2c 100644
--- a/src/com/android/settings/bluetooth/BluetoothNamePreference.java
+++ b/src/com/android/settings/bluetooth/BluetoothNamePreference.java
@@ -17,6 +17,7 @@
 package com.android.settings.bluetooth;
 
 import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothError;
 import android.bluetooth.BluetoothIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
@@ -39,7 +40,14 @@
     private BroadcastReceiver mReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
-            setSummaryToName();
+            String action = intent.getAction();
+            if (action.equals(BluetoothIntent.NAME_CHANGED_ACTION)) {
+                setSummaryToName();
+            } else if (action.equals(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION) &&
+                    (intent.getIntExtra(BluetoothIntent.BLUETOOTH_STATE,
+                    BluetoothError.ERROR) == BluetoothDevice.BLUETOOTH_STATE_ON)) {
+                setSummaryToName();
+            }
         }
     };
     
@@ -53,7 +61,7 @@
 
     public void resume() {
         IntentFilter filter = new IntentFilter();
-        filter.addAction(BluetoothIntent.ENABLED_ACTION);
+        filter.addAction(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION);
         filter.addAction(BluetoothIntent.NAME_CHANGED_ACTION);
         getContext().registerReceiver(mReceiver, filter);
     }
diff --git a/src/com/android/settings/bluetooth/BluetoothSettings.java b/src/com/android/settings/bluetooth/BluetoothSettings.java
index 5adada3..e6ac5fd 100644
--- a/src/com/android/settings/bluetooth/BluetoothSettings.java
+++ b/src/com/android/settings/bluetooth/BluetoothSettings.java
@@ -18,11 +18,12 @@
 
 import com.android.settings.ProgressCategory;
 import com.android.settings.R;
-import com.android.settings.bluetooth.LocalBluetoothManager.ExtendedBluetoothState;
 
 import java.util.List;
 import java.util.WeakHashMap;
 
+import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
@@ -117,8 +118,8 @@
         
         mLocalManager.startScanning(false);
 
-        registerReceiver(mReceiver, 
-                new IntentFilter(LocalBluetoothManager.EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION));
+        registerReceiver(mReceiver,
+                new IntentFilter(BluetoothIntent.BLUETOOTH_STATE_CHANGED_ACTION));
         
         mLocalManager.setForegroundActivity(this);
     }
@@ -248,12 +249,12 @@
         mDeviceList.setProgress(started);
     }
     
-    private void onBluetoothStateChanged(ExtendedBluetoothState bluetoothState) {
+    private void onBluetoothStateChanged(int bluetoothState) {
         // When bluetooth is enabled (and we are in the activity, which we are),
         // we should start a scan
-        if (bluetoothState == ExtendedBluetoothState.ENABLED) {
+        if (bluetoothState == BluetoothDevice.BLUETOOTH_STATE_ON) {
             mLocalManager.startScanning(false);
-        } else if (bluetoothState == ExtendedBluetoothState.DISABLED) {
+        } else if (bluetoothState == BluetoothDevice.BLUETOOTH_STATE_OFF) {
             mDeviceList.setProgress(false);
         }
     }
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothDevice.java b/src/com/android/settings/bluetooth/LocalBluetoothDevice.java
index a488540..eedae93 100644
--- a/src/com/android/settings/bluetooth/LocalBluetoothDevice.java
+++ b/src/com/android/settings/bluetooth/LocalBluetoothDevice.java
@@ -20,22 +20,23 @@
 import com.android.settings.bluetooth.LocalBluetoothProfileManager.Profile;
 
 import android.app.AlertDialog;
-import android.bluetooth.BluetoothDevice;
 import android.bluetooth.BluetoothClass;
-import android.bluetooth.IBluetoothDeviceCallback;
+import android.bluetooth.BluetoothDevice;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
 import android.content.res.Resources;
-import android.os.IBinder;
-import android.os.RemoteException;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.ContextMenu;
 import android.view.Menu;
 import android.view.MenuItem;
 
+import java.text.DateFormat;
 import java.util.ArrayList;
+import java.util.Date;
+import java.util.Iterator;
+import java.util.LinkedList;
 import java.util.List;
 
 /**
@@ -71,6 +72,173 @@
      */
     private boolean mIsConnectingErrorPossible;
 
+    // Max time to hold the work queue if we don't get or missed a response
+    // from the bt framework.
+    private static final long MAX_WAIT_TIME_FOR_FRAMEWORK = 25 * 1000;
+
+    private enum BluetoothCommand {
+        CONNECT, DISCONNECT,
+    }
+
+    class BluetoothJob {
+        final BluetoothCommand command; // CONNECT, DISCONNECT
+        final LocalBluetoothDevice device;
+        final Profile profile; // HEADSET, A2DP, etc
+        // 0 means this command was not been sent to the bt framework.
+        long timeSent;
+
+        public BluetoothJob(BluetoothCommand command,
+                LocalBluetoothDevice device, Profile profile) {
+            this.command = command;
+            this.device = device;
+            this.profile = profile;
+            this.timeSent = 0;
+        }
+        
+        @Override
+        public String toString() {
+            StringBuilder sb = new StringBuilder();
+            sb.append(command.name());
+            sb.append(" Address:").append(device.mAddress);
+            sb.append(" Profile:").append(profile.name());
+            sb.append(" TimeSent:");
+            if (timeSent == 0) {
+                sb.append("not yet");
+            } else {
+                sb.append(DateFormat.getTimeInstance().format(new Date(timeSent)));
+            }
+            return sb.toString();
+        }
+    }
+
+    /**
+     * We want to serialize connect and disconnect calls. http://b/170538
+     * This are some headsets that may have L2CAP resource limitation. We want
+     * to limit the bt bandwidth usage.
+     *
+     * A queue to keep track of asynchronous calls to the bt framework.  The
+     * first item, if exist, should be in progress i.e. went to the bt framework
+     * already, waiting for a notification to come back. The second item and
+     * beyond have not been sent to the bt framework yet.
+     */
+    private static LinkedList<BluetoothJob> workQueue = new LinkedList<BluetoothJob>();
+
+    private void queueCommand(BluetoothJob job) {
+        Log.d(TAG, workQueue.toString());
+        synchronized (workQueue) {
+            boolean processNow = false;
+            long now = System.currentTimeMillis();
+
+            Iterator<BluetoothJob> it = workQueue.iterator();
+            while (it.hasNext()) {
+                BluetoothJob existingJob = it.next();
+
+                // Remove any pending CONNECTS when we receive a DISCONNECT
+                if (job.command == BluetoothCommand.DISCONNECT) {
+                    if (existingJob.timeSent == 0
+                            && existingJob.command == BluetoothCommand.CONNECT
+                            && existingJob.device.mAddress.equals(job.device.mAddress)
+                            && existingJob.profile == job.profile) {
+                        it.remove();
+                        continue;
+                    }
+                }
+
+                // Defensive Code: Remove any job that older than a preset time.
+                // We never got a call back. It is better to have overlapping
+                // calls than to get stuck.
+                Log.d(TAG, "Age:" + (now - existingJob.timeSent));
+                if (existingJob.timeSent != 0
+                        && (now - existingJob.timeSent) >= MAX_WAIT_TIME_FOR_FRAMEWORK) {
+                    Log.w(TAG, "Timeout. Removing Job:" + existingJob.toString());
+                    it.remove();
+                    processNow = true;
+                    continue;
+                }
+            }
+
+            // Add job to queue
+            Log.d(TAG, "Adding: " + job.toString());
+            workQueue.add(job);
+
+            // if there's nothing pending from before, send the command to bt
+            // framework immediately.
+            if (workQueue.size() == 1 || processNow) {
+                Log.d(TAG, "workQueue.size() == 1 || TimeOut -> process command now");
+                // If the failed to process, just drop it from the queue.
+                // There will be no callback to remove this from the queue.
+                processCommands();
+            }
+        }
+    }
+
+    private boolean processCommand(BluetoothJob job) {
+        boolean successful = false;
+        if (job.timeSent == 0) {
+            job.timeSent = System.currentTimeMillis();                
+            switch (job.command) {
+            case CONNECT:
+                successful = connectInt(job.device, job.profile);
+                break;
+            case DISCONNECT:
+                successful = disconnectInt(job.device, job.profile);
+                break;
+            }
+
+            if (successful) {
+                Log.d(TAG, "Command sent successfully:" + job.toString());
+            } else {
+                Log.d(TAG, "Framework rejected command immediately:" + job.toString());
+            }
+            
+        } else {
+            Log.d(TAG, "Job already has a sent time. Skip. " + job.toString());
+        }
+
+        return successful;
+    }
+
+    public void onProfileStateChanged() {
+        // Remove the first item and process the next one
+        BluetoothJob job = workQueue.poll();
+        if (job == null) {
+            Log.w(TAG, "Yikes, onProfileStateChanged called but job queue is empty");
+        } else if (job.device.mAddress != mAddress) {
+            Log.w(TAG, "Yikes, onProfileStateChanged called but the address differ. this.mAddress="
+                    + mAddress + " workQueue.head=" + job.toString());
+        } else {
+            Log.d(TAG, "LocalBluetoothDevice.onProfileStateChanged() called. MAC addr matched");
+        }
+
+        processCommands();
+    }
+
+    /*
+     * This method is called in 2 places:
+     * 1) queryCommand() - when someone or something want to connect or
+     *    disconnect
+     * 2) onProfileStateChanged() - when the framework sends an intent
+     *    notification when it finishes processing a command
+     */
+    private void processCommands() {
+        Iterator<BluetoothJob> it = workQueue.iterator();
+        while (it.hasNext()) {
+            BluetoothJob job = it.next();
+            if (processCommand(job)) {
+                // Sent to bt framework. Done for now. Will remove this job
+                // from queue when we get an event
+                return;
+            } else {
+                /*
+                 * If the command failed immediately, there will be no event
+                 * callbacks. So delete the job immediately and move on to the
+                 * next one
+                 */
+                it.remove();
+            }
+        }
+    }
+
     LocalBluetoothDevice(Context context, String address) {
         mLocalManager = LocalBluetoothManager.getInstance(context);
         if (mLocalManager == null) {
@@ -102,12 +270,19 @@
     }
 
     public void disconnect(Profile profile) {
+        queueCommand(new BluetoothJob(BluetoothCommand.DISCONNECT, this, profile));
+    }
+
+    private boolean disconnectInt(LocalBluetoothDevice device, Profile profile) {
         LocalBluetoothProfileManager profileManager =
                 LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
-        int status = profileManager.getConnectionStatus(mAddress);
+        int status = profileManager.getConnectionStatus(device.mAddress);
         if (SettingsBtStatus.isConnectionStatusConnected(status)) {
-            profileManager.disconnect(mAddress);
+            if (profileManager.disconnect(device.mAddress) == BluetoothDevice.RESULT_SUCCESS) {
+                return true;
+            }
         }
+        return false;
     }
 
     public void askDisconnect() {
@@ -153,7 +328,7 @@
                     LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
             if (profileManager.isPreferred(mAddress)) {
                 hasAtLeastOnePreferredProfile = true;
-                connectInt(profile);
+                queueCommand(new BluetoothJob(BluetoothCommand.CONNECT, this, profile));
             }
         }
 
@@ -173,27 +348,30 @@
             LocalBluetoothProfileManager profileManager =
                     LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
             profileManager.setPreferred(mAddress, true);
-            connectInt(profile);
+            queueCommand(new BluetoothJob(BluetoothCommand.CONNECT, this, profile));
         }
     }
 
     public void connect(Profile profile) {
         // Reset the only-show-one-error-dialog tracking variable
         mIsConnectingErrorPossible = true;
-        connectInt(profile);
+        queueCommand(new BluetoothJob(BluetoothCommand.CONNECT, this, profile));
     }
 
-    public void connectInt(Profile profile) {
-        if (!ensurePaired()) return;
+    private boolean connectInt(LocalBluetoothDevice device, Profile profile) {
+        if (!device.ensurePaired()) return false;
 
         LocalBluetoothProfileManager profileManager =
                 LocalBluetoothProfileManager.getProfileManager(mLocalManager, profile);
-        int status = profileManager.getConnectionStatus(mAddress);
+        int status = profileManager.getConnectionStatus(device.mAddress);
         if (!SettingsBtStatus.isConnectionStatusConnected(status)) {
-            if (profileManager.connect(mAddress) != BluetoothDevice.RESULT_SUCCESS) {
-                Log.i(TAG, "Failed to connect " + profile.toString() + " to " + mName);
+            if (profileManager.connect(device.mAddress) == BluetoothDevice.RESULT_SUCCESS) {
+                return true;
             }
+            Log.i(TAG, "Failed to connect " + profile.toString() + " to " + device.mName);
         }
+        Log.i(TAG, "Not connected");
+        return false;
     }
 
     public void showConnectingError() {
@@ -228,6 +406,24 @@
     }
 
     public void unpair() {
+        synchronized (workQueue) {
+            // Remove any pending commands for this device
+            boolean processNow = false;            
+            Iterator<BluetoothJob> it = workQueue.iterator();
+            while (it.hasNext()) {
+                BluetoothJob job = it.next();
+                if (job.device.mAddress.equals(this.mAddress)) {
+                    it.remove();
+                    if (job.timeSent != 0) {
+                        processNow = true;
+                    }
+                }
+            }
+            if (processNow) {
+                processCommands();
+            }
+        }
+
         BluetoothDevice manager = mLocalManager.getBluetoothManager();
 
         switch (getBondState()) {
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java b/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java
index 6bb2b4a..9527980 100644
--- a/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java
+++ b/src/com/android/settings/bluetooth/LocalBluetoothDeviceManager.java
@@ -16,11 +16,8 @@
 
 package com.android.settings.bluetooth;
 
-import android.app.AlertDialog;
 import android.bluetooth.BluetoothDevice;
 import android.util.Log;
-import android.widget.Toast;
-import android.content.Context;
 
 import com.android.settings.R;
 import com.android.settings.bluetooth.LocalBluetoothManager.Callback;
@@ -190,10 +187,13 @@
                         R.string.bluetooth_pairing_error_message);
     }
     
-    public synchronized void onProfileStateChanged(String address) {
+    public synchronized void onProfileStateChanged(String address, boolean transientState) {
         LocalBluetoothDevice device = findDevice(address);
         if (device == null) return;
         
+        if (!transientState) {
+            device.onProfileStateChanged();
+        }
         device.refresh();
     }
     
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothManager.java b/src/com/android/settings/bluetooth/LocalBluetoothManager.java
index 4671fac..1a848b2 100644
--- a/src/com/android/settings/bluetooth/LocalBluetoothManager.java
+++ b/src/com/android/settings/bluetooth/LocalBluetoothManager.java
@@ -25,6 +25,8 @@
 import android.app.AlertDialog;
 import android.bluetooth.BluetoothA2dp;
 import android.bluetooth.BluetoothDevice;
+import android.bluetooth.BluetoothError;
+import android.bluetooth.BluetoothIntent;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
@@ -40,8 +42,6 @@
     private static final String TAG = "LocalBluetoothManager";
     static final boolean V = true;
     
-    public static final String EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION =
-        "com.android.settings.bluetooth.intent.action.EXTENDED_BLUETOOTH_STATE_CHANGED";
     private static final String SHARED_PREFERENCES_NAME = "bluetooth_settings";
     
     private static LocalBluetoothManager INSTANCE;
@@ -60,8 +60,7 @@
     private BluetoothEventRedirector mEventRedirector;
     private BluetoothA2dp mBluetoothA2dp;
     
-    public static enum ExtendedBluetoothState { ENABLED, ENABLING, DISABLED, DISABLING, UNKNOWN }
-    private ExtendedBluetoothState mState = ExtendedBluetoothState.UNKNOWN;
+    private int mState = BluetoothError.ERROR;
 
     private List<Callback> mCallbacks = new ArrayList<Callback>();
     
@@ -182,34 +181,27 @@
         }
     }
     
-    public ExtendedBluetoothState getBluetoothState() {
+    public int getBluetoothState() {
         
-        if (mState == ExtendedBluetoothState.UNKNOWN) {
+        if (mState == BluetoothError.ERROR) {
             syncBluetoothState();
         }
             
         return mState;
     }
     
-    void setBluetoothStateInt(ExtendedBluetoothState state) {
+    void setBluetoothStateInt(int state) {
         mState = state;
-        
-        /*
-         * TODO: change to callback method. originally it was broadcast to
-         * parallel the framework's method, but it just complicates things here.
-         */
-        // If this were a real API, I'd add as an extra
-        mContext.sendBroadcast(new Intent(EXTENDED_BLUETOOTH_STATE_CHANGED_ACTION));
-        
-        if (state == ExtendedBluetoothState.ENABLED || state == ExtendedBluetoothState.DISABLED) {
-            mLocalDeviceManager.onBluetoothStateChanged(state == ExtendedBluetoothState.ENABLED);
+        if (state == BluetoothDevice.BLUETOOTH_STATE_ON ||
+            state == BluetoothDevice.BLUETOOTH_STATE_OFF) {
+            mLocalDeviceManager.onBluetoothStateChanged(state == BluetoothDevice.BLUETOOTH_STATE_ON);
         }
     }
     
     private void syncBluetoothState() {
         setBluetoothStateInt(mManager.isEnabled()
-                ? ExtendedBluetoothState.ENABLED
-                : ExtendedBluetoothState.DISABLED);
+                ? BluetoothDevice.BLUETOOTH_STATE_ON
+                : BluetoothDevice.BLUETOOTH_STATE_OFF);
     }
 
     public void setBluetoothEnabled(boolean enabled) {
@@ -219,8 +211,8 @@
                 
         if (wasSetStateSuccessful) {
             setBluetoothStateInt(enabled
-                    ? ExtendedBluetoothState.ENABLING
-                    : ExtendedBluetoothState.DISABLING);
+                ? BluetoothDevice.BLUETOOTH_STATE_TURNING_ON
+                : BluetoothDevice.BLUETOOTH_STATE_TURNING_OFF);
         } else {
             if (V) {
                 Log.v(TAG,
diff --git a/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java b/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java
index 50edf86..24563a7 100644
--- a/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java
+++ b/src/com/android/settings/bluetooth/LocalBluetoothProfileManager.java
@@ -72,19 +72,22 @@
     /**
      * Temporary method to fill profiles based on a device's class.
      * 
+     * NOTE: This list happens to define the connection order. We should put this logic in a more
+     * well known place when this method is no longer temporary.
+     * 
      * @param btClass The class
      * @param profiles The list of profiles to fill
      */
     public static void fill(int btClass, List<Profile> profiles) {
         profiles.clear();
 
-        if (BluetoothA2dp.doesClassMatchSink(btClass)) {
-            profiles.add(Profile.A2DP);
-        }
-        
         if (BluetoothHeadset.doesClassMatch(btClass)) {
             profiles.add(Profile.HEADSET);
         }
+        
+        if (BluetoothA2dp.doesClassMatchSink(btClass)) {
+            profiles.add(Profile.A2DP);
+        }
     }
 
     protected LocalBluetoothProfileManager(LocalBluetoothManager localManager) {
@@ -214,7 +217,7 @@
                      */
                     String address = mService.getHeadsetAddress();
                     if (TextUtils.isEmpty(address)) return;
-                    mLocalManager.getLocalDeviceManager().onProfileStateChanged(address);
+                    mLocalManager.getLocalDeviceManager().onProfileStateChanged(address, true);
                 }
             });
         }
