diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index adf36a2..15bb878 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -1211,6 +1211,8 @@
                 android:enabled="@bool/has_powercontrol_widget">
             <intent-filter>
                 <action android:name="android.appwidget.action.APPWIDGET_UPDATE" />
+                <action android:name="android.appwidget.action.APPWIDGET_ENABLED" />
+                <action android:name="android.appwidget.action.APPWIDGET_DISABLED" />
                 <action android:name="android.net.wifi.WIFI_STATE_CHANGED" />
                 <action android:name="android.net.conn.BACKGROUND_DATA_SETTING_CHANGED" />
                 <action android:name="android.bluetooth.adapter.action.STATE_CHANGED" />
diff --git a/res/drawable-hdpi/ic_appwidget_settings_brightness_half_holo.png b/res/drawable-hdpi/ic_appwidget_settings_brightness_half_holo.png
new file mode 100644
index 0000000..3a5a043
--- /dev/null
+++ b/res/drawable-hdpi/ic_appwidget_settings_brightness_half_holo.png
Binary files differ
diff --git a/res/drawable-mdpi/ic_appwidget_settings_brightness_half_holo.png b/res/drawable-mdpi/ic_appwidget_settings_brightness_half_holo.png
new file mode 100644
index 0000000..fe043f5
--- /dev/null
+++ b/res/drawable-mdpi/ic_appwidget_settings_brightness_half_holo.png
Binary files differ
diff --git a/res/drawable-xhdpi/ic_appwidget_settings_brightness_half_holo.png b/res/drawable-xhdpi/ic_appwidget_settings_brightness_half_holo.png
new file mode 100644
index 0000000..b6d238b
--- /dev/null
+++ b/res/drawable-xhdpi/ic_appwidget_settings_brightness_half_holo.png
Binary files differ
diff --git a/res/layout/device_admin_add.xml b/res/layout/device_admin_add.xml
index b1ad72c..d6a0dcb 100644
--- a/res/layout/device_admin_add.xml
+++ b/res/layout/device_admin_add.xml
@@ -25,8 +25,9 @@
         android:layout_width="match_parent"
         android:layout_height="0dip"
         android:layout_weight="1.0"
-        android:layout_marginLeft="16dip"
-        android:layout_marginRight="16dip"
+        android:paddingLeft="16dip"
+        android:paddingRight="16dip"
+        android:scrollbarStyle="outsideOverlay"
         android:gravity="top">
         <LinearLayout
             android:layout_width="match_parent"
@@ -36,12 +37,12 @@
             <LinearLayout
                 android:layout_width="match_parent"
                 android:layout_height="wrap_content"
-                android:orientation="horizontal">
+                android:orientation="horizontal"
+                android:layout_marginTop="16dip">
                 <ImageView android:id="@+id/admin_icon"
                     android:layout_width="@android:dimen/app_icon_size"
                     android:layout_height="@android:dimen/app_icon_size"
-                    android:layout_marginLeft="5dip"
-                    android:layout_marginRight="11dip"
+                    android:layout_marginRight="16dip"
                     android:layout_gravity="center_vertical"
                     android:scaleType="fitCenter"/>
                 <TextView android:id="@+id/admin_name"
@@ -101,18 +102,14 @@
     <LinearLayout android:id="@+id/buttonPanel"
         android:layout_width="match_parent"
         android:layout_height="wrap_content"
-        android:minHeight="54dip"
         android:orientation="vertical"
         android:divider="?android:attr/dividerHorizontal"
-        android:showDividers="beginning"
-        android:dividerPadding="16dip">
+        android:showDividers="beginning">
         <LinearLayout
             style="?android:attr/buttonBarStyle"
             android:layout_width="match_parent"
             android:layout_height="wrap_content"
             android:orientation="horizontal"
-            android:paddingLeft="2dip"
-            android:paddingRight="2dip"
             android:measureWithLargestChild="true">
             <LinearLayout android:id="@+id/leftSpacer"
                 android:layout_weight="0.25"
diff --git a/res/values/arrays.xml b/res/values/arrays.xml
index 5ee80bf..7bd76a9 100644
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@@ -149,7 +149,7 @@
         <item msgid="6490061470416867723">Small</item>
         <item msgid="3579015730662088893">Normal</item>
         <item msgid="1678068858001018666">Large</item>
-        <item msgid="490158884605093126">Extra Large</item>
+        <item msgid="490158884605093126">Extra large</item>
     </string-array>
 
     <string-array name="entryvalues_font_size" translatable="false">
@@ -315,9 +315,9 @@
         <!-- Push button based configuration involves pushing a button on two connecting devices [CHAR LIMIT=30]-->
         <item>Push button</item>
         <!-- This involves entering a pin obtained from a peer device [CHAR LIMIT=30] -->
-        <item>Pin from peer device</item>
+        <item>PIN from peer device</item>
         <!-- This involves generating a pin from this device [CHAR LIMIT=20] -->
-        <item>Pin from this device</item>
+        <item>PIN from this device</item>
     </string-array>
 
     <!-- Match this with the order of WifiP2pDevice.Status -->
@@ -327,7 +327,7 @@
         <item>Invited</item>
         <item>Unsuccessful</item>
         <item>Available</item>
-        <item>Out of range</item>
+        <item>Out-of-range</item>
    </string-array>
 
 
@@ -406,9 +406,9 @@
 
     <!-- Display options for UsageStats class -->
     <string-array name="usage_stats_display_order_types">
-        <item>Usage Time</item>
-        <item>Launch Count</item>
-        <item>Application Name</item>
+        <item>Usage time</item>
+        <item>Launch count</item>
+        <item>App name</item>
     </string-array>
 
     <!-- EAP method -->
@@ -435,9 +435,9 @@
         <!-- WPS is a new standard that allowes secure connection establishment to a home wireless network using a simplified process. WPS push button based configuration involves pushing a button on the router and the device [CHAR LIMIT=25]-->
         <item>Push button</item>
         <!-- WPS pin method based configuration. This requires entering a pin obtained from the access point [CHAR LIMIT=25] -->
-        <item>Pin from access point</item>
+        <item>PIN from access point</item>
         <!-- WPS pin method based configuration. This requires generating a pin from this device [CHAR LIMIT=25] -->
-        <item>Pin from this device</item>
+        <item>PIN from this device</item>
     </string-array>
 
     <!-- Wi-Fi IP settings. -->
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 37441a4..7b554bb 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -274,15 +274,15 @@
     <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices -->
     <string name="progress_scanning">Searching</string>
     <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices is finished, indicating that user can tap on a device to pair with it [CHAR LIMIT=20]-->
-    <string name="progress_tap_to_pair">Tap to pair</string>
+    <string name="progress_tap_to_pair">Touch to pair</string>
     <!--Bluetooth settings screen, text that appears when scanning for devices is finished and no nearby bluetooth device was found [CHAR LIMIT=40]-->
-    <string name="bluetooth_no_devices_found">No Bluetooth devices were found nearby.</string>
+    <string name="bluetooth_no_devices_found">No nearby Bluetooth devices were found.</string>
     <!-- Notification ticker text (shown in the status bar) when a Bluetooth device wants to pair with us -->
     <string name="bluetooth_notif_ticker">Bluetooth pairing request</string>
     <!-- Notification title when a Bluetooth device wants to pair with us -->
     <string name="bluetooth_notif_title">Pairing request</string>
     <!-- Notification message when a Bluetooth device wants to pair with us -->
-    <string name="bluetooth_notif_message">Select to pair with <xliff:g id="device_name">%1$s</xliff:g></string>
+    <string name="bluetooth_notif_message">Touch to pair with <xliff:g id="device_name">%1$s</xliff:g></string>
     <!-- Bluetooth settings screen, menu to show the list of received files [CHAR LIMIT=30] -->
     <string name="bluetooth_show_received_files">Show received files</string>
 
@@ -293,25 +293,25 @@
     <string name="bluetooth_permission_request">"Bluetooth permission request"</string>
 
     <!-- Strings for asking to the user whether to allow an app to enable bluetooth -->
-    <string name="bluetooth_ask_enablement">"An application is requesting permission to turn on Bluetooth. Do you want to do this?"</string>
+    <string name="bluetooth_ask_enablement">"An app wants to turn on Bluetooth. Allow?"</string>
 
     <!-- Strings for asking to the user whether to allow an app to enable discovery mode -->
-    <string name="bluetooth_ask_discovery" product="tablet">"An application on your tablet is requesting permission to make your tablet discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Do you want to do this?"</string>
+    <string name="bluetooth_ask_discovery" product="tablet">"An app on your tablet wants to make your tablet discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>
     <!-- Strings for asking to the user whether to allow an app to enable discovery mode -->
-    <string name="bluetooth_ask_discovery" product="default">"An application on your phone is requesting permission to make your phone discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Do you want to do this?"</string>
+    <string name="bluetooth_ask_discovery" product="default">"An app on your phone wants to make your phone discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>
 
     <!-- Strings for asking to the user whether to allow an app to enable lasting discovery mode  -->
-    <string name="bluetooth_ask_lasting_discovery" product="tablet">"An application on your tablet is requesting permission to make your tablet \u201calways discoverable\u201d by other Bluetooth devices. Do you want to do this?"</string>
-    <string name="bluetooth_ask_lasting_discovery" product="default">"An application on your phone is requesting permission to make your phone \u201calways discoverable\u201d by other Bluetooth devices. Do you want to do this?"</string>
+    <string name="bluetooth_ask_lasting_discovery" product="tablet">"An app on your tablet wants to make your tablet \u201calways discoverable\u201d by other Bluetooth devices. Allow?"</string>
+    <string name="bluetooth_ask_lasting_discovery" product="default">"An app on your phone wants to make your phone \u201calways discoverable\u201d by other Bluetooth devices. Allow?"</string>
 
     <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
-    <string name="bluetooth_ask_enablement_and_discovery" product="tablet">"An application on your tablet is requesting permission to turn on Bluetooth and to make your tablet discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Do you want to do this?"</string>
+    <string name="bluetooth_ask_enablement_and_discovery" product="tablet">"An app on your tablet wants to turn on Bluetooth and make your tablet discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>
     <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
-    <string name="bluetooth_ask_enablement_and_discovery" product="default">"An application on your phone is requesting permission to turn on Bluetooth and to make your phone discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Do you want to do this?"</string>
+    <string name="bluetooth_ask_enablement_and_discovery" product="default">"An app on your phone wants to turn on Bluetooth and make your phone discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>
 
     <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
-    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet">"An application on your tablet is requesting permission to turn on Bluetooth and to make your tablet discoverable by other devices. Do you want to do this?"</string>
-    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default">"An application on your phone is requesting permission to turn on Bluetooth and to make your phone discoverable by other devices. Do you want to do this?"</string>
+    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet">"An app on your tablet wants to turn on Bluetooth and make your tablet discoverable by other devices. Allow?"</string>
+    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default">"An app on your phone wants to turn on Bluetooth and make your phone discoverable by other devices. Allow?"</string>
 
     <!-- Strings for msg to display to user while bluetooth is turning on [CHAR LIMIT=60] -->
     <string name="bluetooth_turning_on">"Turning Bluetooth on\u2026"</string>
@@ -320,13 +320,13 @@
     <string name="bluetooth_turning_off">"Turning Bluetooth off\u2026"</string>
 
     <!-- Strings for device profile auto connect setting -->
-    <string name="bluetooth_auto_connect">Auto connect</string>
+    <string name="bluetooth_auto_connect">Auto-connect</string>
 
     <!-- Activity label of BluetoothPermissionActivity [CHAR LIMIT=none]-->
     <string name="bluetooth_connection_permission_request">"Bluetooth connection request"</string>
 
     <!-- Notification message when a remote Bluetooth device wants to connect to a Bluetooth profile [CHAR LIMIT=none]-->
-    <string name="bluetooth_connection_notif_message">"Touch to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022"</string>
+    <string name="bluetooth_connection_notif_message">"Touch to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022."</string>
 
     <!-- Bluetooth connection permission Alert Activity text [CHAR LIMIT=none]-->
     <string name="bluetooth_connection_dialog_text">"Do you want to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022?"</string>
@@ -347,7 +347,7 @@
     <!-- Date/time settings.  Summary of the checkbox for choosing between 12 hour time or 24 hour time.  Sample of 24-hour time -->
     <string name="date_time_24_hour_sample">13:00</string>
     <!-- The title of the activity to pick a time zone. -->
-    <string name="choose_timezone">Select time zone</string>
+    <string name="choose_timezone">Choose time zone</string>
     <!-- Do not translate. Used as the value for a setting. -->
     <string name="default_date_format"><xliff:g id="default_date_format">MM/dd/yyyy</xliff:g></string>
 
@@ -398,17 +398,17 @@
     <!-- HTTP proxy settings. Button to get rid of error box-->
     <string name="proxy_error_dismiss">OK</string>
     <!-- HTTP proxy settings. The error if the hostname is not valid -->
-    <string name="proxy_error_invalid_host">The hostname you typed is not valid.</string>
+    <string name="proxy_error_invalid_host">The hostname you typed isn\'t valid.</string>
     <!-- HTTP proxy settings. The error if the exclusion list is not valid -->
-    <string name="proxy_error_invalid_exclusion_list">The exclusion list you typed is not properly formatted. Please enter a comma-separated list of excluded domains.</string>
+    <string name="proxy_error_invalid_exclusion_list">The exclusion list you typed isn\'t properly formatted. Type a comma-separated list of excluded domains.</string>
     <!-- HTTP proxy settings. Error msg -->
     <string name="proxy_error_empty_port">You must complete the port field.</string>
     <!-- HTTP proxy settings. Error msg -->
     <string name="proxy_error_empty_host_set_port">The port field must be empty if the host field is empty.</string>
     <!-- HTTP proxy settings. Error msg -->
-    <string name="proxy_error_invalid_port">The port you typed is not valid.</string>
+    <string name="proxy_error_invalid_port">The port you typed isn\'t valid.</string>
     <!-- HTTP proxy settings. Warning message about limited application support [CHAR LIMIT=100]-->
-    <string name="proxy_warning_limited_support">The HTTP proxy is used by the browser but may not be used by the other applications</string>
+    <string name="proxy_warning_limited_support">The HTTP proxy is used by the browser but may not be used by the other apps.</string>
 
     <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
     <string name="radio_info_signal_location_label">Location:</string>
@@ -503,9 +503,9 @@
     <!-- Message when the SD card is being used by the computer as mass storage -->
     <string name="sdcard_settings_mass_storage_status" product="default">SD card is being used as a mass storage device</string>
     <!-- Message when it is safe to remove the SD card [CHAR LIMIT=30] -->
-    <string name="sdcard_settings_unmounted_status" product="nosdcard">It is now safe to remove the USB storage</string>
+    <string name="sdcard_settings_unmounted_status" product="nosdcard">It\'s now safe to remove the USB storage</string>
     <!-- Message when it is safe to remove the SD card -->
-    <string name="sdcard_settings_unmounted_status" product="default">It is now safe to remove the SD card</string>
+    <string name="sdcard_settings_unmounted_status" product="default">It\'s now safe to remove the SD card</string>
     <!-- Error message when the SD card was removed without properly unmounting [CHAR LIMIT=30] -->
     <string name="sdcard_settings_bad_removal_status" product="nosdcard">USB storage was removed while still in use!</string>
     <!-- Error message when the SD card was removed without properly unmounting -->
@@ -530,7 +530,7 @@
     <string name="language_picker_title">Language</string>
 
     <!-- The title of the dialog to pick an activity.  This is shown when there are multiple activities that can do a particular action.  For example, suppose you click on the "Share" menu item in the Browser.  Since you can share the webpage URL via many communication methods, this dialog would come up with choices like "Email", "IM", etc.  This is a generic message, and the previous example is a single possible scenario (so please don't assume it's for the browser or anything :) ). -->
-    <string name="activity_picker_label">Select activity</string>
+    <string name="activity_picker_label">Choose activity</string>
     <!-- Do not translate. -->
     <string name="debug_intent_sender_label">Debug intent sender</string>
     <!-- The title of the activity to see random device info. -->
@@ -570,7 +570,7 @@
     <!-- Wireless Settings screen title for things like Wi-Fi, bluetooth, airplane mode. -->
     <string name="wireless_networks_settings_title">Wireless &amp; networks</string>
     <!-- Main Settings screen settings summary text for the "Wireless controls" setting -->
-    <string name="radio_controls_summary">Manage Wi-Fi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</string>
+    <string name="radio_controls_summary">Manage WiFi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</string>
 
     <!-- mobile network settings screen, setting check box title -->
     <string name="roaming">Data roaming</string>
@@ -589,7 +589,7 @@
     <!-- mobile network settings screen, setting option name -->
     <string name="networks">Operator selection</string>
     <!-- mobile network settings screen, setting option summary text -->
-    <string name="sum_carrier_select">Select a network operator</string>
+    <string name="sum_carrier_select">Choose a network operator</string>
 
     <!-- Date and time settings --><skip />
     <!-- Main Settings screen setting option name to go into the date and time settings-->
@@ -597,7 +597,7 @@
     <!-- Title for Date & Time settings screen in SetupWizard [CHAR LIMIT=40] -->
     <string name="date_and_time_settings_title_setup_wizard">Set date and time</string>
     <!-- Main Settings screen setting option summary text for the item to go into the date and time settings. -->
-    <string name="date_and_time_settings_summary">Set date, time, time zone &amp; formats</string>
+    <string name="date_and_time_settings_summary">Set date, time, time zone, &amp; formats</string>
     <!-- Date & time setting screen setting check box title if the date and time should be determined automatically [CHAR LIMIT=25] -->
     <string name="date_time_auto">Automatic date &amp; time</string>
     <!-- Date & time setting screen setting option summary text when Automatic check box is selected
@@ -648,7 +648,7 @@
     <!-- Text shown for summary of owner info setting [CHAR LIMIT=40]-->
     <string name="owner_info_settings_summary"></string>
     <!-- Hint text shown in owner info edit text [CHAR LIMIT=50] -->
-    <string name="owner_info_settings_edit_text_hint">Enter text to display on the lock screen</string>
+    <string name="owner_info_settings_edit_text_hint">Type text to display on the lock screen</string>
     <!-- Main Settings screen setting option title for the item to take you to the location screen -->
     <string name="location_settings_title">Location services</string>
     <!-- Main Settings screen setting option title for the item to take you to the security screen -->
@@ -681,7 +681,7 @@
 
     <!-- Informational text in the first confirmation screen before starting device encryption -->
     <string name="crypt_keeper_desc" product="tablet">
-    You can encrypt your accounts, settings, downloaded applications and their data,
+    You can encrypt your accounts, settings, downloaded apps and their data,
     media, and other files. Once you encrypt your tablet, you must enter a numeric PIN
     or password to decrypt it each time you power it on: you can\'t unencrypt your tablet
     except by performing a factory data reset, erasing all your data.\n\nEncryption takes
@@ -690,7 +690,7 @@
     some or all of your data.</string>
     <!-- Informational text in the first confirmation screen before starting device encryption -->
     <string name="crypt_keeper_desc" product="default">
-    You can encrypt your accounts, settings, downloaded applications and their data,
+    You can encrypt your accounts, settings, downloaded apps and their data,
     media, and other files. Once you encrypt your phone, you must enter a numeric PIN or
     password to decrypt it each time you power it on: you can\'t unencrypt your phone
     except by performing a factory data reset, erasing all your data.\n\nEncryption takes
@@ -704,9 +704,9 @@
     <string name="crypt_keeper_button_text" product="default">Encrypt phone</string>
 
     <!-- Warning string that will be displayed when encryption cannot be started -->
-    <string name="crypt_keeper_low_charge_text">Please charge your battery and try again.</string>
+    <string name="crypt_keeper_low_charge_text">Charge your battery and try again.</string>
     <!-- Warning string that will be displayed when encryption cannot be started -->
-    <string name="crypt_keeper_unplugged_text">Please plug in your charger and try again.</string>
+    <string name="crypt_keeper_unplugged_text">Plug in your charger and try again.</string>
 
     <!-- Dialog title, shown when encryption cannot proceed because a PIN/Password is needed -->
     <string name="crypt_keeper_dialog_need_password_title">No lock screen PIN or password</string>
@@ -731,17 +731,17 @@
     <string name="crypt_keeper_setup_title">Encrypting</string>
 
     <!-- Informational text on the progress screen while encrypting the device -->
-    <string name="crypt_keeper_setup_description" product="tablet">Please wait while your tablet
+    <string name="crypt_keeper_setup_description" product="tablet">Wait while your tablet
     is being encrypted. <xliff:g id="percent" example="50">^1</xliff:g>% complete.</string>
     <!-- Informational text on the progress screen while encrypting the device -->
-    <string name="crypt_keeper_setup_description" product="default">Please wait while your phone
+    <string name="crypt_keeper_setup_description" product="default">Wait while your phone
     is being encrypted. <xliff:g id="percent" example="50">^1</xliff:g>% complete.</string>
 
     <!-- Informational text on the password entry screen when password entry fails-->
     <string name="crypt_keeper_cooldown">Try again in <xliff:g id="delay" example="15">^1</xliff:g> seconds.</string>
 
     <!-- Informational text on the password entry screen prompting the user for their password -->
-    <string name="crypt_keeper_enter_password">Enter your password</string>
+    <string name="crypt_keeper_enter_password">Type your password</string>
 
     <!-- Title of the encryption screen when encrypting the device failed -->
     <string name="crypt_keeper_failed_title">Encryption unsuccessful</string>
@@ -801,7 +801,7 @@
     <string name="unlock_set_unlock_none_summary">No security</string>
 
     <!-- Title for preference that guides the user through a weak biometric lock [CHAR LIMIT=22] -->
-    <string name="unlock_set_unlock_biometric_weak_title">Face Unlock</string>
+    <string name="unlock_set_unlock_biometric_weak_title">Face unlock</string>
     <!-- Summary for preference that disables unlock security [CHAR LIMIT=45]-->
     <string name="unlock_set_unlock_biometric_weak_summary">Low security, experimental</string>
 
@@ -969,10 +969,10 @@
     <string name="bluetooth_pairing_request">Bluetooth pairing request</string>
 
     <!-- Message when bluetooth dialog for pin entry is showing. [CHAR LIMIT=NONE] -->
-    <string name="bluetooth_enter_pin_msg">To pair with:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Enter the device\'s required PIN:</string>
+    <string name="bluetooth_enter_pin_msg">To pair with:<xliff:g id="bold">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold">&lt;/b>&lt;br>&lt;br></xliff:g>Type the device\'s required PIN:</string>
 
     <!-- Message when bluetooth dialog for passkey entry is showing. [CHAR LIMIT=NONE] -->
-    <string name="bluetooth_enter_passkey_msg">To pair with:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Enter the device\'s required passkey:</string>
+    <string name="bluetooth_enter_passkey_msg">To pair with:<xliff:g id="bold">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold">&lt;/b>&lt;br>&lt;br></xliff:g>Type the device\'s required passkey:</string>
 
     <!-- Checkbox label for alphanumeric PIN entry (default is numeric PIN). [CHAR LIMIT=50] -->
     <string name="bluetooth_enable_alphanumeric_pin">PIN contains letters or symbols</string>
@@ -992,7 +992,7 @@
     <string name="bluetooth_incoming_pairing_msg">From:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Pair with this device?</string>
 
     <!-- Message when bluetooth dialog when passkey or pin needs to be displayed. -->
-    <string name="bluetooth_display_passkey_pin_msg">To pair with:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Type on it:&lt;br>&lt;b><xliff:g id="passkey">%2$s</xliff:g>&lt;/b>, then Return or Enter.</string>
+    <string name="bluetooth_display_passkey_pin_msg">To pair with:<xliff:g id="bold1">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold1">&lt;/b>&lt;br>&lt;br></xliff:g>Type on it:<xliff:g id="bold2">&lt;br>&lt;b></xliff:g><xliff:g id="passkey">%2$s</xliff:g><xliff:g id="end_bold2">&lt;/b></xliff:g>, then press Return or Enter.</string>
 
     <!-- Button text for accepting an incoming pairing request. [CHAR LIMIT=20] -->
     <string name="bluetooth_pairing_accept">Pair</string>
@@ -1000,14 +1000,14 @@
     <string name="bluetooth_pairing_decline">Cancel</string>
 
     <!-- Title for BT error dialogs. -->
-    <string name="bluetooth_error_title">Attention</string>
+    <string name="bluetooth_error_title"></string>
     <!-- Message for the error dialog when BT pairing fails generically. -->
-    <string name="bluetooth_pairing_error_message">There was a problem pairing with <xliff:g id="device_name">%1$s</xliff:g>.</string>
+    <string name="bluetooth_pairing_error_message">Couldn\'t pair with <xliff:g id="device_name">%1$s</xliff:g>.</string>
     <!-- Message for the error dialog when BT pairing fails because the PIN /
     Passkey entered is incorrect. -->
-    <string name="bluetooth_pairing_pin_error_message">There was a problem pairing with <xliff:g id="device_name">%1$s</xliff:g> because the PIN or Passkey is incorrect.</string>
+    <string name="bluetooth_pairing_pin_error_message">Couldn\'t pair with <xliff:g id="device_name">%1$s</xliff:g> because of an incorrect PIN or passkey.</string>
     <!-- Message for the error dialog when BT pairing fails because the other device is down. -->
-    <string name="bluetooth_pairing_device_down_error_message">Cannot establish communication with <xliff:g id="device_name">%1$s</xliff:g>.</string>
+    <string name="bluetooth_pairing_device_down_error_message">Can\'t communicate with <xliff:g id="device_name">%1$s</xliff:g>.</string>
     <!-- Message for the error dialog when BT pairing fails because the other device rejected the pairing. -->
     <string name="bluetooth_pairing_rejected_error_message">Pairing rejected by <xliff:g id="device_name">%1$s</xliff:g>.</string>
 
@@ -1148,27 +1148,27 @@
 
     <!-- Wi-Fi Settings --> <skip />
     <!-- Used in the 1st-level settings screen to turn on Wi-Fi -->
-    <string name="wifi_quick_toggle_title">Wi-Fi</string>
+    <string name="wifi_quick_toggle_title">WiFi</string>
     <!-- Used in the 1st-level settings screen as the turn-on summary -->
-    <string name="wifi_quick_toggle_summary">Turn on Wi-Fi</string>
+    <string name="wifi_quick_toggle_summary">Turn on WiFi</string>
     <!-- Used in the 1st-level settings screen to go to the 2nd-level settings screen  [CHAR LIMIT=20]-->
-    <string name="wifi_settings">Wi-Fi</string>
+    <string name="wifi_settings">WiFi</string>
     <!-- Title of the Wi-fi settings screen -->
-    <string name="wifi_settings_category">Wi-Fi settings</string>
+    <string name="wifi_settings_category">WiFi settings</string>
     <!-- Title of the Wi-fi settings entry in the left top level menu -->
-    <string name="wifi_settings_title">Wi-Fi</string>
+    <string name="wifi_settings_title">WiFi</string>
     <!-- Summary text of the Wi-fi settings screen -->
     <string name="wifi_settings_summary">Set up &amp; manage wireless access points</string>
     <!-- Summary text when turning Wi-Fi or bluetooth on -->
-    <string name="wifi_starting">Turning Wi-Fi on\u2026</string>
+    <string name="wifi_starting">Turning WiFi on\u2026</string>
     <!-- Summary text when turning Wi-Fi or bluetooth off -->
-    <string name="wifi_stopping">Turning off Wi-Fi\u2026</string>
+    <string name="wifi_stopping">Turning off WiFi\u2026</string>
     <!-- Summary text when Wi-Fi or bluetooth has error -->
     <string name="wifi_error">Error</string>
     <!-- Toast message when Wi-Fi or bluetooth is disallowed in airplane mode -->
-    <string name="wifi_in_airplane_mode">In airplane mode</string>
+    <string name="wifi_in_airplane_mode">In Airplane mode</string>
     <!-- Toast message when Wi-Fi cannot scan for networks -->
-    <string name="wifi_fail_to_scan">Unable to scan for networks</string>
+    <string name="wifi_fail_to_scan">Can\'t scan for networks</string>
     <!-- Checkbox title for option to notify user when open networks are nearby -->
     <string name="wifi_notify_open_networks">Network notification</string>
     <!-- Checkbox summary for option to notify user when open networks are nearby -->
@@ -1176,15 +1176,15 @@
     <!-- Checkbox title for option to toggle wifi watchdog service -->
     <string name="wifi_enable_watchdog_service">Avoid poor connections</string>
     <!-- Checkbox summary for option to toggle wifi watchdog service -->
-    <string name="wifi_enable_watchdog_service_summary">Don\'t use a Wi-Fi network unless it has a decent internet connection</string>
+    <string name="wifi_enable_watchdog_service_summary">Don\'t use a WiFi network unless it has a good Internet connection</string>
     <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? -->
-    <string name="wifi_setting_sleep_policy_title">Keep Wi-Fi during sleep</string>
+    <string name="wifi_setting_sleep_policy_title">Keep WiFi on during sleep</string>
     <!-- Generic error message when the sleep policy could not be set. -->
     <string name="wifi_setting_sleep_policy_error">There was a problem changing the setting</string>
     <!-- Action bar text message to manually add a wifi network [CHAR LIMIT=20]-->
     <string name="wifi_add_network">Add network</string>
     <!-- Header for the list of wifi networks-->
-    <string name="wifi_access_points">Wi-Fi networks</string>
+    <string name="wifi_access_points">WiFi networks</string>
     <!-- Menu option to scan Wi-Fi networks -->
     <string name="wifi_menu_scan">Scan</string>
     <!-- Menu option to Wi-Fi advanced settings -->
@@ -1196,7 +1196,7 @@
     <!-- Menu option to modify a Wi-Fi network configuration -->
     <string name="wifi_menu_modify">Modify network</string>
     <!-- Wi-Fi settings. text displayed when WiFi is off and network list is empty [CHAR LIMIT=50]-->
-    <string name="wifi_empty_list_wifi_off">To see available networks, turn Wi-Fi on.</string>
+    <string name="wifi_empty_list_wifi_off">To see available networks, turn WiFi on.</string>
 
     <!-- Dialog for Access Points --> <skip />
     <!-- Label to show/hide advanced options -->
@@ -1204,11 +1204,11 @@
     <!-- Label for network setup [CHAR LIMIT=50] -->
     <string name="wifi_network_setup">WPS</string>
     <!-- Label for the text view for WPS pin input [CHAR LIMIT=50] -->
-    <string name="wifi_wps_pin">Enter pin from access point</string>
+    <string name="wifi_wps_pin">Type PIN from access point</string>
     <!-- Title for the WPS setup dialog [CHAR LIMIT=50] -->
-    <string name="wifi_wps_setup_title">WPS Setup</string>
+    <string name="wifi_wps_setup_title">WPS setup</string>
     <!-- Text displayed in the WPS pin display dialog [CHAR LIMIT=75] -->
-    <string name="wifi_wps_pin_output">Enter the pin <xliff:g id="wps_pin">%1$s</xliff:g> on the access point</string>
+    <string name="wifi_wps_pin_output">Type the PIN <xliff:g id="wps_pin">%1$s</xliff:g> on the access point</string>
     <!-- Text displayed when WPS setup is in progress [CHAR LIMIT=75] -->
     <string name="wifi_wps_in_progress">WPS is already in progress and can take tens of seconds to complete</string>
     <!-- Text displayed when WPS fails to start [CHAR LIMIT=75] -->
@@ -1254,11 +1254,11 @@
     <!-- Status for networks disabled for unknown reason -->
     <string name="wifi_disabled_generic">Disabled</string>
     <!-- Status for networked disabled from a DNS or DHCP failure -->
-    <string name="wifi_disabled_network_failure">Avoided poor internet connection</string>
+    <string name="wifi_disabled_network_failure">Avoided poor Internet connection</string>
     <!-- Heading in the Wi-Fi dialog box when we display a reason for disabling a connection -->
-    <string name="wifi_disabled_heading">Details</string>
+    <string name="wifi_disabled_heading"></string>
     <!-- Detailed message in Wi-Fi dialog when we disable Wi-Fi due to DNS failure. -->
-    <string name="wifi_disabled_help">Network avoided due to poor connection. You can turn off this behavior of avoiding a network with poor connection in advanced menu of Wi-Fi settings.</string>
+    <string name="wifi_disabled_help">The network was avoided due to poor connection. Turn off this behavior from the Settings &gt; WiFi screen, Advanced menu item.</string>
     <!-- Status for networks disabled from authentication failure (wrong password
          or certificate). -->
     <string name="wifi_disabled_password_failure">Authentication problem</string>
@@ -1266,10 +1266,10 @@
     <string name="wifi_not_in_range">Not in range</string>
     <!-- Substring of status line when Wi-Fi Protected Setup (WPS) is available and
          string is listed first -->
-    <string name="wifi_wps_available_first_item">WPS available</string>
+    <string name="wifi_wps_available_first_item">Protected network available</string>
     <!-- Substring of wifi status when Wi-Fi Protected Setup (WPS) is available and
          string is listed after a wifi_secured_* string-->
-    <string name="wifi_wps_available_second_item">\u0020(WPS available)</string>
+    <string name="wifi_wps_available_second_item">\u0020(protected network available)</string>
     <!-- Substring of wifi status for wifi with authentication.  This version is for when the
          string is first in the list (titlecase in english) -->
     <string name="wifi_secured_first_item">Secured with <xliff:g id="wifi_security_short">%1$s</xliff:g></string>
@@ -1318,13 +1318,13 @@
 
     <!-- Errors reported on wifi settings page -->
     <!-- Toast message indicating WPS overlap detection [CHAR LIMIT=75] -->
-    <string name="wifi_wps_overlap_error">Another WPS session detected, please retry in a few minutes</string>
+    <string name="wifi_wps_overlap_error">Another WiFi protected session was detected. Try again in a few minutes.</string>
 
     <!-- Wi-Fi Advanced Settings --> <skip />
     <!-- Wi-Fi settings screen, advanced, settings section.  This is a header shown above advanced wifi settings. -->
-    <string name="wifi_advanced_titlebar">Advanced Wi-Fi</string>
+    <string name="wifi_advanced_titlebar">Advanced WiFi</string>
     <!-- Wi-Fi settings screen, setting title for setting the band [CHAR LIMIT=50]-->
-    <string name="wifi_setting_frequency_band_title">Wi-Fi frequency band</string>
+    <string name="wifi_setting_frequency_band_title">WiFi frequency band</string>
     <!-- Wi-Fi settings screen, setting summary for setting the wifi frequency band [CHAR LIMIT=50]-->
     <string name="wifi_setting_frequency_band_summary">Specify the frequency range of operation</string>
     <!-- Wi-Fi settings screen, error message when the frequency band could not be set [CHAR LIMIT=50]. -->
@@ -1342,13 +1342,13 @@
     <!-- Menu ietm to cancel the IP settings -->
     <string name="wifi_ip_settings_menu_cancel">Cancel</string>
     <!-- Error message if the IP address is not valid [CHAR LIMIT=50]-->
-    <string name="wifi_ip_settings_invalid_ip_address">Please type a valid IP address.</string>
+    <string name="wifi_ip_settings_invalid_ip_address">Type a valid IP address.</string>
     <!-- Error message if the gateway is not valid [CHAR LIMIT=50]-->
-    <string name="wifi_ip_settings_invalid_gateway">Please type a valid gateway address.</string>
+    <string name="wifi_ip_settings_invalid_gateway">Type a valid gateway address.</string>
     <!-- Error message if the dns is not valid [CHAR LIMIT=50]-->
-    <string name="wifi_ip_settings_invalid_dns">Please type a valid dns address.</string>
+    <string name="wifi_ip_settings_invalid_dns">Type a valid DNS address.</string>
     <!-- Error message if the network prefix length is not valid [CHAR LIMIT=50]-->
-    <string name="wifi_ip_settings_invalid_network_prefix_length">Please type a network prefix length between 0 and 32.</string>
+    <string name="wifi_ip_settings_invalid_network_prefix_length">Type a network prefix length between 0 and 32.</string>
     <!-- Label for the DNS (first one) -->
     <string name="wifi_dns1">DNS 1</string>
     <!-- Hint text for DNS -->
@@ -1369,12 +1369,12 @@
 
     <!-- Wi-Fi p2p / Wi-Fi Direct settings -->
     <!-- Used in the 1st-level settings screen to launch Wi-fi Direct settings [CHAR LIMIT=25] -->
-    <string name="wifi_p2p_settings_title">Wi-Fi Direct</string>
+    <string name="wifi_p2p_settings_title">WiFi direct</string>
     <!-- Summary for Wi-fi Direct settings item in the 1st-level settings screen [CHAR LIMIT=50]-->
-    <string name="wifi_p2p_settings_summary">Setup peer-to-peer connectivity</string>
-    <string name="wifi_p2p_device_info">Device Information</string>
-    <string name="wifi_p2p_wps_setup">Wi-Fi Protected Setup</string>
-    <string name="wifi_p2p_wps_pin">Enter pin</string>
+    <string name="wifi_p2p_settings_summary">Set up peer-to-peer connectivity</string>
+    <string name="wifi_p2p_device_info">Device information</string>
+    <string name="wifi_p2p_wps_setup">WiFi protected setup</string>
+    <string name="wifi_p2p_wps_pin">Type PIN</string>
     <string name="wifi_p2p_persist_network">Remember this connection</string>
     <!-- Menu option to discover peers-->
     <string name="wifi_p2p_menu_search">Search</string>
@@ -1385,25 +1385,25 @@
     <!-- Menu option to Wi-Fi p2p advanced settings -->
     <string name="wifi_p2p_menu_advanced">Advanced</string>
     <!-- Title for available p2p devices -->
-    <string name="wifi_p2p_available_devices">Available Devices</string>
+    <string name="wifi_p2p_available_devices">Available devices</string>
 
     <!-- Wifi AP settings-->
     <!-- Label for wifi tether checkbox. Toggles Access Point on/off -->
-    <string name="wifi_tether_checkbox_text">Portable Wi-Fi hotspot</string>
+    <string name="wifi_tether_checkbox_text">Portable WiFi hotspot</string>
     <!-- Subtext for wifi tether checkbox on success -->
     <string name="wifi_tether_enabled_subtext">Portable hotspot <xliff:g id="network_ssid">%1$s</xliff:g> active</string>
     <!-- Subtext for wifi tether checkbox on failure -->
-    <string name="wifi_tether_failed_subtext">Portable Wi-Fi hotspot error</string>
+    <string name="wifi_tether_failed_subtext">Portable WiFi hotspot error</string>
     <!-- Used to open the ssid and security dialog for Wifi Access Point -->
-    <string name="wifi_tether_configure_ap_text">Configure Wi-Fi hotspot</string>
+    <string name="wifi_tether_configure_ap_text">Configure WiFi hotspot</string>
     <!-- Subtext on configuration preference to indicate SSID and security chosen -->
-    <string name="wifi_tether_configure_subtext"><xliff:g id="network_ssid">%1$s</xliff:g> <xliff:g id="network_security">%2$s</xliff:g> portable Wi-Fi hotspot</string>
+    <string name="wifi_tether_configure_subtext"><xliff:g id="network_ssid">%1$s</xliff:g> <xliff:g id="network_security">%2$s</xliff:g> portable WiFi hotspot</string>
     <!-- Default access point SSID used for tethering -->
     <string name="wifi_tether_configure_ssid_default">AndroidHotspot</string>
 
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Wi-Fi Testing on the diagnostic screen-->
-    <string name="testing_wifi_info" translatable="false">Wifi information</string>
+    <string name="testing_wifi_info" translatable="false">WiFi information</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Menu item for WifiManager disableNetwork API-->
     <string name="disableNetwork" translatable="false">disableNetwork</string>
@@ -1421,49 +1421,49 @@
     <string name="getConnectionInfo" translatable="false">getConnectionInfo</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Menu item on Wifi information screen-->
-    <string name="wifi_api_test" translatable="false">Wi-Fi API</string>
+    <string name="wifi_api_test" translatable="false">WiFi API</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Menu item on Wifi information screen-->
-    <string name="wifi_status_test" translatable="false">Wi-Fi Status</string>
+    <string name="wifi_status_test" translatable="false">WiFi status</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Button text on Wifi Status screen-->
-    <string name="wifi_update" translatable="false">Refresh Stats</string>
+    <string name="wifi_update" translatable="false">Refresh stats</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="wifi_state_label" translatable="false">Wi-Fi State :</string>
+    <string name="wifi_state_label" translatable="false">WiFi state:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="network_state_label" translatable="false">Network State :</string>
+    <string name="network_state_label" translatable="false">Network state:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
-    <string name="supplicant_state_label" translatable="false">Supplicant State :</string>
+    <string name="supplicant_state_label" translatable="false">Supplicant state:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="rssi_label" translatable="false">RSSI :</string>
+    <string name="rssi_label" translatable="false">RSSI:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="bssid_label" translatable="false">BSSID :</string>
+    <string name="bssid_label" translatable="false">BSSID:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="ssid_label" translatable="false">SSID :</string>
+    <string name="ssid_label" translatable="false">SSID:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="hidden_ssid_label" translatable="false">Hidden SSID :</string>
+    <string name="hidden_ssid_label" translatable="false">Hidden SSID:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="ipaddr_label" translatable="false">IPaddr :</string>
+    <string name="ipaddr_label" translatable="false">IPaddr:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="macaddr_label" translatable="false">MAC addr :</string>
+    <string name="macaddr_label" translatable="false">MAC addr:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="networkid_label" translatable="false">Network ID :</string>
+    <string name="networkid_label" translatable="false">Network ID:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="link_speed_label" translatable="false">Link Speed :</string>
+    <string name="link_speed_label" translatable="false">Link speed:</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Status screen-->
-    <string name="scan_list_label" translatable="false">Scan results :</string>
+    <string name="scan_list_label" translatable="false">Scan results:</string>
 
     <!-- wifi state values-->
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
@@ -1479,10 +1479,10 @@
 
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Menu item on Wifi information screen-->
-    <string name="wifi_config_info" translatable="false">Wi-Fi Config</string>
+    <string name="wifi_config_info" translatable="false">WiFi config</string>
     <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
          Label on Wifi Configuration screen-->
-    <string name="config_list_label" translatable="false">Configured Networks</string>
+    <string name="config_list_label" translatable="false">Configured networks</string>
 
     <!-- Sound and alerts settings -->
     <skip/>
@@ -1499,7 +1499,7 @@
     <!-- Sound settings screen, volume title -->
     <string name="all_volume_title">Volumes</string>
     <!-- Sound settings screen, music effects title [CHAR LIMIT=30]-->
-    <string name="musicfx_title">Music Effects</string>
+    <string name="musicfx_title">Music effects</string>
     <!-- Sound settings screen, setting option name -->
     <string name="ring_volume_title">Ringer volume</string>
     <!-- Sound settings screen, setting option name checkbox -->
@@ -1518,7 +1518,7 @@
          the same as the incoming call volume. -->
     <string name="checkbox_notification_same_as_incoming_call">Use incoming call volume for notifications</string>
     <!-- Sound settings screen, setting option title-->
-    <string name="notification_sound_dialog_title">Select notification ringtone</string>
+    <string name="notification_sound_dialog_title">Choose notification ringtone</string>
     <!-- Sound settings screen, setting option name -->
     <string name="media_volume_title">Media</string>
     <!-- Sound settings screen, setting option summary text -->
@@ -1538,7 +1538,7 @@
     <!-- Sound settings screen, setting option name checkbox to enable/disable audio recording features that improve audio recording in noisy environments -->
     <string name="audio_record_proc_title">Noise cancellation</string>
     <!-- Volume description for media volume -->
-    <string name="volume_media_description">Music, video, games &amp; other media</string>
+    <string name="volume_media_description">Music, video, games, &amp; other media</string>
     <!-- Volume description for ringtone and notification volume -->
     <string name="volume_ring_description">Ringtone &amp; notifications</string>
     <!-- Volume description for notification volume -->
@@ -1565,11 +1565,11 @@
     <!-- Dock not found dialog title -->
     <string name="dock_not_found_title">Dock not found</string>
     <!-- Dock not found dialog text -->
-    <string name="dock_not_found_text" product="tablet">The tablet must be docked to configure dock audio</string>
+    <string name="dock_not_found_text" product="tablet">You must dock the tablet before setting up dock audio.</string>
     <!-- Dock not found dialog text -->
-    <string name="dock_not_found_text" product="default">The phone must be docked to configure dock audio</string>
+    <string name="dock_not_found_text" product="default">You must dock the phone before setting up dock audio.</string>
     <!-- Dock settings screen, dock events SFX setting check box label -->
-    <string name="dock_sounds_enable_title">Dock insertion sound</string>
+    <string name="dock_sounds_enable_title">Dock insert sound</string>
     <!-- Dock settings screen, setting option summary text when check box is selected -->
     <string name="dock_sounds_enable_summary_on" product="tablet">Play sound when inserting or removing tablet from dock</string>
     <!-- Dock settings screen, setting option summary text when check box is selected -->
@@ -1611,7 +1611,7 @@
     <!-- Wallpaper settings title [CHAR LIMIT=30] -->
     <string name="wallpaper_settings_title">Wallpaper</string>
     <!-- Wallpaper settings fragment title [CHAR LIMIT=30] -->
-    <string name="wallpaper_settings_fragment_title">Select wallpaper from</string>
+    <string name="wallpaper_settings_fragment_title">Choose wallpaper from</string>
     <!-- Display settings screen, trigger for screen saver options -->
     <string name="dream_settings_title">Android Dreams</string>
     <!-- Display settings screen, summary for screen saver options -->
@@ -1667,15 +1667,15 @@
     <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
     <string name="sim_change_pin">SIM PIN</string>
     <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered -->
-    <string name="sim_bad_pin">Incorrect PIN!</string>
+    <string name="sim_bad_pin">Incorrect PIN</string>
     <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match -->
-    <string name="sim_pins_dont_match">PINs don\'t match!</string>
+    <string name="sim_pins_dont_match">PINs don\'t match</string>
     <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
-    <string name="sim_change_failed">Unable to change PIN.\nPossibly incorrect PIN.</string>
+    <string name="sim_change_failed">Can\'t change PIN.\nPossibly incorrect PIN.</string>
     <!-- SIM card lock settings screen, SIM PIN dialog message when the entered PIN is correct-->
     <string name="sim_change_succeeded">SIM PIN changed successfully</string>
     <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
-    <string name="sim_lock_failed">Unable to change SIM card lock state.\nPossibly incorrect PIN.</string>
+    <string name="sim_lock_failed">Can\'t change SIM card lock state.\nPossibly incorrect PIN.</string>
     <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
     <string name="sim_enter_ok">OK</string>
     <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
@@ -1751,7 +1751,7 @@
     <!-- About phone, status item title. The cell carrier that the user is connected to.  -->
     <string name="status_operator">Network</string>
     <!-- About phone, status item title.  The MAC address of the Wi-Fi network adapter. -->
-    <string name="status_wifi_mac_address">Wi-Fi MAC address</string>
+    <string name="status_wifi_mac_address">WiFi MAC address</string>
     <!-- About phone, status item title.  The bluetooth adapter's hardware address-->
     <string name="status_bt_address">Bluetooth address</string>
     <!-- About phone, status item title.  The hardware serial number. [CHAR LIMIT=30]-->
@@ -1775,15 +1775,15 @@
     <!-- SD card & phone storage settings summary. Displayed when the total memory usage is being calculated. Will be replaced with a number like "12.3 GB" when finished calucating. [CHAR LIMIT=30] -->
     <string name="memory_calculating_size">Calculating…</string>
     <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of applications installed. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
-    <string name="memory_apps_usage">Applications</string>
+    <string name="memory_apps_usage">Apps</string>
     <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of media on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
     <string name="memory_media_usage">Media</string>
     <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of /sdcard/Download on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
     <string name="memory_downloads_usage">Downloads</string>
     <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of all pictures, videos in /sdcard/DCIM, /sdcard/Pictures folders on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
-    <string name="memory_dcim_usage">Pictures, Videos</string>
+    <string name="memory_dcim_usage">Pictures, videos</string>
     <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of audio files in /sdcard on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
-    <string name="memory_music_usage">Audio (music, ringtones, podcasts etc)</string>
+    <string name="memory_music_usage">Audio (music, ringtones, podcasts, etc.)</string>
     <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of misc files on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
     <string name="memory_media_misc_usage">Misc.</string>
     <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   [CHAR LIMIT=25] -->
@@ -1821,21 +1821,21 @@
     <!-- SD card status when it is mounted as read only. Will be appended to size, starts with an unbreakable space -->
     <string name="read_only">\u0020(Read-only)</string>
     <!-- SD card eject confirmation dialog title   [CHAR LIMIT=25] -->
-    <string name="dlg_confirm_unmount_title" product="nosdcard">Unmount USB storage</string>
+    <string name="dlg_confirm_unmount_title" product="nosdcard">Unmount USB storage?</string>
     <!-- SD card eject confirmation dialog title   -->
-    <string name="dlg_confirm_unmount_title" product="default">Unmount SD card</string>
+    <string name="dlg_confirm_unmount_title" product="default">Unmount SD card?</string>
     <!-- SD card eject confirmation dialog  [CHAR LIMIT=NONE] -->
-    <string name="dlg_confirm_unmount_text" product="nosdcard">If you unmount the USB storage, some applications you are using will stop and may be unavailable until you remount the USB storage.</string>
+    <string name="dlg_confirm_unmount_text" product="nosdcard">If you unmount the USB storage, some apps you are using will stop and may be unavailable until you remount the USB storage.</string>
     <!-- SD card eject confirmation dialog  -->
-    <string name="dlg_confirm_unmount_text" product="default">If you unmount the SD card, some applications you are using will stop and may be unavailable until you remount the SD card.</string>
+    <string name="dlg_confirm_unmount_text" product="default">If you unmount the SD card, some apps you are using will stop and may be unavailable until you remount the SD card.</string>
     <!-- SD card eject error dialog title   [CHAR LIMIT=30] -->
-    <string name="dlg_error_unmount_title" product="nosdcard">Couldn\'t unmount USB storage</string>
+    <string name="dlg_error_unmount_title" product="nosdcard"></string>
     <!-- SD card eject error dialog title   -->
-    <string name="dlg_error_unmount_title" product="default">Couldn\'t unmount SD card</string>
+    <string name="dlg_error_unmount_title" product="default"></string>
     <!-- SD card eject error dialog text   [CHAR LIMIT=NONE] -->
-    <string name="dlg_error_unmount_text" product="nosdcard">Cannot unmount USB storage. Try again later.</string>
+    <string name="dlg_error_unmount_text" product="nosdcard">Couldn\'t unmount USB storage. Try again later.</string>
     <!-- SD card eject error dialog text   -->
-    <string name="dlg_error_unmount_text" product="default">Cannot unmount SD card. Try again later.</string>
+    <string name="dlg_error_unmount_text" product="default">Couldn\'t unmount SD card. Try again later.</string>
     <!-- SD card unmount informative text   [CHAR LIMIT=NONE] -->
     <string name="unmount_inform_text" product="nosdcard">USB storage will be unmounted.</string>
     <!-- SD card unmount informative text   [CHAR LIMIT=NONE] -->
@@ -1873,7 +1873,7 @@
     <!-- Screen title after user selects APNs setting option -->
     <string name="apn_edit">Edit access point</string>
     <!-- Edit access point label summary text when no value has been set -->
-    <string name="apn_not_set">&lt;Not set&gt;</string>
+    <string name="apn_not_set">Not set</string>
     <!-- Edit access point labels: A label the user can give to the APN to allow him to differentiate it from the others -->
     <string name="apn_name">Name</string>
     <!-- Edit access point labels: The actual access point name-->
@@ -1913,9 +1913,9 @@
     <!-- Edit access point labels: The protocol of the APN, e.g., "IPv4", "IPv6", or "IPv4/IPv6". -->
     <string name="apn_protocol">APN protocol</string>
     <!-- Edit enable/disable of APN -->
-    <string name="carrier_enabled">APN Enable/Disable</string>
-    <string name="carrier_enabled_summaryOn">APN Enabled</string>
-    <string name="carrier_enabled_summaryOff">APN Disabled</string>
+    <string name="carrier_enabled">APN enable/disable</string>
+    <string name="carrier_enabled_summaryOn">APN enabled</string>
+    <string name="carrier_enabled_summaryOff">APN disabled</string>
     <!-- Edit Beaerer Info of APN -->
     <string name="bearer">Bearer</string>
     <!-- Edit access point screen menu option to delete this APN -->
@@ -1927,21 +1927,21 @@
     <!-- Edit access point screen menu option to discard the user's changes for this APN -->
     <string name="menu_cancel">Discard</string>
     <!-- APN error dialog title -->
-    <string name="error_title">Attention</string>
+    <string name="error_title"></string>
     <!-- APN error dialog messages: -->
-    <string name="error_name_empty">The Name field cannot be empty.</string>
+    <string name="error_name_empty">The Name field can\'t be empty.</string>
     <!-- APN error dialog messages: -->
-    <string name="error_apn_empty">The APN cannot be empty.</string>
+    <string name="error_apn_empty">The APN can\'t be empty.</string>
     <!-- APN error dialog messages: -->
     <string name="error_mcc_not3">MCC field must be 3 digits.</string>
     <!-- APN error dialog messages: -->
     <string name="error_mnc_not23">MNC field must be 2 or 3 digits.</string>
     <!-- The message of dialog indicated restoring default APN settings in progress -->
-    <string name="restore_default_apn">Restoring default APN settings</string>
+    <string name="restore_default_apn">Restoring default APN settings.</string>
     <!-- APNs screen menu option to reset default APN settings -->
     <string name="menu_restore">Reset to default</string>
     <!-- APNs screen toast message to inform reset default APN settings is completed -->
-    <string name="restore_default_apn_completed">Reset default APN settings completed</string>
+    <string name="restore_default_apn_completed">Reset default APN settings completed.</string>
 
     <!-- Master Clear -->
     <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading -->
@@ -1951,31 +1951,31 @@
     <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
     <string name="master_clear_summary" product="default">Erases all data on phone</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
-    <string name="master_clear_desc" product="tablet">"This will erase all data from your tablet\'s <b>internal storage</b>, including:\n\n<li>Your Google Account</li>\n<li>System and application data and settings</li>\n<li>Downloaded applications</li>"</string>
+    <string name="master_clear_desc" product="tablet">"This will erase all data from your tablet\'s <b>internal storage</b>, including:\n\n<li>Your Google account</li>\n<li>System and app data and settings</li>\n<li>Downloaded apps</li>"</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
-    <string name="master_clear_desc" product="default">"This will erase all data from your phone\'s <b>internal storage</b>, including:\n\n<li>Your Google Account</li>\n<li>System and application data and settings</li>\n<li>Downloaded applications"</li></string>
+    <string name="master_clear_desc" product="default">"This will erase all data from your phone\'s <b>internal storage</b>, including:\n\n<li>Your Google account</li>\n<li>System and app data and settings</li>\n<li>Downloaded apps"</li></string>
     <!-- SD card & phone storage settings screen, instructions and list of current accounts.  The list of accounts follows this text[CHAR LIMIT=NONE] -->
     <string name="master_clear_accounts" product="default">"\n\nYou are currently signed into the following accounts:\n"</string>
     <!-- SD card & phone storage settings screen, list of items in user data storage (USB storage or SD card) that will be erased during this operation [CHAR LIMIT=NONE] -->
     <string name="master_clear_desc_also_erases_external">"<li>Music</li>\n<li>Photos</li>\n<li>Other user data</li>"</string>
     <!-- SD card & phone storage settings screen, instructions about whether to also erase the external storage (SD card) when erasing the internal storage [CHAR LIMIT=NONE] -->
-    <string name="master_clear_desc_erase_external_storage" product="nosdcard">"\n\nTo also clear music, pictures, and other user data, the <b>USB storage</b> needs to be erased."</string>
+    <string name="master_clear_desc_erase_external_storage" product="nosdcard">"\n\nTo clear music, pictures, and other user data, the <b>USB storage</b> needs to be erased."</string>
     <!-- SD card & phone storage settings screen, instructions about whether to also erase the external storage (SD card) when erasing the internal storage [CHAR LIMIT=NONE] -->
-    <string name="master_clear_desc_erase_external_storage" product="default">"\n\nTo also clear music, pictures, and other user data, the <b>SD card</b> needs to be erased."</string>
+    <string name="master_clear_desc_erase_external_storage" product="default">"\n\nTo clear music, pictures, and other user data, the <b>SD card</b> needs to be erased."</string>
     <!-- SD card & phone storage settings screen, label for check box to erase USB storage [CHAR LIMIT=30] -->
     <string name="erase_external_storage" product="nosdcard">Erase USB storage</string>
     <!-- SD card & phone storage settings screen, label for check box to erase SD card [CHAR LIMIT=30] -->
     <string name="erase_external_storage" product="default">Erase SD card</string>
     <!-- SD card & phone storage settings screen, description for check box to erase USB storage [CHAR LIMIT=NONE] -->
-    <string name="erase_external_storage_description" product="nosdcard">Erase all the data on the internal USB storage, such as music or photos.</string>
+    <string name="erase_external_storage_description" product="nosdcard">Erase all the data on the internal USB storage, such as music or photos</string>
     <!-- SD card & phone storage settings screen, description for check box to erase USB storage [CHAR LIMIT=NONE] -->
-    <string name="erase_external_storage_description" product="default">Erase all the data on the SD card, such as music or photos.</string>
+    <string name="erase_external_storage_description" product="default">Erase all the data on the SD card, such as music or photos</string>
     <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
     <string name="master_clear_button_text" product="tablet">Reset tablet</string>
     <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
     <string name="master_clear_button_text" product="default">Reset phone</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button -->
-    <string name="master_clear_final_desc">Erase all of your personal information and any downloaded applications? It is impossible to reverse this action!</string>
+    <string name="master_clear_final_desc">Erase all your personal information and downloaded apps? You can\'t reverse this action!</string>
     <!-- SD card & phone storage settings screen, button on screen after user selects Reset phone button -->
     <string name="master_clear_final_button_text">Erase everything</string>
     <!-- Message to draw an unlock pattern before clearing the device -->
@@ -1983,9 +1983,9 @@
     <!-- Explanation of drawing unlockp attern to reset phone -->
     <string name="master_clear_gesture_explanation">You must draw your unlock pattern to confirm a factory data reset.</string>
     <!-- Master clear failed message -->
-    <string name="master_clear_failed">No reset was performed because the System Clear service is not available.</string>
+    <string name="master_clear_failed">No reset was performed because the System Clear service isn\'t available.</string>
     <!-- Master clear confirmation screen title [CHAR LIMIT=30] -->
-    <string name="master_clear_confirm_title">Confirm reset</string>
+    <string name="master_clear_confirm_title">Reset?</string>
 
     <!-- Media Format -->
     <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading [CHAR LIMIT=25] -->
@@ -1997,17 +1997,17 @@
     <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
     <string name="media_format_summary" product="default">Erases all data on the SD card</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
-    <string name="media_format_desc" product="nosdcard">This action will erase the USB storage. You will lose <b>all</b> data stored there!</string>
+    <string name="media_format_desc" product="nosdcard">Erase all USB storage? You will lose <b>all</b> stored data!</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
-    <string name="media_format_desc" product="default">This action will erase the SD card. You will lose <b>all</b> data on the card!</string>
+    <string name="media_format_desc" product="default">Erase the SD card? You will lose <b>all</b> data on the card!</string>
     <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset [CHAR LIMIT=25] -->
     <string name="media_format_button_text" product="nosdcard">Erase USB storage</string>
     <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
     <string name="media_format_button_text" product="default">Erase SD card</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Format media button [CHAR LIMIT=NONE] -->
-    <string name="media_format_final_desc" product="nosdcard">Erase USB storage, deleting all files stored there? Action cannot be reversed!</string>
+    <string name="media_format_final_desc" product="nosdcard">Erase the USB storage, deleting all files stored there? You can\'t reverse this action!</string>
     <!-- SD card & phone storage settings screen, message on screen after user selects Format media button [CHAR LIMIT=NONE] -->
-    <string name="media_format_final_desc" product="default">Erase SD card, deleting all files stored there? Action cannot be reversed!</string>
+    <string name="media_format_final_desc" product="default">Erase the SD card, deleting all files stored there? You can\'t reverse this action!</string>
     <!-- SD card & phone storage settings screen, button on screen after user selects Format media button -->
     <string name="media_format_final_button_text">Erase everything</string>
     <!-- Message to draw an unlock pattern before clearing the device -->
@@ -2042,7 +2042,7 @@
     <!-- USB tethered subtext - shown when USB is connected and being tethered -->
     <string name="usb_tethering_active_subtext">Tethered</string>
     <!-- USB storage subtext - shown when tethering is disabled because USB storage is active -->
-    <string name="usb_tethering_storage_active_subtext">Can\'t tether when USB storage in use</string>
+    <string name="usb_tethering_storage_active_subtext">Can\'t tether when USB storage is in use</string>
     <!-- USB unavailable subtext - shown when USB is not connected -->
     <string name="usb_tethering_unavailable_subtext">USB not connected</string>
     <!-- USB errored subtext - shown when USB is broken for some reason -->
@@ -2068,9 +2068,9 @@
     <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=50]-->
     <string name="bluetooth_tethering_off_subtext" product="default">Not sharing this phone\'s Internet connection</string>
     <!-- Bluetooth errored subtext - shown when Bluetooth is broken for some reason [CHAR LIMIT=50]-->
-    <string name="bluetooth_tethering_errored_subtext">Bluetooth tethering error</string>
+    <string name="bluetooth_tethering_errored_subtext">Not tethered</string>
     <!-- Bluetooth Tethering settings. Error message shown when trying to connect an 8th device [CHAR LIMIT=50]-->
-    <string name="bluetooth_tethering_overflow_error">Cannot tether to more than <xliff:g id="maxConnection">%1$d</xliff:g> devices</string>
+    <string name="bluetooth_tethering_overflow_error">Can\'t tether to more than <xliff:g id="maxConnection">%1$d</xliff:g> devices.</string>
     <!-- Bluetooth Tethering settings.  Message for untethering from a bluetooth device [CHAR LIMIT=50]-->
     <string name="bluetooth_untether_blank"><xliff:g id="device_name">%1$s</xliff:g> will be untethered.</string>
 
@@ -2085,9 +2085,9 @@
     <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for Google location service (cell ID, wifi, etc.) -->
     <string name="location_network_based">Google\'s location service</string>
     <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary for Google location service check box-->
-    <string name="location_neighborhood_level">Let apps use data from sources such as Wi-Fi and mobile networks to determine your approximate location</string>
+    <string name="location_neighborhood_level">Let apps use data from sources such as WiFi and mobile networks to determine your approximate location</string>
     <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary when Use wireless networks check box is selected, for wifi-only devices -->
-    <string name="location_neighborhood_level_wifi">Location determined by Wi-Fi</string>
+    <string name="location_neighborhood_level_wifi">Location determined by WiFi</string>
     <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for GPS satellites -->
     <string name="location_gps">GPS satellites</string>
     <!-- [CHAR LIMIT=100] Security & location settings screen, setting check box summary for GPS satellites -->
@@ -2143,7 +2143,7 @@
     <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
     <string name="settings_safetylegal_activity_title">Safety information</string>
     <!-- About phone settings screen, Safety legal dialog message when data network is not connected -->
-    <string name="settings_safetylegal_activity_unreachable">You do not have a data connection. To view this information now, go to %s from any computer connected to the Internet.</string>
+    <string name="settings_safetylegal_activity_unreachable">You don\'t have a data connection. To view this information now, go to %s from any computer connected to the Internet.</string>
     <!-- About phone settings screen, Safety Legal dialog title until the link is fully loaded -->
     <string name="settings_safetylegal_activity_loading">Loading\u2026</string>
 
@@ -2185,7 +2185,7 @@
     <!-- Do not translate. -->
     <string name="lockpattern_need_to_unlock_footer" />
     <!-- Security & location settings screen, change unlock pattern screen instruction if user draws incorrect pattern -->
-    <string name="lockpattern_need_to_unlock_wrong">Sorry, try again:</string>
+    <string name="lockpattern_need_to_unlock_wrong">Try again:</string>
     <!-- Do not translate. -->
     <string name="lockpattern_need_to_unlock_wrong_footer" />
     <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen.  This si when they are supposed to draw a new unlock pattern (for example, if they are changing their unlock patterns)..-->
@@ -2240,45 +2240,45 @@
     <!-- ChooseLockPatternTutorial, tutorial screen title -->
     <string name="lock_title" product="default">Securing your phone</string>
     <!-- ChooseLockPatternTutorial, tutorial screen text -->
-    <string name="lock_intro_message" product="tablet">Protect your tablet from unauthorized use by creating a personal screen unlock pattern. Use your finger to connect the dots in any order on the next screen.  You must connect at least four dots.
-        \n\nReady to start? Touch \u201CNext\u201D.
+    <string name="lock_intro_message" product="tablet">Protect your tablet from unauthorized use by creating a personal screen unlock pattern. Slide your finger to connect the dots in any order on the next screen.  You must connect at least four dots.
+        \n\nReady to start? Touch Next.
     </string>
     <!-- ChooseLockPatternTutorial, tutorial screen text -->
-    <string name="lock_intro_message" product="default">Protect your phone from unauthorized use by creating a personal screen unlock pattern. Use your finger to connect at least four dots in any order on the next screen.
-        \n\nReady to start? Touch \u201CNext\u201D.
+    <string name="lock_intro_message" product="default">Protect your phone from unauthorized use by creating a personal screen unlock pattern. Slide your finger to connect at least four dots in any order on the next screen.
+        \n\nReady to start? Touch Next.
     </string>
 
     <!-- Applications Settings --> <skip />
     <!-- Applications settings screen, setting option name for the user to go to the screen to manage installed applications  -->
-    <string name="manageapplications_settings_title">Manage applications</string>
+    <string name="manageapplications_settings_title">Manage apps</string>
     <!-- Applications settings screen, setting option summary for the user to go to the screen to manage installed applications  -->
-    <string name="manageapplications_settings_summary">Manage and remove installed applications</string>
+    <string name="manageapplications_settings_summary">Manage and remove installed apps</string>
     <!-- Applications settings title, on main settings screen. If clicked, the user is taken to a settings screen full of application settings-->
-    <string name="applications_settings">Applications</string>
+    <string name="applications_settings">Apps</string>
     <!-- Applications settings summary, on main settings screen. The summary for the "Applications" item on the main settings screen. Describes what settings are accessible from the "Applications" screen. -->
-    <string name="applications_settings_summary">Manage applications, set up quick launch shortcuts</string>
+    <string name="applications_settings_summary">Manage apps, set up quick launch shortcuts</string>
     <!-- Applications settings screen heading. The header for the Application settings screen. -->
-    <string name="applications_settings_header">Application settings</string>
+    <string name="applications_settings_header">App settings</string>
     <!-- Applications settings screen, setting check box title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  -->
     <string name="install_applications">Unknown sources</string>
     <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  -->
-    <string name="install_unknown_applications">Allow installation of non-Market applications</string>
+    <string name="install_unknown_applications">Allow installation of non-Market apps</string>
     <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
-    <string name="install_all_warning" product="tablet">Your tablet and personal data are more vulnerable to attack by applications
+    <string name="install_all_warning" product="tablet">Your tablet and personal data are more vulnerable to attack by apps
  from unknown sources. You agree that you are solely responsible for any
  damage to your tablet or loss of data that may result from using
- these applications.</string>
+ these apps.</string>
     <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
-    <string name="install_all_warning" product="default">Your phone and personal data are more vulnerable to attack by applications
+    <string name="install_all_warning" product="default">Your phone and personal data are more vulnerable to attack by apps
  from unknown sources. You agree that you are solely responsible for any
  damage to your phone or loss of data that may result from using
- these applications.</string>
+ these apps.</string>
     <!-- Applications settings screen, setting check box title. If checked, applications show more settings options. -->
     <string name="advanced_settings">Advanced settings</string>
     <!-- Applications settings screen, setting check box summary.  This is the summary for "Advanced settings" checkbox  -->
-    <string name="advanced_settings_summary">Enable more settings options.</string>
+    <string name="advanced_settings_summary">Enable more settings options</string>
     <!-- Manage applications, individual application info screen title. For example, if they click on "Browser" in "Manage applications", the title of the next screen will be this -->
-    <string name="application_info_label">Application info</string>
+    <string name="application_info_label">App info</string>
     <!-- Manage applications, individual application info screen, section heading for stuff relating to an app's storage settings. -->
     <string name="storage_label">Storage</string>
     <!-- Manage applications, individual application info screen,  heading for settings related to controlling whether this app is the default for some actions -->
@@ -2300,7 +2300,7 @@
     <!-- Manage applications, individual application info screen,label under Storage heading.  The total storage space taken up by this app. -->
     <string name="total_size_label">Total</string>
     <!-- Manage applications, individual application info screen, label under Storage heading. The amount of space taken up by the application itself (for example, the java compield files and things like that) -->
-    <string name="application_size_label">Application</string>
+    <string name="application_size_label">App</string>
     <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's code on USB storage [CHARSIZE=40] -->
     <string name="external_code_size_label">USB storage app</string>
     <!-- Manage applications, individual application info screen, label under Storage heading.  The amount of sapce taken up by the app's data (for example, downloaded emails or something like that) -->
@@ -2320,18 +2320,18 @@
     <!-- Manage applications, restore updated system application to factory version -->
     <string name="app_factory_reset">Uninstall updates</string>
     <!-- Manage applications, individual application info screen, screen, message text under Launch by default heading. This is present if the app is set as a default for some actions. -->
-    <string name="auto_launch_enable_text">You have selected to launch this application by default for some actions.</string>
+    <string name="auto_launch_enable_text">You\'ve chosen to launch this app by default for some actions.</string>
     <!-- Manage applications, individual application screen, text under Launch by default heading if the app is NOT a default for actions -->
     <string name="auto_launch_disable_text">No defaults set.</string>
     <!-- Manage applications, individual application screen, button label under Launch by default heading.  This is used to clear any default actions that may be assigned to this app.  -->
     <string name="clear_activities">Clear defaults</string>
     <!-- Manage applications, individual application info screen, screen, message text under screen compatibility heading -->
-    <string name="screen_compatibility_text">This application may not be designed for your screen; you can control how it
+    <string name="screen_compatibility_text">This app may not be designed for your screen. You can control how it
             adjusts to your screen here.</string>
     <!-- Manage applications, individual application screen, checkbox to control asking for compatibility mode.  -->
     <string name="ask_compatibility">Ask when launched</string>
     <!-- Manage applications, individual application screen, checkbox to control compatibility mode.  -->
-    <string name="enable_compatibility">Scale application</string>
+    <string name="enable_compatibility">Scale app</string>
     <!-- Manage apps, individual app screen, substituted for the application's label when the app's label CAN NOT be determined.-->
     <string name="unknown">Unknown</string>
     <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Sorts all of the apps in the list alphabetically. -->
@@ -2347,7 +2347,7 @@
     <!-- Text for menu option in ManageApps screen to present various menu options -->
     <string name="filter">Filter</string>
     <!-- Title of dialog for presenting filter options -->
-    <string name="filter_dlg_title">Select filter options</string>
+    <string name="filter_dlg_title">Choose filter options</string>
     <!-- Text for filter option in ManageApps screen to display all installed
     applications -->
     <string name="filter_apps_all">All</string>
@@ -2366,7 +2366,7 @@
     <!-- [CHAR LIMIT=25] Manage applications, text telling using an application is disabled. -->
     <string name="disabled">Disabled</string>
     <!-- [CHAR LIMIT=25] Text shown when there are no applications to display. -->
-    <string name="no_applications">No applications.</string>
+    <string name="no_applications">No apps.</string>
     <!-- [CHAR LIMIT=15] Manage applications, label for chart showing internal storage use. -->
     <string name="internal_storage">Internal storage</string>
     <!-- [CHAR LIMIT=15] Manage applications, label for chart showing SD card storage use. -->
@@ -2376,36 +2376,36 @@
     <!-- Manage app screen, shown when the activity is busy recomputing the size of each app -->
     <string name="recompute_size">Recomputing size\u2026</string>
     <!-- Manage applications, individual application screen, confirmation dialog title. Displays when user selects to "Clear data". -->
-    <string name="clear_data_dlg_title">Delete</string>
+    <string name="clear_data_dlg_title">Delete app data?</string>
     <!-- Manage applications, individual application screen, confirmation dialog message. Displays when user selects to "Clear data". It warns the user of the consequences of clearing the data for an app. -->
-    <string name="clear_data_dlg_text">All of this application\'s data will be deleted permanently. This includes all files, settings, accounts, databases and so on.</string>
+    <string name="clear_data_dlg_text">All this app\'s data will be deleted permanently. This includes all files, settings, accounts, databases, etc.</string>
     <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". Goes through with the clearing of the data. -->
     <string name="dlg_ok">OK</string>
     <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". -->
     <string name="dlg_cancel">Cancel</string>
     <!-- Manage applications, individual application dialog box title. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
-    <string name="app_not_found_dlg_title">Application not found</string>
+    <string name="app_not_found_dlg_title"></string>
     <!-- Manage applications, individual application dialog box message. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
-    <string name="app_not_found_dlg_text"> The application was not
-found in the list of installed applications.</string>
+    <string name="app_not_found_dlg_text"> The app wasn\'t
+found in the list of installed apps.</string>
     <!-- Manage applications, individual application dialog box message. Shown when there was an error trying to clear the data. -->
-    <string name="clear_data_failed">Unable to clear application data.</string>
+    <string name="clear_data_failed">Couldn\'t clear app data.</string>
     <!-- Manage applications, factory reset dialog title for system applications. -->
-    <string name="app_factory_reset_dlg_title">Uninstall updates</string>
+    <string name="app_factory_reset_dlg_title">Uninstall updates?</string>
     <!-- Manage applications, factory reset option dialog text for system applications. -->
-    <string name="app_factory_reset_dlg_text">Do you want to uninstall all updates to this Android system application?</string>
+    <string name="app_factory_reset_dlg_text">All updates to this Android system app will be uninstalled.</string>
     <!-- Manage applications, title for dialog if clear data fails-->
     <string name="clear_failed_dlg_title">Clear data</string>
     <!-- Manage applications, text for dialog if clear data fails-->
-    <string name="clear_failed_dlg_text">Couldn\'t clear data for application.</string>
+    <string name="clear_failed_dlg_text">Couldn\'t clear data for app.</string>
     <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
-    <string name="security_settings_desc" product="tablet">This application can access the following on your tablet:</string>
+    <string name="security_settings_desc" product="tablet">This app can access the following on your tablet:</string>
     <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
-    <string name="security_settings_desc" product="default">This application can access the following on your phone:</string>
+    <string name="security_settings_desc" product="default">This app can access the following on your phone:</string>
     <string name="computing_size">Computing\u2026</string>
     <string name="invalid_size_value">Unable to compute package size</string>
     <!-- String displayed when list is empty -->
-    <string name="empty_list_msg">You do not have any third-party applications installed.</string>
+    <string name="empty_list_msg">You don\'t have any third-party apps installed.</string>
     <!-- Manage applications, version string displayed in app snippet -->
     <string name="version_text">version <xliff:g id="version_num">%1$s</xliff:g></string>
     <!-- Manage applications, text for Move button -->
@@ -2423,33 +2423,33 @@
     <string name="moving">Moving</string>
 
     <!-- Manage applications, text for move error messages -->
-    <string name="insufficient_storage">There is not enough storage left.</string>
-    <string name="does_not_exist">The application does not exist.</string>
-    <string name="app_forward_locked">The application is copy-protected.</string>
-    <string name="invalid_location">The specified install location is not valid.</string>
-    <string name="system_package">System updates cannot be installed on external media.</string>
+    <string name="insufficient_storage">Not enough storage space.</string>
+    <string name="does_not_exist">App doesn\'t exist.</string>
+    <string name="app_forward_locked">App is copy-protected.</string>
+    <string name="invalid_location">Install location isn\'t valid.</string>
+    <string name="system_package">System updates can\'t be installed on external media.</string>
 
-    <string name="force_stop_dlg_title">Force stop</string>
+    <string name="force_stop_dlg_title">Force stop?</string>
     <!-- [CHAR LIMIT=200] Manage applications, text for dialog when killing persistent apps-->
-    <string name="force_stop_dlg_text">Force stopping an application can cause it to misbehave.  Are you sure?</string>
+    <string name="force_stop_dlg_text">If you force stop an app, it may misbehave.</string>
     <!-- Manage applications, text for dialog when moving an app -->
-    <string name="move_app_failed_dlg_title">Move application</string>
+    <string name="move_app_failed_dlg_title"></string>
     <!-- Manage applications, text for dialog moving an app -->
-    <string name="move_app_failed_dlg_text">Couldn\'t move application. <xliff:g id="reason">%1$s</xliff:g></string>
+    <string name="move_app_failed_dlg_text">Couldn\'t move app. <xliff:g id="reason">%1$s</xliff:g></string>
     <!-- Manage applications, application installation location title -->
     <string name="app_install_location_title">Preferred install location</string>
     <!-- Manage applications. application installation location summary -->
-    <string name="app_install_location_summary">Change the preferred installation location for new applications.</string>
+    <string name="app_install_location_summary">Change the preferred installation location for new apps</string>
     <!-- [CHAR LIMIT=30] Manage applications, title for dialog when disabling apps -->
-    <string name="app_disable_dlg_title">Disable built-in app</string>
+    <string name="app_disable_dlg_title">Disable built-in app?</string>
     <!-- [CHAR LIMIT=200] Manage applications, text for dialog when disabling apps -->
-    <string name="app_disable_dlg_text">Disabling a built-in application may cause other applications
-        to misbehave.  Are you sure?</string>
+    <string name="app_disable_dlg_text">If you disable a built-in app, other apps
+        may misbehave.</string>
 
     <!-- [CHAR LIMIT=25] Services settings screen, setting option name for the user to go to the screen to view app storage use -->
     <string name="storageuse_settings_title">Storage use</string>
     <!-- Services settings screen, setting option summary for the user to go to the screen to app storage use -->
-    <string name="storageuse_settings_summary">View storage used by applications</string>
+    <string name="storageuse_settings_summary">View storage used by apps</string>
 
     <!-- Services settings screen, setting option name for the user to go to the screen to view running services -->
     <string name="runningservices_settings_title">Running services</string>
@@ -2462,7 +2462,7 @@
     <!-- [CHAR LIMIT=25] Text shown when there are no services running -->
     <string name="no_running_services">Nothing running.</string>
     <!-- Running services, description for a service in the started state -->
-    <string name="service_started_by_app">Started by application.</string>
+    <string name="service_started_by_app">Started by app.</string>
     <!-- Running services, description for a service in the started state -->
     <string name="service_client_name"><xliff:g id="client_name">%1$s</xliff:g></string>
     <!-- [CHAR LIMIT=10] Running services, summary of background processes -->
@@ -2487,7 +2487,7 @@
         processes and <xliff:g id="numservices">%2$d</xliff:g> services</string>
 
     <!-- Details about an application's running services. -->
-    <string name="runningservicedetails_settings_title">Running application</string>
+    <string name="runningservicedetails_settings_title">Running app</string>
     <!-- Message displayed when there are no active services in a process. -->
     <string name="no_services">Not active</string>
     <!-- Title for list of services. -->
@@ -2500,19 +2500,19 @@
     <string name="service_manage">Settings</string>
     <!-- Running service details, default description for services that are started. -->
     <string name="service_stop_description">This service was started by its
-        application.  Stopping it may cause the application to fail.</string>
+        app. Stopping it may cause the app to fail.</string>
     <!-- Running service details, description for running heavy-weight process. -->
-    <string name="heavy_weight_stop_description">This application can not safely
-        be stopped.  Doing so may lose some of your current work.</string>
+    <string name="heavy_weight_stop_description">This app can\'t safely
+        be stopped. If you stop it, you may lose some of your current work.</string>
     <!-- Running service details, description for background process. -->
-    <string name="background_process_stop_description">This is an old application
-        process that is being kept for better speed in case it is needed again.
+    <string name="background_process_stop_description">This is an old app
+        process that is still running in case it\'s needed again.
         There is usually no reason to stop it.</string>
     <!-- Running service details, default description for services that are managed. -->
     <string name="service_manage_description"><xliff:g id="client_name">%1$s</xliff:g>:
-        currently in use.  Touch Settings to control it.</string>
+        currently in use. Touch Settings to control it.</string>
     <!-- Description of the main process in the details. -->
-    <string name="main_running_process_description">Main process that is in use.</string>
+    <string name="main_running_process_description">Main process in use.</string>
     <!-- Message that a process's service is in use. -->
     <string name="process_service_in_use_description">Service <xliff:g id="comp_name">%1$s</xliff:g>
         is in use.</string>
@@ -2522,11 +2522,11 @@
     <!-- Running service details, stop confirmation dialog title. Displays when user selects selects to stop a system service. -->
     <string name="runningservicedetails_stop_dlg_title">Stop system service?</string>
     <!-- Running service details, stop confirmation descriptive text. Displays when user selects selects to stop a system service. -->
-    <string name="runningservicedetails_stop_dlg_text" product="tablet">Are you sure you want to stop this system service? If you do, some
+    <string name="runningservicedetails_stop_dlg_text" product="tablet">If you stop this service, some
         features of your tablet may stop working correctly until you power it off
         and then on again.</string>
     <!-- Running service details, stop confirmation descriptive text. Displays when user selects selects to stop a system service. -->
-    <string name="runningservicedetails_stop_dlg_text" product="default">Are you sure you want to stop this system service? If you do, some
+    <string name="runningservicedetails_stop_dlg_text" product="default">If you stop this service, some
         features of your phone may stop working correctly until you power it off
         and then on again.</string>
 
@@ -2565,7 +2565,7 @@
          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
+    card numbers.  It comes from the app
     <xliff:g id="ime_application_name">%1$s</xliff:g>.
     Use this input method?</string>
     <!-- On Language & input settings screen, heading. Inside the "Language & input settings" screen, this is the header for settings that relate to mouse and trackpad devices. [CHAR LIMIT=40] -->
@@ -2593,7 +2593,7 @@
     <!-- User dictionary settings. The title of the context menu item to delete the current word -->
     <string name="user_dict_settings_context_menu_delete_title">Delete</string>
     <!-- User dictionary settings. The text to show when there are no user-defined words in the dictionary  [CHAR LIMIT=200] -->
-    <string name="user_dict_settings_empty_text">You do not have any words in the user dictionary. You can add a word by touching the Add ( + ) button.</string>
+    <string name="user_dict_settings_empty_text">You don\'t have any words in the user dictionary. Add a word by touching the Add (+) button.</string>
     <!-- User dictionary settings. The text to show to describe the dictionary common to all languages -->
     <string name="user_dict_settings_all_languages">All languages</string>
 
@@ -2611,9 +2611,9 @@
     <!-- The title of the item to go into the Quick launch settings. -->
     <string name="quick_launch_title">Quick launch</string>
     <!-- The summary of the item to go into the Quick launch settings. This is a description of what Quick launch offers. -->
-    <string name="quick_launch_summary">Set keyboard shortcuts to launch applications</string>
+    <string name="quick_launch_summary">Set keyboard shortcuts to launch apps</string>
     <!-- On the Quick launch settings screen, title of the item for shortcut letters that are not assigned to an application yet. Quick launch is assigning a global shortcut to launch a specific app. -->
-    <string name="quick_launch_assign_application">Assign application</string>
+    <string name="quick_launch_assign_application">Assign app</string>
     <!-- On the Quick launch settings screen, summary text for the item of letters that are not assigned. See the quick launch "Assign application" for a description of quick launch -->
     <string name="quick_launch_no_shortcut">No shortcut</string>
     <!-- On the Quick launch settings screen, summary text under the item for each assigned letter.  -->
@@ -2627,7 +2627,7 @@
     <!-- Clear dialog for quick launch setting box button labels: -->
     <string name="quick_launch_clear_cancel_button">Cancel</string>
     <!-- Quick launch screen, when assigning an app to a shortcut, this menu item to show a list of all applications.  -->
-    <string name="quick_launch_display_mode_applications">Applications</string>
+    <string name="quick_launch_display_mode_applications">Apps</string>
     <!-- Quick launch screen, when assigning an app to a shortcut, this menu item to show a list of all shortcutable applications -->
     <string name="quick_launch_display_mode_shortcuts">Shortcuts</string>
 
@@ -2646,7 +2646,7 @@
     <!-- An option to always hide input method selector [CHAR LIMIT=25] -->
     <string name="input_method_selector_always_hide_title">Always hide</string>
     <!-- Title for configuring input method settings [CHAR LIMIT=35] -->
-    <string name="configure_input_method">Configure input methods</string>
+    <string name="configure_input_method">Set up input methods</string>
     <!-- Title for settings of each IME [CHAR LIMIT=25] -->
     <string name="input_method_settings">Settings</string>
     <!-- Spoken description for IME settings image button [CHAR LIMIT=NONE] -->
@@ -2658,7 +2658,7 @@
     <!-- Input Methods Settings localized format string for generating the appropriate "Foo settings" menu label for the Input Method named "Foo" [CHAR LIMIT=35] -->
     <string name="input_methods_settings_label_format"><xliff:g id="ime_name">%1$s</xliff:g> settings</string>
     <!-- Title for the settings of selecting active input methods of an IME [CHAR LIMIT=35] -->
-    <string name="input_methods_and_subtype_enabler_title">Select active input methods</string>
+    <string name="input_methods_and_subtype_enabler_title">Choose active input methods</string>
     <!-- Summary for on-screen keyboard settings -->
     <string name="onscreen_keyboard_settings_summary">Onscreen keyboard settings</string>
     <!-- Title for built-in keyboard settings -->
@@ -2669,7 +2669,7 @@
     <!-- Development Settings.  the title for the item to take the user to Development settings.  Development settings are settings meant for application developers.  -->
     <string name="development_settings_title">Developer options</string>
     <!-- Development Settings summary.  The summary of the item to take the user to Development settings.  Development settings are settings meant for application developers. -->
-    <string name="development_settings_summary">Set options for application development</string>
+    <string name="development_settings_summary">Set options for app development</string>
     <!-- Setting checkbox title for Whether to enable USB debugging support on the phone. -->
     <string name="enable_adb">USB debugging</string>
     <!-- Setting checkbox summary for Whether to enable USB debugging support on the phone -->
@@ -2691,7 +2691,7 @@
     <!-- Title of warning dialog about the implications of enabling USB debugging -->
     <string name="adb_warning_title">Allow USB debugging?</string>
     <!-- Warning text to user about the implications of enabling USB debugging -->
-    <string name="adb_warning_message">USB debugging is intended for development purposes only. It can be used to copy data between your computer and your device, install applications on your device without notification, and read log data.</string>
+    <string name="adb_warning_message">USB debugging is intended for development purposes only. Use it to copy data between your computer and your device, install apps on your device without notification, and read log data.</string>
 
     <!-- Title for the screen that lets the user choose a gadget to add to the home screen
          (or other screens that can host gadgets).  Note to translators: we're still determining
@@ -2723,7 +2723,7 @@
     <!-- label for text to indicate sort options -->
     <string name="display_order_text">Sort by:</string>
     <!-- label for application name -->
-    <string name="app_name_label">Application</string>
+    <string name="app_name_label">App</string>
     <!-- label for launch count -->
     <string name="launch_count_label">Count</string>
     <!-- label for usage time -->
@@ -2857,7 +2857,7 @@
     <!-- [CHAR LIMIT=25] Label for battery stats gps on state graph -->
     <string name="battery_stats_gps_on_label">GPS on</string>
     <!-- [CHAR LIMIT=25] Label for battery stats wifi running state graph -->
-    <string name="battery_stats_wifi_running_label">Wi-Fi</string>
+    <string name="battery_stats_wifi_running_label">WiFi</string>
     <!-- [CHAR LIMIT=25] Label for battery stats wake lock state graph -->
     <string name="battery_stats_wake_lock_label">Awake</string>
     <!-- [CHAR LIMIT=25] Label for battery stats phone signal strength graph -->
@@ -2867,9 +2867,9 @@
     <!-- CPU awake time title -->
     <string name="awake">Device awake time</string>
     <!-- Wifi on time -->
-    <string name="wifi_on_time">Wi-Fi on time</string>
+    <string name="wifi_on_time">WiFi on time</string>
     <!-- Bluetooth on time -->
-    <string name="bluetooth_on_time">Wi-Fi on time</string>
+    <string name="bluetooth_on_time">WiFi on time</string>
     <!-- Application name and battery usage percentage -->
     <string name="usage_name_percent"><xliff:g id="name">%1$s</xliff:g>" - "
             <xliff:g id="number" example="30">%2$s</xliff:g><xliff:g id="percent" example="%">%%</xliff:g></string>
@@ -2889,7 +2889,7 @@
     <!-- Label for power consumed by the screen -->
     <string name="power_screen">Screen</string>
     <!-- Label for power consumed by WiFi -->
-    <string name="power_wifi">Wi-Fi</string>
+    <string name="power_wifi">WiFi</string>
     <!-- Label for power consumed by Bluetooth -->
     <string name="power_bluetooth">Bluetooth</string>
     <!-- Label for power consumed by Cell idle -->
@@ -2910,7 +2910,7 @@
     <!-- Label for GPU usage time -->
     <string name="usage_type_gps">GPS</string>
     <!-- [CHAR LIMIT=25] Label for WIFI usage time -->
-    <string name="usage_type_wifi_running">Wi-Fi running</string>
+    <string name="usage_type_wifi_running">WiFi running</string>
     <!-- Label for Phone usage time -->
     <string name="usage_type_phone" product="tablet">Tablet</string>
     <!-- Label for Phone usage time -->
@@ -2930,13 +2930,13 @@
     <!-- Label for force stop action -->
     <string name="battery_action_stop">Force stop</string>
     <!-- Label for app details action -->
-    <string name="battery_action_app_details">Application info</string>
+    <string name="battery_action_app_details">App info</string>
     <!-- Label for app settings action -->
-    <string name="battery_action_app_settings">Application settings</string>
+    <string name="battery_action_app_settings">App settings</string>
     <!-- Label for display settings -->
     <string name="battery_action_display">Screen settings</string>
     <!-- Label for wifi settings -->
-    <string name="battery_action_wifi">Wi-Fi settings</string>
+    <string name="battery_action_wifi">WiFi settings</string>
     <!-- Label for bluetooth settings -->
     <string name="battery_action_bluetooth">Bluetooth settings</string>
 
@@ -2959,25 +2959,25 @@
     <string name="battery_sugg_display">Reduce the screen brightness and/or screen timeout</string>
 
     <!-- Description for wifi connectivity -->
-    <string name="battery_desc_wifi">Battery used by Wi-Fi</string>
+    <string name="battery_desc_wifi">Battery used by WiFi</string>
     <!-- Suggestion for wifi connectivity power drain -->
-    <string name="battery_sugg_wifi">Turn off Wi-Fi when not using it or where it is not available</string>
+    <string name="battery_sugg_wifi">Turn off WiFi when not using it or when it isn\'t available</string>
 
     <!-- Description for bluetooth power consumption detail -->
-    <string name="battery_desc_bluetooth">Battery used by bluetooth</string>
+    <string name="battery_desc_bluetooth">Battery used by Bluetooth</string>
     <!-- Suggestion for bluetooth -->
-    <string name="battery_sugg_bluetooth_basic">Turn off bluetooth when you aren\'t using it</string>
+    <string name="battery_sugg_bluetooth_basic">Turn off Bluetooth when you aren\'t using it</string>
     <!-- Suggestion for bluetooth headset -->
-    <string name="battery_sugg_bluetooth_headset">Try connecting to a different bluetooth device</string>
+    <string name="battery_sugg_bluetooth_headset">Try connecting to a different Bluetooth device</string>
 
     <!-- [CHAR LIMIT=50] Description for power consumed by applications -->
-    <string name="battery_desc_apps">Battery used by application</string>
+    <string name="battery_desc_apps">Battery used by app</string>
     <!-- Suggestion for exploring application info to stop or uninstall -->
-    <string name="battery_sugg_apps_info">Stop or uninstall the application</string>
+    <string name="battery_sugg_apps_info">Stop or uninstall the app</string>
     <!-- [CHAR LIMIT=100] Suggestion for getting apps to consume less power due to GPS-->
-    <string name="battery_sugg_apps_gps">"Manually control GPS to prevent application from using it"</string>
+    <string name="battery_sugg_apps_gps">"Manually control GPS to prevent app from using it"</string>
     <!-- Suggestion for getting apps to consume less power -->
-    <string name="battery_sugg_apps_settings">The application may offer settings to reduce battery use</string>
+    <string name="battery_sugg_apps_settings">The app may offer settings to reduce battery use</string>
 
     <!-- Menu label for viewing battery usage since unplugged -->
     <string name="menu_stats_unplugged"><xliff:g id="unplugged">%1$s</xliff:g> since unplugged</string>
@@ -3020,11 +3020,11 @@
     <!-- On main TTS Settings screen, title for toggle used to force use of default TTS settings -->
     <string name="use_default_tts_settings_title">Always use my settings</string>
     <!-- On main TTS Settings screen, summary for toggle used to force use of default TTS settings -->
-    <string name="use_default_tts_settings_summary">Default settings below override application settings</string>
+    <string name="use_default_tts_settings_summary">Default settings below override app settings</string>
     <!-- On main TTS Settings screen, section header for default TTS settings -->
     <string name="tts_default_settings_section">Default settings</string>
     <!-- On main TTS Settings screen, in default settings section, setting default synthesis engine for synthesized voice -->
-    <string name="tts_default_synth_title">Default Engine</string>
+    <string name="tts_default_synth_title">Default engine</string>
     <!-- On main TTS Settings screen, summary for default synthesis engine for synthesized voice -->
     <string name="tts_default_synth_summary">Sets the speech synthesis engine to be used for spoken text</string>
     <!-- On main TTS Settings screen, in default settings section, setting default speech rate for synthesized voice -->
@@ -3056,12 +3056,12 @@
     <!-- Button text for error screen when a selected TTS engine can't run because it's missing components -->
     <string name="tts_engine_error_config">Configure</string>
     <!-- Button text for error screen when a selected TTS engine can't run because it's missing components -->
-    <string name="tts_engine_error_reselect">Select another engine</string>
+    <string name="tts_engine_error_reselect">Choose another engine</string>
     <!-- Warning message about security implications of enabling a TTS engine, displayed as a dialog
          message when the user selects to enable an engine. -->
     <string name="tts_engine_security_warning">This speech synthesis engine may be able to collect
     all the text that will be spoken, including personal data like passwords and credit
-    card numbers.  It comes from the <xliff:g id="tts_plugin_engine_name">%s</xliff:g> engine.
+    card numbers. It comes from the <xliff:g id="tts_plugin_engine_name">%s</xliff:g> engine.
     Enable the use of this speech synthesis engine?</string>
     <!-- On main TTS Settings screen, text for divider under which all TTS engines are listed -->
     <string name="tts_engines_section">Engines</string>
@@ -3106,8 +3106,8 @@
     <string name="tts_general_section_title">General</string>
 
     <!-- Power Control Widget -->
-    <string name="gadget_title">Power Control</string>
-    <string name="gadget_toggle_wifi">Updating Wi-Fi setting</string>
+    <string name="gadget_title">Power control</string>
+    <string name="gadget_toggle_wifi">Updating WiFi setting</string>
     <string name="gadget_toggle_bluetooth">Updating Bluetooth setting</string>
 
     <!-- Title of preference to enter the VPN settings activity -->
@@ -3133,13 +3133,13 @@
     <string name="trusted_credentials_summary">Display trusted CA certificates</string>
 
     <!-- Title of dialog to enable credential storage [CHAR LIMIT=30] -->
-    <string name="credentials_unlock">Enter password</string>
+    <string name="credentials_unlock"></string>
     <!-- Description of dialog to enable credential storage [CHAR LIMIT=NONE] -->
-    <string name="credentials_unlock_hint">Enter the password for credential storage.</string>
+    <string name="credentials_unlock_hint">Type the password for credential storage.</string>
     <!-- Description of the input box for the old password [CHAR LIMIT=30] -->
     <string name="credentials_old_password">Current password:</string>
     <!-- Description of dialog to reset credential storage [CHAR LIMIT=NONE] -->
-    <string name="credentials_reset_hint">All the contents will be removed. Are you sure about that?</string>
+    <string name="credentials_reset_hint">Remove all the contents?</string>
     <string name="credentials_password_too_short">The password must have at least 8 characters.</string>
     <!-- Error message [CHAR LIMIT=NONE] -->
     <string name="credentials_wrong_password">Incorrect password.</string>
@@ -3150,11 +3150,11 @@
     <!-- Toast message [CHAR LIMIT=30] -->
     <string name="credentials_erased">Credential storage is erased.</string>
     <!-- Toast message [CHAR LIMIT=30] when credential storage containing private keys and certificates could not be erased (opposite of string credentials_erased) -->
-    <string name="credentials_not_erased">Credential storage could not be erased.</string>
+    <string name="credentials_not_erased">Credential storage couldn\'t be erased.</string>
     <!-- Toast message [CHAR LIMIT=30] -->
     <string name="credentials_enabled">Credential storage is enabled.</string>
     <!-- Description of dialog to explain that a lock screen password is required to use credential storage [CHAR LIMIT=NONE] -->
-    <string name="credentials_configure_lock_screen_hint">You must set a lock screen PIN or password before you can use credential storage. Would you like to do that now?</string>
+    <string name="credentials_configure_lock_screen_hint">You must set a lock screen PIN or password before you can use credential storage.</string>
 
     <!-- Sound settings screen, setting check box label -->
     <string name="emergency_tone_title">Emergency tone</string>
@@ -3167,13 +3167,13 @@
     <!-- Privacy settings activity title -->
     <string name="privacy_settings_title">Backup &amp; reset</string>
     <!-- Backup section title -->
-    <string name="backup_section_title">Backup and restore</string>
+    <string name="backup_section_title">Backup &amp; restore</string>
     <!-- Personal data section title -->
     <string name="personal_data_section_title">Personal data</string>
     <!-- Backup data menu title -->
     <string name="backup_data_title">Back up my data</string>
     <!-- Summary text of the "back up data" setting -->
-    <string name="backup_data_summary">Back up application data, Wi-Fi passwords, and other settings to Google servers</string>
+    <string name="backup_data_summary">Back up app data, WiFi passwords, and other settings to Google servers</string>
     <!-- Configure backup account options menu title [CHAR LIMIT=25]-->
     <string name="backup_configure_account_title">Backup account</string>
     <!-- Default summary text of the "Configure backup account" setting [CHAR LIMIT=80]-->
@@ -3181,19 +3181,19 @@
     <!-- Auto-restore menu title -->
     <string name="auto_restore_title">Automatic restore</string>
     <!-- Summary text of the "automatic restore" setting -->
-    <string name="auto_restore_summary">If I reinstall an application, restore backed up settings or other data</string>
+    <string name="auto_restore_summary">When reinstalling an app, restore backed up settings and data</string>
 
     <!-- Local (desktop) backup password menu title [CHAR LIMIT=25] -->
     <string name="local_backup_password_title">Desktop backup password</string>
     <!-- Summary text of the "local backup password" setting when the user has not supplied a password -->
-    <string name="local_backup_password_summary_none">Desktop full backups are not currently protected.</string>
+    <string name="local_backup_password_summary_none">Desktop full backups aren\'t currently protected.</string>
     <!-- Summary text of the "local backup password" setting when the user has already supplied a password -->
     <string name="local_backup_password_summary_change">Select to change or remove the password for desktop full backups</string>
 
     <!-- Dialog title for confirmation to erase backup data from server -->
-    <string name="backup_erase_dialog_title">Backup</string>
+    <string name="backup_erase_dialog_title"></string>
     <!-- Dialog title for confirmation to erase backup data from server -->
-    <string name="backup_erase_dialog_message">Are you sure you want to stop backing up your Wi-Fi passwords, bookmarks, and other settings and application data and erase all copies on Google servers?</string>
+    <string name="backup_erase_dialog_message">Stop backing up your WiFi passwords, bookmarks, other settings, and app data, plus erase all copies on Google servers?</string>
 
     <!-- Device admin settings screen --><skip />
     <!-- Device admin settings activity title -->
@@ -3215,11 +3215,11 @@
     <string name="device_admin_add_title">Device administrator</string>
     <!-- Device admin warning message about policies an admin can use -->
     <string name="device_admin_warning">Activating this administrator will allow
-        the application <xliff:g id="app_name">%1$s</xliff:g> to perform the
+        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
         following operations:</string>
     <!-- Device admin warning message about policies an admin can use -->
     <string name="device_admin_status">This administrator is active and allows
-        the application <xliff:g id="app_name">%1$s</xliff:g> to perform the
+        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
         following operations:</string>
 
     <!-- Name to assign to a Network Access Point that was saved without a name -->
@@ -3232,22 +3232,22 @@
 
     <!-- Wifi Setup For Setup Wizard with XL screen -->
     <!-- Title shown in Wifi Setup Wizard with XL screen -->
-    <string name="wifi_setup_title">Wi-Fi setup</string>
+    <string name="wifi_setup_title">WiFi setup</string>
     <!-- Title shown in Wifi Setup Wizard with XL screen when
          a user is configuring password for a network.
          The argument should be the name of the network.
          [CHAR LIMIT=50] -->
-    <string name="wifi_setup_title_editing_network">Connect to Wi-Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
+    <string name="wifi_setup_title_editing_network">Connect to WiFi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
     <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
          the device is connecting a network the user specified.
          The argument should be the name of the network.
          [CHAR LIMIT=50] -->
-    <string name="wifi_setup_title_connecting_network">Connecting to Wi-Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g>...</string>
+    <string name="wifi_setup_title_connecting_network">Connecting to WiFi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g>\u2026</string>
     <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
          the device successfully connected to a network the user specified.
          The argument should be the name of the network.
          [CHAR LIMIT=50] -->
-    <string name="wifi_setup_title_connected_network">Connected to Wi-Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
+    <string name="wifi_setup_title_connected_network">Connected to WiFi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
     <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
          a user is adding a network.
          [CHAR LIMIT=50] -->
@@ -3288,7 +3288,7 @@
 
     <!-- The message shown above available networks when the device is scanning
          available networks [CHAR LIMIT=35] -->
-    <string name="wifi_setup_status_scanning">Scanning networks...</string>
+    <string name="wifi_setup_status_scanning">Scanning networks\u2026</string>
     <!-- Message shown above available network when there's no connected network.
          Used in Wifi Setup For Setup Wizard with XL screen. -->
     <string name="wifi_setup_status_select_network">Touch a network to connect to it</string>
@@ -3303,7 +3303,7 @@
     <!-- Message shown above available networks when a user clicked one of available
          networks and the UI is prompting the user to edit the network configuration
          if needed. Used in Wifi Setup with XL screen. [CHAR LIMIT=35] -->
-    <string name="wifi_setup_status_edit_network">Enter network configuration</string>
+    <string name="wifi_setup_status_edit_network">Type network configuration</string>
     <!-- The message shown above available networks when a user clicked "Add network"
          button. Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
     <string name="wifi_setup_status_new_network">Connect to new network</string>
@@ -3311,23 +3311,23 @@
          networks or created another profile and he/she is waiting for the connection
          is established.
          Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
-    <string name="wifi_setup_status_connecting">Connecting...</string>
+    <string name="wifi_setup_status_connecting">Connecting\u2026</string>
     <!-- The message shown above available networks when connection is established,
          letting a user to proceed to the next step of the SetupWizard.
          Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
-    <string name="wifi_setup_status_proceed_to_next">Proceed to the next step</string>
+    <string name="wifi_setup_status_proceed_to_next">Go to the next step</string>
     <!-- The message shown above available networks when a user clicked a network secured by
          EAP. We don't allow the user to connect it.
          Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
-    <string name="wifi_setup_status_eap_not_supported">EAP not supported</string>
+    <string name="wifi_setup_status_eap_not_supported">EAP isn\'t supported.</string>
     <!-- Message shown when users select EAP in WiFi settings for SetupWizard,
          saying EAP can't be configured in SetupWizard flow.
          [CHAR LIMIT=NONE] -->
-    <string name="wifi_setup_eap_not_supported">You can\u0027t configure an EAP Wi-Fi connection during setup. After setup, you can do that in Settings, under <b>Wireless &amp; networks</b>.</string>
+    <string name="wifi_setup_eap_not_supported">You can\'t configure an EAP WiFi connection during setup. After setup, you can do that in Settings &gt; Wireless &amp; networks.</string>
     <!-- Message shown when the device is connecting a network [CHAR LIMIT=NONE] -->
-    <string name="wifi_setup_description_connecting">Connecting can take a few minutes...</string>
+    <string name="wifi_setup_description_connecting">Connecting can take a few minutes\u2026</string>
     <!-- Message shown when the device is connected to a network [CHAR LIMIT=NONE] -->
-    <string name="wifi_setup_description_connected">Touch <b>Next</b> to continue with setup.\n\nTouch <b>Back</b> to connect to a different Wi-Fi network.</string>
+    <string name="wifi_setup_description_connected">Touch <b>Next</b> to continue with setup.\n\nTouch <b>Back</b> to connect to a different WiFi network.</string>
 
     <!-- Do not translate. This is a stub which will be removed soon. -->
     <string name="time_zone_auto_stub" translatable="false">Select Time Zone</string>
@@ -3348,11 +3348,11 @@
     <!-- Data synchronization settings screen, title of setting that controls whether background data should be used [CHAR LIMIT=30] -->
     <string name="background_data">Background data</string>
     <!-- Data synchronization settings screen, summary of setting that controls whether background data should be used [CHAR LIMIT=60] -->
-    <string name="background_data_summary">Applications can sync, send, and receive data at any time</string>
+    <string name="background_data_summary">Apps can sync, send, and receive data at any time</string>
     <!-- Data synchronization settings screen, title of dialog that confirms the user's unchecking of background data [CHAR LIMIT=20] -->
-    <string name="background_data_dialog_title">Attention</string>
+    <string name="background_data_dialog_title">Disable background data?</string>
     <!-- Data synchronization settings screen, message of dialog that confirms the user's unchecking of background data [CHAR LIMIT=200] -->
-    <string name="background_data_dialog_message">Disabling background data extends battery life and lowers data use. Some applications may still use the background data connection.</string>
+    <string name="background_data_dialog_message">Disabling background data extends battery life and lowers data use. Some apps may still use the background data connection.</string>
     <!-- Title for a checkbox that enables data synchronization in the account and sync screen [CHAR LIMIT=35] -->
     <string name="sync_automatically">Auto-sync app data</string>
 
@@ -3386,7 +3386,7 @@
     </string>
 
     <!-- Header title for those settings relating to application syncing. -->
-    <string name="header_application_sync_settings">Application sync settings</string>
+    <string name="header_application_sync_settings">App sync settings</string>
 
     <!-- Header for data and synchronization -->
     <string name="header_data_and_synchronization">Data &amp; synchronization</string>
@@ -3401,44 +3401,42 @@
     <!-- Button shown when this activity is run from SetupWizard -->
     <string name="finish_button_label">Finish</string>
     <!-- Title of remove message for remove account dialog -->
-    <string name="really_remove_account_title">Remove account</string>
+    <string name="really_remove_account_title">Remove account?</string>
     <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
-    <string name="really_remove_account_message" product="tablet">Do you really want to remove this account? Removing it will also delete all of its messages, contacts, and other data from the tablet.
-    \nProceed?</string>
+    <string name="really_remove_account_message" product="tablet">Removing this account will delete all of its messages, contacts, and other data from the tablet!</string>
     <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
-    <string name="really_remove_account_message" product="default">Do you really want to remove this account? Removing it will also delete all of its messages, contacts, and other data from the phone.
-    \nProceed?</string>
+    <string name="really_remove_account_message" product="default">Removing this account will delete all of its messages, contacts, and other data from the phone!</string>
     <!-- This is shown if the autheticator for a given account fails to remove it. -->
-    <string name="remove_account_failed" product="tablet">This account is required by some applications. You can only remove it by resetting the tablet to factory defaults (which deletes all your personal data). You do that in the Settings application, under Privacy.</string>
+    <string name="remove_account_failed" product="tablet">This account is required by some apps. You can only remove it by resetting the tablet to factory defaults (which deletes all your personal data) in Settings &gt; Backup &amp; reset.</string>
     <!-- This is shown if the autheticator for a given account fails to remove it. -->
-    <string name="remove_account_failed" product="default">This account is required by some applications. You can only remove it by resetting the phone to factory defaults (which deletes all your personal data). You do that in the Settings application, under Privacy.</string>
+    <string name="remove_account_failed" product="default">This account is required by some apps. You can only remove it by resetting the phone to factory defaults (which deletes all your personal data) in Settings &gt; Backup &amp; reset.</string>
     <!-- What to show in messaging that refers to this provider, e.g. AccountSyncSettings -->
     <string name="provider_label">Push subscriptions</string>
     <!-- Formatter in AccountSyncSettings for each application we wish to synchronize, e.g. "Sync Calendar" -->
     <string name="sync_item_title">Sync <xliff:g id="authority" example="Calendar">%s</xliff:g></string>
     <!-- Title of dialog shown when you can't manually sync an item because it's disabled -->
-    <string name="cant_sync_dialog_title">Cannot manually sync</string>
+    <string name="cant_sync_dialog_title">Can\'t manually sync</string>
     <!-- Messaage shown in dialog when you can't manually sync -->
-    <string name="cant_sync_dialog_message">Sync for this item is currently disabled. To change your preference, temporarily turn on background data and automatic sync.</string>
+    <string name="cant_sync_dialog_message">Sync for this item is currently disabled. To change this setting, temporarily turn on background data and automatic sync.</string>
 
     <!-- This is displayed to the user when the device needs to be decrypted -->
-    <string name="enter_password">Enter password to decrypt storage</string>
+    <string name="enter_password">Type password to decrypt storage</string>
     <!-- This is displayed when the password is entered incorrectly -->
-    <string name="try_again">Sorry, try again</string>
+    <string name="try_again">Try again.</string>
     <!-- This error message is displayed when the vpn profile is going to be saved but the vpn service is busy [CHAR LIMIT=NONE] -->
-    <string name="service_busy">Service busy, try again</string>
+    <string name="service_busy">The service is busy. Try again.</string>
 
     <!-- the following are for Settings Storage screen -->
     <!-- Menu item/button 'delete' -->
     <string name="delete">Delete</string>
     <!-- Misc files [CHAR LIMIT=25] -->
-    <string name="misc_files">Misc Files</string>
+    <string name="misc_files">Misc files</string>
     <!-- number of misc files selected [CHAR LIMIT=40] -->
     <string name="misc_files_selected_count">selected <xliff:g id="number" example="3">%1$d</xliff:g> out of <xliff:g id="total" example="15">%2$d</xliff:g></string>
     <!-- number of bytes represented by the selected misc files [CHAR LIMIT=40] -->
     <string name="misc_files_selected_count_bytes"><xliff:g id="number" example="3.25MB">%1$s</xliff:g> out of <xliff:g id="total" example="15.25MB">%2$s</xliff:g></string>
     <!--  action to select all [CHAR LIMIT=30] -->
-    <string name="select_all">Select All</string>
+    <string name="select_all">Select all</string>
 
     <!-- HDCP checking title, used for debug purposes only. [CHAR LIMIT=25] -->
     <string name="hdcp_checking_title">HDCP checking</string>
@@ -3477,7 +3475,7 @@
     <!-- UI debug setting: force hardware acceleration to render apps [CHAR LIMIT=25] -->
     <string name="force_hw_ui">Force hardware acceleration</string>
     <!-- UI debug setting: force hardware acceleration summary [CHAR LIMIT=50] -->
-    <string name="force_hw_ui_summary">Render applications using the GPU</string>
+    <string name="force_hw_ui_summary">Render apps using the GPU</string>
 
     <!-- UI debug setting: scaling factor for window animations [CHAR LIMIT=25] -->
     <string name="window_animation_scale_title">Window animation scale</string>
@@ -3486,7 +3484,7 @@
     <string name="transition_animation_scale_title">Transition animation scale</string>
 
     <!-- Preference category for application debugging development settings. [CHAR LIMIT=25] -->
-    <string name="debug_applications_category">Applications</string>
+    <string name="debug_applications_category">Apps</string>
 
     <!-- UI debug setting: immediately destroy activities? [CHAR LIMIT=25] -->
     <string name="immediately_destroy_activities">Don\'t keep activities</string>
@@ -3500,7 +3498,7 @@
     <!-- UI debug setting: show all ANRs? [CHAR LIMIT=25] -->
     <string name="show_all_anrs">Show all ANRs</string>
     <!-- UI debug setting: show all ANRs summary [CHAR LIMIT=50] -->
-    <string name="show_all_anrs_summary">Show Application Not Responding dialog
+    <string name="show_all_anrs_summary">Show App Not Responding dialog
         for background apps</string>
 
     <!-- Activity title for network data usage summary. [CHAR LIMIT=25] -->
@@ -3514,7 +3512,7 @@
     <!-- Title for checkbox menu option to show 4G mobile data usage separate from other mobile data usage. [CHAR LIMIT=32] -->
     <string name="data_usage_menu_split_4g">Separate 4G usage</string>
     <!-- Title for checkbox menu option to show Wi-Fi data usage. [CHAR LIMIT=32] -->
-    <string name="data_usage_menu_show_wifi">Show Wi-Fi usage</string>
+    <string name="data_usage_menu_show_wifi">Show WiFi usage</string>
     <!-- Title for checkbox menu option to show Ethernet data usage. [CHAR LIMIT=32] -->
     <string name="data_usage_menu_show_ethernet">Show Ethernet usage</string>
     <!-- Title for option to change data usage cycle day. [CHAR LIMIT=32] -->
@@ -3522,7 +3520,7 @@
     <!-- Body of dialog prompting user to change numerical day of month that data usage cycle should reset. [CHAR LIMIT=64] -->
     <string name="data_usage_pick_cycle_day">Day of month to reset data usage cycle:</string>
     <!-- Label shown when no applications used data during selected time period. [CHAR LIMIT=48] -->
-    <string name="data_usage_empty">No applications used data during this period.</string>
+    <string name="data_usage_empty">No apps used data during this period.</string>
     <!-- Label for data usage occuring while application in foreground. [CHAR LIMIT=48] -->
     <string name="data_usage_label_foreground">Foreground</string>
     <!-- Label for data usage occuring while application in background. [CHAR LIMIT=48] -->
@@ -3537,10 +3535,10 @@
     <!-- Checkbox label that will disable 2G-3G network data connection when user-defined limit is reached. [CHAR LIMIT=32] -->
     <string name="data_usage_disable_3g_limit">Set 2G-3G data limit</string>
     <!-- Checkbox label that will disable Wi-Fi network data connection when user-defined limit is reached. [CHAR LIMIT=32] -->
-    <string name="data_usage_disable_wifi_limit">Set Wi-Fi data limit</string>
+    <string name="data_usage_disable_wifi_limit">Set WiFi data limit</string>
 
     <!-- Tab title for showing Wi-Fi data usage. [CHAR LIMIT=10] -->
-    <string name="data_usage_tab_wifi">Wi-Fi</string>
+    <string name="data_usage_tab_wifi">WiFi</string>
     <!-- Tab title for showing Ethernet data usage. [CHAR LIMIT=10] -->
     <string name="data_usage_tab_ethernet">Ethernet</string>
     <!-- Tab title for showing combined mobile data usage. [CHAR LIMIT=10] -->
@@ -3563,17 +3561,17 @@
     <string name="data_usage_enable_4g">4G data</string>
 
     <!-- Button title for launching application-specific data usage settings. [CHAR LIMIT=32] -->
-    <string name="data_usage_app_settings">View application settings</string>
+    <string name="data_usage_app_settings">View app settings</string>
     <!-- Checkbox label that restricts background data usage of a specific application. [CHAR LIMIT=32] -->
     <string name="data_usage_app_restrict_background">Restrict background data</string>
     <!-- Summary message for checkbox that restricts background data usage of a specific application. [CHAR LIMIT=64] -->
-    <string name="data_usage_app_restrict_background_summary">Disable background data on mobile data network only. Wi-Fi will be used if available.</string>
+    <string name="data_usage_app_restrict_background_summary">Disable background data on mobile data network only. WiFi will be used if available.</string>
     <!-- Summary message for checkbox that restricts background data usage of a specific application when no networks have been limited. [CHAR LIMIT=64] -->
     <string name="data_usage_app_restrict_background_summary_disabled">To restrict background data for this app, first set a mobile data limit.</string>
     <!-- Title of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=48] -->
     <string name="data_usage_app_restrict_dialog_title">Restrict background data?</string>
     <!-- Body of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_app_restrict_dialog">This feature may cause an app that depends on background data to stop working when Wi-Fi isn\'t available.\n\nMore appropriate data usage controls may be found in the settings available from within the app.</string>
+    <string name="data_usage_app_restrict_dialog">This feature may cause an app that depends on background data to stop working when WiFi isn\'t available.\n\nYou can find more appropriate data usage controls in the settings available within the app.</string>
     <!-- Body of dialog shown when user attempts to restrict background data before a network data limit has been set. [CHAR LIMIT=NONE] -->
     <string name="data_usage_restrict_denied_dialog">Restricting background data is possible only when you\'ve set a mobile data limit.</string>
 
@@ -3592,12 +3590,12 @@
     <!-- Title of dialog shown before user limits data usage. [CHAR LIMIT=48] -->
     <string name="data_usage_limit_dialog_title">Limiting data usage</string>
     <!-- Body of dialog shown before user limits mobile data usage. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_limit_dialog">Your <xliff:g id="networks" example="mobile">%1$s</xliff:g> data connection will be disabled when the specified limit is reached.\n\nTo avoid overage charges, consider using a reduced limit, as device and carrier accounting methods may vary.</string>
+    <string name="data_usage_limit_dialog">Your <xliff:g id="networks" example="mobile">%1$s</xliff:g> data connection will be disabled when the specified limit is reached.\n\nTo avoid overage charges, consider using a reduced limit, as device and accounting methods may vary.</string>
 
     <!-- Title of dialog shown before user restricts background data usage. [CHAR LIMIT=48] -->
     <string name="data_usage_restrict_background_title">Restrict background data?</string>
     <!-- Body of dialog shown before user restricts background data usage. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_restrict_background">If you restrict background mobile data, some apps and services won\'t work unless Wi-Fi is available.</string>
+    <string name="data_usage_restrict_background">If you restrict background mobile data, some apps and services won\'t work unless you\'re connected to a WiFi network.</string>
 
     <!-- Label displaying current network data usage warning threshold. [CHAR LIMIT=18] -->
     <string name="data_usage_sweep_warning"><font size="21"><xliff:g id="number" example="128">^1</xliff:g></font> <font size="9"><xliff:g id="unit" example="KB">^2</xliff:g></font>\n<font size="12">warning</font></string>
@@ -3651,7 +3649,7 @@
     <!-- Hint for not using an optional feature of a VPN network. [CHAR LIMIT=40] -->
     <string name="vpn_not_used">(not used)</string>
     <!-- Option to not use a CA certificate to verify the VPN server. [CHAR LIMIT=40] -->
-    <string name="vpn_no_ca_cert">(do not verify server)</string>
+    <string name="vpn_no_ca_cert">(don\'t verify server)</string>
 
     <!-- Button label to cancel chaning a VPN network. [CHAR LIMIT=40] -->
     <string name="vpn_cancel">Cancel</string>
@@ -3704,22 +3702,22 @@
     <!-- Title for touch exploration tutorial lesson 1. -->
     <string name="accessibility_tutorial_lesson_1_title">Lesson 1: Exploring the screen</string>
     <!-- Instruction for touch exploration tutorial lesson 1. "Explore by touch" should match the string for "Title for accessibility preference to enable touch exploration mode." -->
-    <string name="accessibility_tutorial_lesson_1_text_1">After you turn on \"Explore by touch,\" you can touch the screen to learn what’s under your finger. For example, the current screen contains application icons. Find one of them by touching the screen and sliding your finger around.</string>
+    <string name="accessibility_tutorial_lesson_1_text_1">After you turn on Explore by Touch, you can touch the screen to learn what\’s under your finger. For example, the current screen contains app icons. Find one of them by touching the screen and sliding your finger around.</string>
     <!-- Instruction for touch exploration tutorial lesson 1, displayed after the user touches one icon. -->
     <string name="accessibility_tutorial_lesson_1_text_2_more">Good. Keep sliding your finger around the screen until you find at least one more icon.</string>
     <!-- Instruction for touch exploration tutorial lesson 1, displayed after the user touches a second icon. -->
-    <string name="accessibility_tutorial_lesson_1_text_3">To activate something that you’re touching, tap it. Slide your finger until you find the icon for the <xliff:g id="app_name" example="Browser">%s</xliff:g>. Then tap the icon once to activate it.</string>
+    <string name="accessibility_tutorial_lesson_1_text_3">To activate something that you\’re touching, tap it. Slide your finger until you find the icon for the <xliff:g id="app_name" example="Browser">%s</xliff:g>. Then tap the icon once to activate it.</string>
     <!-- Instruction for touch exploration tutorial lesson 1, displayed if the user touched the target area and stays inside it. -->
     <string name="accessibility_tutorial_lesson_1_text_4">Your finger is touching the <xliff:g id="app_name" example="Browser">%s</xliff:g> icon. Tap once to activate the icon.</string>
     <!-- Instruction for touch exploration tutorial lesson 1, displayed if the user touches inside the target area but moves outside. -->
     <string name="accessibility_tutorial_lesson_1_text_4_exited">Your finger moved over the <xliff:g id="app_name" example="Browser">%s</xliff:g> icon, and then moved away. Slowly slide your finger around the screen until you find the Browser icon again.</string>
     <!-- Instruction for touch exploration tutorial lesson 1, displayed after the user has tapped the target icon. -->
-    <string name="accessibility_tutorial_lesson_1_text_5">Good. To move to the next lesson, find and activate the "<xliff:g id="next" example="Next">%s</xliff:g> button," located near the bottom-right corner of the screen.</string>
+    <string name="accessibility_tutorial_lesson_1_text_5">Good. To move to the next lesson, find and activate the <xliff:g id="next" example="Next">%s</xliff:g> button, located near the bottom-right corner of the screen.</string>
 
     <!-- Title for touch exploration tutorial lesson 2. -->
     <string name="accessibility_tutorial_lesson_2_title">Lesson 2: Scrolling using two fingers</string>
     <!-- Instruction for touch exploration tutorial lesson 2. -->
-    <string name="accessibility_tutorial_lesson_2_text_1">To scroll through a list, you can slide two fingers along the screen. For example, the current screen contains a list of application names that can scroll up or down. First, try to identify a few items in the list by sliding one finger around.</string>
+    <string name="accessibility_tutorial_lesson_2_text_1">To scroll through a list, you can slide two fingers along the screen. For example, the current screen contains a list of app names that can scroll up or down. First, try to identify a few items in the list by sliding one finger around.</string>
     <!-- Instruction for touch exploration tutorial lesson 2, displayed after the user touches one list item. -->
     <string name="accessibility_tutorial_lesson_2_text_2_more">Good. Keep sliding your finger around to find at least one more item.</string>
     <!-- Instruction for touch exploration tutorial lesson 2, displayed after the user touches a second list item. -->
@@ -3727,17 +3725,17 @@
     <!-- Instruction for touch exploration tutorial lesson 2, displayed after the user scrolls a small amount. -->
     <string name="accessibility_tutorial_lesson_2_text_3_more">Good. Keep sliding your fingers up to scroll some more.</string>
     <!-- Instruction for touch exploration tutorial lesson 2, displayed after the user has scrolled a large amount. -->
-    <string name="accessibility_tutorial_lesson_2_text_4">You have completed the tutorial. To exit, find and tap the <xliff:g id="finish" example="Finish">%s</xliff:g> button.</string>
+    <string name="accessibility_tutorial_lesson_2_text_4">You have completed the tutorial. To exit, find and touch the <xliff:g id="finish" example="Finish">%s</xliff:g> button.</string>
 
     <!--  Title for spelling correction settings -->
     <string name="spellcheckers_settings_title">Spelling correction</string>
 
     <!-- Prompt for the user to enter their current full-backup password -->
-    <string name="current_backup_pw_prompt">Enter your current full backup password here</string>
+    <string name="current_backup_pw_prompt">Type your current full backup password here</string>
     <!-- Prompt for the user to enter a new full-backup password -->
-    <string name="new_backup_pw_prompt">Enter a new password for full backups here</string>
+    <string name="new_backup_pw_prompt">Type a new password for full backups here</string>
     <!-- Prompt for the user to confirm the new full-backup password by re-entering it -->
-    <string name="confirm_new_backup_pw_prompt">Please re-enter your new full backup password here</string>
+    <string name="confirm_new_backup_pw_prompt">Retype your new full backup password here</string>
 
     <!-- Button label for setting the user's new full-backup password -->
     <string name="backup_pw_set_button_text">Set backup password</string>
diff --git a/src/com/android/settings/ChooseLockGeneric.java b/src/com/android/settings/ChooseLockGeneric.java
index 8b3f204..110635f 100644
--- a/src/com/android/settings/ChooseLockGeneric.java
+++ b/src/com/android/settings/ChooseLockGeneric.java
@@ -328,8 +328,7 @@
                 if(isFallback) {
                     startActivityForResult(intent, FALLBACK_REQUEST);
                     return;
-                }
-                else {
+                } else {
                     intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
                     startActivity(intent);
                 }
@@ -346,8 +345,7 @@
                 if(isFallback) {
                     startActivityForResult(intent, FALLBACK_REQUEST);
                     return;
-                }
-                else {
+                } else {
                     intent.addFlags(Intent.FLAG_ACTIVITY_FORWARD_RESULT);
                     startActivity(intent);
                 }
diff --git a/src/com/android/settings/SoundSettings.java b/src/com/android/settings/SoundSettings.java
index 8b7cd37..f73460b 100644
--- a/src/com/android/settings/SoundSettings.java
+++ b/src/com/android/settings/SoundSettings.java
@@ -351,8 +351,11 @@
             try {
                 Cursor cursor = context.getContentResolver().query(ringtoneUri,
                         new String[] { MediaStore.Audio.Media.TITLE }, null, null, null);
-                if (cursor.moveToFirst()) {
-                    summary = cursor.getString(0);
+                if (cursor != null) {
+                    if (cursor.moveToFirst()) {
+                        summary = cursor.getString(0);
+                    }
+                    cursor.close();
                 }
             } catch (SQLiteException sqle) {
                 // Unknown title for the ringtone
diff --git a/src/com/android/settings/fuelgauge/PowerUsageSummary.java b/src/com/android/settings/fuelgauge/PowerUsageSummary.java
index 6ff3e0e..41286ef 100644
--- a/src/com/android/settings/fuelgauge/PowerUsageSummary.java
+++ b/src/com/android/settings/fuelgauge/PowerUsageSummary.java
@@ -414,6 +414,8 @@
         }
         final double averageCostPerByte = getAverageDataCost();
         long uSecTime = mStats.computeBatteryRealtime(SystemClock.elapsedRealtime() * 1000, which);
+        long appWakelockTime = 0;
+        BatterySipper osApp = null;
         mStatsPeriod = uSecTime;
         SparseArray<? extends Uid> uidStats = mStats.getUidStats();
         final int NU = uidStats.size();
@@ -488,6 +490,7 @@
                 }
             }
             wakelockTime /= 1000; // convert to millis
+            appWakelockTime += wakelockTime;
 
             // Add cost of holding a wake lock
             power += (wakelockTime
@@ -535,7 +538,7 @@
             if (DEBUG) Log.i(TAG, "UID " + u.getUid() + ": power=" + power);
 
             // Add the app to the list if it is consuming power
-            if (power != 0) {
+            if (power != 0 || u.getUid() == 0) {
                 BatterySipper app = new BatterySipper(getActivity(), mRequestQueue, mHandler,
                         packageWithHighestDrain, DrainType.APP, 0, u,
                         new double[] {power});
@@ -553,6 +556,9 @@
                 } else {
                     mUsageList.add(app);
                 }
+                if (u.getUid() == 0) {
+                    osApp = app;
+                }
             }
             if (u.getUid() == Process.WIFI_UID) {
                 mWifiPower += power;
@@ -564,6 +570,25 @@
             }
             if (DEBUG) Log.i(TAG, "Added power = " + power);
         }
+
+        // The device has probably been awake for longer than the screen on
+        // time and application wake lock time would account for.  Assign
+        // this remainder to the OS, if possible.
+        if (osApp != null) {
+            long wakeTimeMillis = mStats.computeBatteryUptime(
+                    SystemClock.uptimeMillis() * 1000, which) / 1000;
+            wakeTimeMillis -= appWakelockTime - (mStats.getScreenOnTime(
+                    SystemClock.elapsedRealtime(), which) / 1000);
+            if (wakeTimeMillis > 0) {
+                double power = (wakeTimeMillis
+                        * mPowerProfile.getAveragePower(PowerProfile.POWER_CPU_AWAKE)) / 1000;
+                osApp.wakeLockTime += wakeTimeMillis;
+                osApp.value += power;
+                osApp.values[0] += power;
+                if (osApp.value > mMaxPower) mMaxPower = osApp.value;
+                mTotalPower += power;
+            }
+        }
     }
 
     private void addPhoneUsage(long uSecNow) {
diff --git a/src/com/android/settings/widget/SettingsAppWidgetProvider.java b/src/com/android/settings/widget/SettingsAppWidgetProvider.java
index 656bf47..656d072 100644
--- a/src/com/android/settings/widget/SettingsAppWidgetProvider.java
+++ b/src/com/android/settings/widget/SettingsAppWidgetProvider.java
@@ -100,6 +100,10 @@
     private static final int MINIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_DIM + 10;
     private static final int MAXIMUM_BACKLIGHT = android.os.Power.BRIGHTNESS_ON;
     private static final int DEFAULT_BACKLIGHT = (int) (android.os.Power.BRIGHTNESS_ON * 0.4f);
+    /** Minimum brightness at which the indicator is shown at half-full and ON */
+    private static final int HALF_BRIGHTNESS_THRESHOLD = (int) (0.3 * MAXIMUM_BACKLIGHT);
+    /** Minimum brightness at which the indicator is shown at full */
+    private static final int FULL_BRIGHTNESS_THRESHOLD = (int) (0.8 * MAXIMUM_BACKLIGHT);
 
     private static final StateTracker sWifiState = new WifiStateTracker();
     private static final StateTracker sBluetoothState = new BluetoothStateTracker();
@@ -580,6 +584,14 @@
         }
     }
 
+    private static void checkObserver(Context context) {
+        if (sSettingsObserver == null) {
+            sSettingsObserver = new SettingsObserver(new Handler(),
+                    context.getApplicationContext());
+            sSettingsObserver.startObserving();
+        }
+    }
+
     @Override
     public void onUpdate(Context context, AppWidgetManager appWidgetManager,
             int[] appWidgetIds) {
@@ -598,11 +610,7 @@
                 new ComponentName("com.android.settings", ".widget.SettingsAppWidgetProvider"),
                 PackageManager.COMPONENT_ENABLED_STATE_ENABLED,
                 PackageManager.DONT_KILL_APP);
-        if (sSettingsObserver == null) {
-            sSettingsObserver = new SettingsObserver(new Handler(),
-                    context.getApplicationContext());
-            sSettingsObserver.startObserving();
-        }
+        checkObserver(context);
     }
 
     @Override
@@ -653,6 +661,7 @@
         // Update specific list of appWidgetIds if given, otherwise default to all
         final AppWidgetManager gm = AppWidgetManager.getInstance(context);
         gm.updateAppWidget(THIS_APPWIDGET, views);
+        checkObserver(context);
     }
 
     /**
@@ -669,19 +678,30 @@
 
         if (getBrightnessMode(context)) {
             views.setImageViewResource(R.id.img_brightness,
-                                       R.drawable.ic_appwidget_settings_brightness_auto_holo);
+                    R.drawable.ic_appwidget_settings_brightness_auto_holo);
             views.setImageViewResource(R.id.ind_brightness,
-                                       R.drawable.appwidget_settings_ind_on_r_holo);
-        } else if (getBrightness(context)) {
-            views.setImageViewResource(R.id.img_brightness,
-                                       R.drawable.ic_appwidget_settings_brightness_full_holo);
-            views.setImageViewResource(R.id.ind_brightness,
-                                       R.drawable.appwidget_settings_ind_on_r_holo);
+                    R.drawable.appwidget_settings_ind_on_r_holo);
         } else {
-            views.setImageViewResource(R.id.img_brightness,
-                                       R.drawable.ic_appwidget_settings_brightness_off_holo);
-            views.setImageViewResource(R.id.ind_brightness,
-                                       R.drawable.appwidget_settings_ind_off_r_holo);
+            final int brightness = getBrightness(context);
+            // Set the icon
+            if (brightness > FULL_BRIGHTNESS_THRESHOLD) {
+                views.setImageViewResource(R.id.img_brightness,
+                        R.drawable.ic_appwidget_settings_brightness_full_holo);
+            } else if (brightness > HALF_BRIGHTNESS_THRESHOLD) {
+                views.setImageViewResource(R.id.img_brightness,
+                        R.drawable.ic_appwidget_settings_brightness_half_holo);
+            } else {
+                views.setImageViewResource(R.id.img_brightness,
+                        R.drawable.ic_appwidget_settings_brightness_off_holo);
+            }
+            // Set the ON state
+            if (brightness > HALF_BRIGHTNESS_THRESHOLD) {
+                views.setImageViewResource(R.id.ind_brightness,
+                        R.drawable.appwidget_settings_ind_on_r_holo);
+            } else {
+                views.setImageViewResource(R.id.ind_brightness,
+                        R.drawable.appwidget_settings_ind_off_r_holo);
+            }
         }
     }
 
@@ -747,24 +767,23 @@
     }
 
     /**
-     * Gets state of brightness.
+     * Gets brightness level.
      *
      * @param context
-     * @return true if more than moderately bright.
+     * @return brightness level between 0 and 255.
      */
-    private static boolean getBrightness(Context context) {
+    private static int getBrightness(Context context) {
         try {
             IPowerManager power = IPowerManager.Stub.asInterface(
                     ServiceManager.getService("power"));
             if (power != null) {
                 int brightness = Settings.System.getInt(context.getContentResolver(),
                         Settings.System.SCREEN_BRIGHTNESS);
-                return brightness > 100;
+                return brightness;
             }
         } catch (Exception e) {
-            Log.d(TAG, "getBrightness: " + e);
         }
-        return false;
+        return 0;
     }
 
     /**
