diff --git a/AndroidManifest.xml b/AndroidManifest.xml
index 55736f4..fac2d34 100644
--- a/AndroidManifest.xml
+++ b/AndroidManifest.xml
@@ -553,6 +553,21 @@
                 android:resource="@id/notification_settings" />
         </activity>
 
+        <activity android:name="Settings$HomeSettingsActivity"
+                android:label="@string/home_settings"
+                android:taskAffinity="">
+            <intent-filter>
+                <action android:name="android.intent.action.MAIN" />
+                <action android:name="android.settings.HOME_SETTINGS" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <category android:name="android.intent.category.VOICE_LAUNCH" />
+            </intent-filter>
+            <meta-data android:name="com.android.settings.FRAGMENT_CLASS"
+                android:value="com.android.settings.HomeSettings" />
+            <meta-data android:name="com.android.settings.TOP_LEVEL_HEADER_ID"
+                android:resource="@id/home_settings" />
+        </activity>
+
         <activity android:name="Settings$DisplaySettingsActivity"
                 android:label="@string/display_settings"
                 android:taskAffinity="">
@@ -735,7 +750,7 @@
         </activity>
 
         <activity android:name="Settings$NotificationStationActivity"
-                android:theme="@android:style/Theme.DeviceDefault"
+                android:theme="@style/Theme.NotificationStation"
                 android:label="@string/notification_log_title"
                 android:taskAffinity="">
             <intent-filter>
diff --git a/res/layout/notification_log_row.xml b/res/layout/notification_log_row.xml
index 57f5a79..cf8b112 100644
--- a/res/layout/notification_log_row.xml
+++ b/res/layout/notification_log_row.xml
@@ -18,6 +18,8 @@
     android:layout_height="wrap_content"
     android:paddingBottom="6dp"
     android:paddingTop="6dp"
+    android:paddingStart="?android:attr/listPreferredItemPaddingStart"
+    android:paddingEnd="?android:attr/listPreferredItemPaddingEnd"
     android:orientation="vertical"
     android:background="?android:attr/selectableItemBackground"
     >
diff --git a/res/layout/settings_main.xml b/res/layout/settings_main.xml
index 0cc018e..cfd4e64 100644
--- a/res/layout/settings_main.xml
+++ b/res/layout/settings_main.xml
@@ -21,7 +21,7 @@
               android:orientation="vertical"
               android:layout_height="match_parent"
               android:layout_width="match_parent"
-              android:background="@color/dashboard_background_color">
+              android:background="?attr/dashboardBackgroundColor">
 
     <LinearLayout
             android:orientation="vertical"
diff --git a/res/values/arrays.xml b/res/values/arrays.xml
index b35a5a1..a00fbb4 100644
--- a/res/values/arrays.xml
+++ b/res/values/arrays.xml
@@ -374,8 +374,8 @@
         <item>Always</item>
         <!-- Keep Wi-Fi on when screen turns off and plugged in.  When on battery, go to sleep when screen turns off. -->
         <item>Only when plugged in</item>
-        <!-- Do not keep Wi-Fi on when screen turns off. -->
-        <item>Never (increases data usage)</item>
+        <!-- Do not keep Wi-Fi on when screen turns off.  [CHAR LIMIT=40] -->
+        <item>Never</item>
     </string-array>
 
     <!-- Wi-Fi settings. Presented as a list dialog to the user to choose the Wi-Fi sleep policy. Used when
@@ -400,10 +400,26 @@
         <item>0</item>
     </string-array>
 
+    <!-- Data Usage settings. Range of data usage. -->
+    <string-array name="data_usage_data_range">
+        <!-- Last 30 days [CHAR LIMIT=25]-->
+        <item>Last 30 days</item>
+        <!-- Set usage cycle [CHAR LIMIT=25]-->
+        <item>Set usage cycle...</item>
+    </string-array>
+
+    <!-- Sim Cards display numbers. Range of data usage. -->
+    <string-array name="sim_card_data_range">
+        <!-- Last 4 digits [CHAR LIMIT=40]-->
+        <item>Last 4 digits</item>
+        <!-- First 4 digits [CHAR LIMIT=40]-->
+        <item>First 4 digits</item>
+    </string-array>
+
     <!-- Wi-Fi settings. Presented as a list dialog to the user to choose the Wi-Fi frequency band. -->
     <string-array name="wifi_frequency_band_entries">
         <!-- Operation on both 2.4 GHz and 5 GHz [CHAR LIMIT=25]-->
-        <item>Auto</item>
+        <item>Automatic</item>
         <!-- Operation on 5 GHz alone [CHAR LIMIT=25]-->
         <item>5 GHz only</item>
         <!-- Operation on 2.4 GHz alone [CHAR LIMIT=25]-->
diff --git a/res/values/attrs.xml b/res/values/attrs.xml
index 86cffa9..a4e4d48 100644
--- a/res/values/attrs.xml
+++ b/res/values/attrs.xml
@@ -100,4 +100,5 @@
     <attr name="switchBarMarginStart" format="dimension" />
     <attr name="switchBarMarginEnd" format="dimension" />
 
+    <attr name="dashboardBackgroundColor" format="color" />
 </resources>
diff --git a/res/values/strings.xml b/res/values/strings.xml
index 69eec26..04e0b9a 100644
--- a/res/values/strings.xml
+++ b/res/values/strings.xml
@@ -45,10 +45,14 @@
     <!-- Category headings in left-pane header menu --> <skip />
     <!-- Settings main menu category heading. Wireless and networks (Wi-Fi, Bluetooth, data usage...). [CHAR LIMIT=40] -->
     <string name="header_category_wireless_networks">Wireless &amp; networks</string>
+    <!-- Settings main menu category heading. Wireless and networks (Wi-Fi, Bluetooth, data usage...). [CHAR LIMIT=40] -->
+    <string name="header_category_connections">Connections</string>
     <!-- Settings main menu category heading. Device (Sound, display, battery, applications...). [CHAR LIMIT=40] -->
     <string name="header_category_device">Device</string>
     <!-- Settings main menu category heading. Personal (Accounts, security, language, backup...). [CHAR LIMIT=40] -->
     <string name="header_category_personal">Personal</string>
+    <!-- Settings main menu category heading. Personal (Accounts, security, language, backup...). [CHAR LIMIT=40] -->
+    <string name="header_category_access">Access</string>
     <!-- Settings main menu category heading. System (Updates, data, accessibility, about phone). [CHAR LIMIT=40] -->
     <string name="header_category_system">System</string>
 
@@ -267,6 +271,8 @@
 
     <!-- Bluetooth Visibility message.  This message informs the user that their device is now visible to other bluetooth devices.  [CHAR LIMIT=50] -->
     <string name="bluetooth_is_visible_message"><xliff:g id="device_name">%1$s</xliff:g> is now visible to nearby devices.</string>
+    <!-- Bluetooth Visibility discoonect question.  Asks the user if they wish to disconnect a paired bluetooth device.  [CHAR LIMIT=50] -->
+    <string name="bluetooth_is_disconnect_question">Disconnect <xliff:g id="device_name">%1$s</xliff:g>?</string>
     <!-- Bluetooth broadcasting settings, option to enable/disable broadcasting -->
     <string name="bluetooth_broadcasting">Broadcasting</string>
     <!-- Bluetooth settings.  Dialog title to disable a single profile of a device. [CHAR LIMIT=40] -->
@@ -604,9 +610,27 @@
     <!-- NEW STUFF -->
     <!-- ======================================================================================= -->
 
-    <!-- Button label for generic cancel action -->
+    <!-- Button label for generic cancel action [CHAR LIMIT=20] -->
     <string name="cancel">Cancel</string>
 
+    <!-- Button label for generic cancel action in all caps [CHAR LIMIT=20] -->
+    <string name="cancel_all_caps">CANCEL</string>
+
+    <!-- Button label for generic continue action in all caps [CHAR LIMIT=20] -->
+    <string name="continue_all_caps">CONTINUE</string>
+
+    <!-- Button label for generic OK action [CHAR LIMIT=20] -->
+    <string name="okay">OK</string>
+
+    <!-- Button label for generic YES action [CHAR LIMIT=20] -->
+    <string name="yes_all_caps">YES</string>
+
+    <!-- Button label for generic NO action [CHAR LIMIT=20] -->
+    <string name="no_all_caps">NO</string>
+
+    <!-- Button label for generic FORGET action [CHAR LIMIT=20] -->
+    <string name="forget">FORGET</string>
+
     <!-- Title of the Settings activity shown within the application itself. -->
     <string name="settings_label">Settings</string>
     <!-- Title of the Settings activity shown in the Launcher. [CHAR LIMIT=20] -->
@@ -615,13 +639,19 @@
     <string name="settings_shortcut">Settings shortcut</string>
     <!-- Wireless controls settings screen, setting check box label -->
     <string name="airplane_mode">Airplane mode</string>
-    <!-- Main Settings screen settings title for things like airplane mode, tethering, NFC, VPN.  This will take you to another screen with those settings. -->
-    <string name="radio_controls_title">NFC &amp; more</string>
+    <!-- Main Settings screen settings title for things like airplane mode, tethering, NFC, VPN.  This will take you to another screen with those settings.  [CHAR LIMIT=30] -->
+    <string name="radio_controls_title">More</string>
     <!-- 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\u2011Fi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</string>
+    <string name="radio_controls_summary">Manage Wi\u2011Fi, Bluetooth, airplane mode, cellular networks, &amp; VPNs</string>
 
+    <!-- check box cellular data title [CHAR LIMIT=30]-->
+    <string name="cellular_data_title">Cellular data</string>
+    <!-- check box cellular data summary [CHAR LIMIT=40]-->
+    <string name="cellular_data_summary">Allow data usage over cellular network</string>
+    <!-- check box to allow data usage when roaming [CHAR LIMIT=30]-->
+    <string name="allow_data_usage_title">Allow data usage when roaming</string>
     <!-- mobile network settings screen, setting check box title -->
     <string name="roaming">Data roaming</string>
     <!-- mobile network settings screen, setting option summary text when check box is selected -->
@@ -668,14 +698,24 @@
     <!-- Date & time setting screen setting option summary text when Automatic time zone check box is clear
         [CHAR LIMIT=100] -->
     <string name="zone_auto_summaryOff">Use network-provided time zone</string>
+    <!-- Date & time setting screen setting check box title [CHAR LIMIT=30] -->
+    <string name="date_time_24hour_title">24\u2011hour format</string>
     <!-- Date & time setting screen setting check box title -->
     <string name="date_time_24hour">Use 24-hour format</string>
+    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
+    <string name="date_time_set_time_title">Time</string>
     <!-- Date & time setting screen setting option title -->
     <string name="date_time_set_time">Set time</string>
+    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
+    <string name="date_time_set_timezone_title">Time zone</string>
     <!-- Date & time setting screen setting option title -->
     <string name="date_time_set_timezone">Select time zone</string>
+    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
+    <string name="date_time_set_date_title">Date</string>
     <!-- Date & time setting screen setting option title -->
     <string name="date_time_set_date">Set date</string>
+    <!-- Date & time setting screen setting option title.  This setting allows the user to choose how the date should be displayed in apps (what ordering for month and day, etc.)  [CHAR LIMIT=30] -->
+    <string name="date_time_date_format_title">Date format</string>
     <!-- Date & time setting screen setting option title.  This setting allows the user to choose how the date should be displayed in apps (what ordering for month and day, etc.) -->
     <string name="date_time_date_format">Choose date format</string>
     <!-- Menu item on Select time zone screen -->
@@ -724,6 +764,8 @@
     <string name="show_profile_info_on_lockscreen_label">Show profile info on lock screen</string>
     <!-- Text shown for title of profile info setting [CHAR LIMIT=20]-->
     <string name="profile_info_settings_title">Profile info</string>
+    <!-- Main Settings screen setting option title for the item to take you to the Accounts screen [CHAR LIMIT=22] -->
+    <string name="Accounts_settings_title">Accounts</string>
     <!-- Main Settings screen setting option title for the item to take you to the location screen -->
     <string name="location_settings_title">Location</string>
     <!-- Main Settings screen setting option title for the item to take you to the accounts screen [CHAR LIMIT=22] -->
@@ -1084,6 +1126,8 @@
 
     <!-- Button text for accepting an incoming pairing request. [CHAR LIMIT=20] -->
     <string name="bluetooth_pairing_accept">Pair</string>
+    <!-- Button text for accepting an incoming pairing request in all caps. [CHAR LIMIT=20] -->
+    <string name="bluetooth_pairing_accept_all_caps">PAIR</string>
     <!-- Button text for declining an incoming pairing request. [CHAR LIMIT=20] -->
     <string name="bluetooth_pairing_decline">Cancel</string>
 
@@ -1110,12 +1154,32 @@
     <string name="bluetooth_searching_for_devices">Searching\u2026</string>
     <!-- Bluetooth settings: The sub heading for device settings. [CHAR LIMIT=30] -->
     <string name="bluetooth_preference_device_settings">Device settings</string>
+    <!-- Bluetooth settings: Paired dialog title [CHAR LIMIT=40] -->
+    <string name="bluetooth_preference_paired_dialog_title">Paired device</string>
+    <!-- Bluetooth settings: Name label [CHAR LIMIT=40] -->
+    <string name="bluetooth_preference_paired_dialog_name_label">Name</string>
+    <!-- Bluetooth settings: Use for label [CHAR LIMIT=40] -->
+    <string name="bluetooth_preference_paired_dialog_use_label">Use for</string>
+    <!-- Bluetooth settings: Checkbox label for enable/disable internet connection.  [CHAR LIMIT=40] -->
+    <string name="bluetooth_preference_paired_dialog_internet_option">Internet connection</string>
+    <!-- Bluetooth settings: Checkbox label for enable/disable keyboard connection.  [CHAR LIMIT=40] -->
+    <string name="bluetooth_preference_paired_dialog_keyboard_option">Keyboard</string>
+    <!-- Bluetooth settings: pairing dialog title.  [CHAR LIMIT=40] -->
+    <string name="bluetooth_pairing_dialog_title">Pair with this device?</string>
+    <!-- Bluetooth settings: share phone book title.  [CHAR LIMIT=40] -->
+    <string name="bluetooth_pairing_dialog_sharing_phonebook_title">Share phone book?</string>
+    <!-- Bluetooth settings: Message informing user that a bluetooth wants to access contant and call history.  [CHAR LIMIT=100] -->
+    <string name="bluetooth_pairing_dialog_contants_request"><xliff:g id="device_name">%1$s</xliff:g> wants to access your contacts and call history.</string>
+    <!-- Bluetooth settings: paring permission message.  [CHAR LIMIT=100] -->
+    <string name="bluetooth_pairing_dialog_paring_request"><xliff:g id="device_name">%1$s</xliff:g> wants to pair with Bluetooth.</string>
     <!-- Bluetooth settings: The sub heading for devices which have already been paired with this device. [CHAR LIMIT=40] -->
     <string name="bluetooth_preference_paired_devices">Paired devices</string>
     <!-- Bluetooth settings: The sub heading for messaging accesses. [CHAR LIMIT=50] -->
     <string name="bluetooth_message_access">Paired devices can view messages from</string>
     <!-- Bluetooth settings: The sub heading for available devices during and after scanning. [CHAR LIMIT=40] -->
     <string name="bluetooth_preference_found_devices">Available devices</string>
+    <!-- Bluetooth settings: The message displayed if no Bluetooth devices were found. [CHAR LIMIT=40] -->
+    <string name="bluetooth_preference_no_found_devices">No devices available</string>
     <!-- Bluetooth settings.  Context menu item for a device.  Action will connect to all profiles on the device. -->
     <string name="bluetooth_device_context_connect">Connect</string>
     <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect from all profiles on the device. -->
@@ -1224,6 +1288,47 @@
     <!-- Bluetooth settings.  Dock Setting Dialog - Remember setting and don't ask user again -->
     <string name="bluetooth_dock_settings_remember">Remember settings</string>
 
+    <!-- Wifi Assistant title string.  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_title">Wi\u2011Fi Assistant</string>
+    <!-- Wifi Assistant No, thanks string.  Text to say no to wifi assistant. [CHAR LIMIT=20] -->
+    <string name="wifi_assistant_no_thanks">NO, THANKS</string>
+    <!-- Wifi Assistant setup string.  Text to say yes to wifi assistant and begin setup. [CHAR LIMIT=20] -->
+    <string name="wifi_assistant_setup">SET UP</string>
+    <!-- Wifi Assistant card message.  [CHAR LIMIT=200] -->
+    <string name="wifi_assistant_card_message">Automatically connect to available networks with a Wi\u2011Fi Assistant.</string>
+    <!-- Wifi Assistant title.  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_title">Wi\u2011Fi Assistant</string>
+    <!-- Wifi Assistant title message.  First piece of text on the Wifi Assistant setup wizard.  [CHAR LIMIT=200] -->
+    <string name="wifi_assistant_title_message">Google Wi\u2011Fi Assistant automatically connects you to the best available Wi\u2011Fi</string>
+    <!-- Wifi Assistant explanation message.  Explains what wifi assistant does to the android phone.  [CHAR LIMIT=200] -->
+    <string name="wifi_assistant_explanation_message">Google Wi\u2011Fi Assistant detects the networks available to you and connects your device to the one with the best speed and reliability.</string>
+    <!-- Wifi Assistant vpn message.  Explains to the user that Google may use/provide a secure VPN connecte to Google's servers.  [CHAR LIMIT=100] -->
+    <string name="wifi_assistant_vpn_message">To help protect your data, Google Wi\u2011Fi Assistant may provide a secure VPN connection through Google servers.</string>
+    <!-- Wifi Assistant No, thanks string.  Text to say no to wifi assistant. [CHAR LIMIT=20] -->
+    <string name="wifi_assistant_activity_no_thanks">No, thanks</string>
+    <!-- Wifi Assistant Yes string.  Text to say yes to wifi assistant. [CHAR LIMIT=20] -->
+    <string name="wifi_assistant_activity_yes">YES, I\'M IN</string>
+    <!-- Wifi Assistant Dialog title.  [CHAR LIMIT=30] -->
+    <string name="wifi_assistant_dialog_title">Connection Request</string>
+    <!-- Wifi Assistant Dialog message.  Explains what monitor may occur with wifi-assistant [CHAR LIMIT=100] -->
+    <string name="wifi_assistant_dialog_message">Wi\u2011Fi Assistant" wants to set up a VPN connection that allows it to monitor network traffic.  Only accept if you trust the source.</string>
+    <!-- Wifi Assistant Dialog message. Notice of the icon that will appear when wifi assistant is on.  [CHAR LIMIT=100] -->
+    <string name="wifi_assistant_dialog_notice">appears at the top of your screen when VPN is active.</string>
+    <!-- Wifi Assistant dialog accept.  [CHAR LIMIT=20] -->
+    <string name="wifi_assistant_accept">ACCEPT</string>
+    <!-- Wifi Assistant dialog deny.  [CHAR LIMIT=20] -->
+    <string name="wifi_assistant_deny">DENY</string>
+    <!-- Wifi Assistant Network Monitoring titile.  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_network_title">Network monitoring</string>
+    <!-- Wifi Assistant permission accepted message.  [CHAR LIMIT=100] -->
+    <string name="wifi_assistant_permission_accepted">You gave “Google Wi\u2011Fi Assistant” permission to set up a VPN connection. That means this app can monitor network traffic.</string>
+    <!-- Wifi Assistant open app button text.  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_open_app">OPEN APP</string>
+    <!-- Wifi Assistant change wi-fi assistant title.  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_change_title">Change Wi\u2011Fi assistant?</string>
+    <!-- Wifi Assistant request message.  This message asks the user if it is okay for a 3rd party app to mana wi-fi assistant (instead of Google's wi-fi assistant). CHAR LIMIT=100] -->
+    <string name="wifi_assistant_change_message">Use <xliff:g id="third_party">%1$s</xliff:g> instead of <xliff:g id="google_wifi">%2$s</xliff:g> to manage your network connections?</string>
+
     <!-- Wifi Display settings. The title of the screen. [CHAR LIMIT=40] -->
     <string name="wifi_display_settings_title">Cast screen</string>
     <!-- Wifi Display settings. The title of a menu item to enable wireless display [CHAR LIMIT=40] -->
@@ -1328,16 +1433,28 @@
     <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 -->
-    <string name="wifi_notify_open_networks_summary">Notify me when an open network is available</string>
+    <!-- Checkbox summary for option to notify user when open networks are nearby [CHAR LIMIT=60]-->
+    <string name="wifi_notify_open_networks_summary">Notify whenever a public network is available</string>
     <!-- Checkbox title for option to toggle poor network detection -->
     <string name="wifi_poor_network_detection">Avoid poor connections</string>
     <!-- Checkbox summary for option to toggle poor network detection -->
     <string name="wifi_poor_network_detection_summary">Don\'t use a Wi\u2011Fi network unless it has a good Internet connection</string>
+    <!-- Checkbox summary for option to toggle poor network detection [CHAR LIMIT=60] -->
+    <string name="wifi_avoid_poor_network_detection_summary">Only use networks that have a good Internet connection</string>
     <!-- Checkbox title for option to scan always available setting -->
     <string name="wifi_scan_always_available">Scanning always available</string>
+    <!-- Checkbox title for option to scan always available setting [CHAR LIMIT=60] -->
+    <string name="wifi_scan_always_available_title">Always allow scanning</string>
     <!-- Checkbox summary for option to toggle scan always available setting -->
-    <string name="wifi_scan_always_available_summary">Let Google\'s location service and other apps scan for networks, even when Wi-Fi is off</string>
+    <string name="wifi_scan_always_available_summary">Let Google\'s location service and other apps scan for networks, even when Wi\u2011Fi is off</string>
+    <!-- Checkbox title for option to Automatically manage Wi\u2011Fi  [CHAR LIMIT=40] -->
+    <string name="wifi_automatically_manage_title">Automatically manage Wi\u2011Fi</string>
+    <!-- Checkbox summary for option to Automatically manage Wi\u2011Fi  [CHAR LIMIT=100] -->
+    <string name="wifi_automatically_manage_summary">Let a Wi\u2011Fi assistant manager your Wi\u2011Fi connection</string>
+    <!-- Checkbox title for option for Wi\u2011Fi Assistant  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_setting_title">Wi\u2011Fi assistant</string>
+    <!-- Checkbox summary for option for Wi\u2011Fi Assistant  [CHAR LIMIT=40] -->
+    <string name="wifi_assistant_setting_summary">Google Wi\u2011Fi Assistant</string>
     <!-- Preference title for option to install certificates -->
     <string name="wifi_install_credentials">Install certificates</string>
     <string name="wifi_scan_notify_text_location_on">To improve location accuracy and for other purposes, Google and other apps may scan for nearby networks, even when Wi-Fi is off. If you don\'t want this to happen, go to Advanced &gt; Scanning always available.</string>
@@ -1346,12 +1463,20 @@
     <string name="wifi_scan_notify_remember_choice">Don\'t show again</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\u2011Fi on during sleep</string>
+    <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? [CHAR LIMIT=30] -->
+    <string name="wifi_setting_on_during_sleep_title">Wi\u2011Fi 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>
+    <!-- Checkbox title for option to toggle suspend power optimizations [CHAR LIMIT=30]-->
+    <string name="wifi_suspend_efficiency">Wi\u2011FI optimization</string>
+    <!-- Checkbox title for option to toggle suspend power optimizations [CHAR LIMIT=30] -->
+    <string name="wifi_suspend_efficiency_title">Improve efficiency</string>
     <!-- Checkbox title for option to toggle suspend power optimizations -->
     <string name="wifi_suspend_optimizations">Wi\u2011Fi optimization</string>
     <!-- Checkbox summary for option to toggle suspend power optimizations -->
     <string name="wifi_suspend_optimizations_summary">Minimize battery usage when Wi\u2011Fi is on</string>
+    <!-- Checkbox summary for option to toggle suspend power optimizations [CHAR LIMIT=30] -->
+    <string name="wifi_limit_optimizations_summary">Limit battery used by Wi\u2011Fi</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-->
@@ -1389,11 +1514,11 @@
     <!-- Wi-Fi settings. wps menu title [CHAR LIMIT=25]-->
     <string name="wifi_setup_wps">Automatic setup (WPS)</string>
     <!-- Message informing that wifi is required during setup [CHAR LIMIT=NONE] -->
-    <string name="wifi_required_info_text">To complete setup, your tablet needs access to Wi\u2011Fi. After setup, you can switch between mobile data and Wi\u2011Fi.</string>
+    <string name="wifi_required_info_text">To complete setup, your tablet needs access to Wi\u2011Fi. After setup, you can switch between cellular data and Wi\u2011Fi.</string>
 
     <!-- Dialog for Access Points --> <skip />
-    <!-- Label to show/hide advanced options -->
-    <string name="wifi_show_advanced">Show advanced options</string>
+    <!-- Label to show/hide advanced options [CHAR LIMIT=40] -->
+    <string name="wifi_show_advanced">Advanced options</string>
     <!-- Title for the WPS setup dialog [CHAR LIMIT=50] -->
     <string name="wifi_wps_setup_title">Wi\u2011Fi Protected Setup</string>
     <!-- Message in WPS dialog at start up [CHAR LIMIT=150] -->
@@ -1514,9 +1639,18 @@
     <string name="wifi_security_eap">802.1x EAP</string>
 
     <string name="wifi_scan_always_turnon_message">To improve location accuracy and for other purposes, <xliff:g id="app_name">%1$s</xliff:g> wants to turn on network scanning, even when Wi-Fi is off.\n\nAllow this for all apps that want to scan?</string>
+    <!-- Message informing the user how to turn off  [CHAR LIMIT=200] -->
+    <string name="wifi_scan_always_turnoff_message">To turn this off, go to Advanced in the overflow menu.</string>
     <string name="wifi_scan_always_confirm_allow">Allow</string>
     <string name="wifi_scan_always_confirm_deny">Deny</string>
 
+    <!-- Dialog label to sign in to a Hotspot. [CHAR LIMIT=50]-->
+    <string name="wifi_hotspot_title">Sign in to connect?</string>
+    <!-- Dialog message to sign in to a Hotspot. [CHAR LIMIT=50]-->
+    <string name="wifi_hotspot_message"><xliff:g id="app_name">%1$s</xliff:g> requires you to sign in online before you connect to the network.</string>
+    <!-- Wifi settings button to connect in to a Hotspot. [CHAR LIMIT=50]-->
+    <string name="wifi_hotspot_connect">CONNECT</string>
+
     <!-- Button label to connect to a Wi-Fi network -->
     <string name="wifi_connect">Connect</string>
     <!-- Failured notification for connect -->
@@ -1537,15 +1671,21 @@
     <string name="wifi_dont_skip">Don\'t skip</string>
 
     <!-- Text warning about skipping Wi-Fi with a mobile connect (tablet) [CHAR LIMIT=NONE]-->
-    <string name="wifi_skipped_message" product="tablet">WARNING: You may incur extra carrier data charges.\n\nTablet setup can require significant network activity.</string>
+    <string name="wifi_skipped_message" product="tablet">WARNING: if you skip Wi\u2011Fi, your tablet will only use cellular data for initial downloads and updates. To avoid possible data charges, connect to Wi\u2011Fi.</string>
+    <!-- Text warning about skipping Wi-Fi with a mobile connect (device) [CHAR LIMIT=NONE]-->
+    <string name="wifi_skipped_message" product="device">WARNING: if you skip Wi\u2011Fi, your device will only use cellular data for initial downloads and updates. To avoid possible data charges, connect to Wi\u2011Fi.</string>
     <!-- Text warning about skipping Wi-Fi with a mobile connect (phone) [CHAR LIMIT=NONE]-->
-    <string name="wifi_skipped_message" product="default">WARNING: You may incur extra carrier data charges.\n\nPhone setup can require significant network activity.</string>
+    <string name="wifi_skipped_message" product="default">WARNING: if you skip Wi\u2011Fi, your phone will only use cellular data for initial downloads and updates. To avoid possible data charges, connect to Wi\u2011Fi.</string>
     <!-- Text warning about skipping Wi-Fi without a mobile connect (tablet) [CHAR LIMIT=NONE] -->
-    <string name="wifi_and_mobile_skipped_message" product="tablet">WARNING: Until you have an internet connection, the tablet won\'t be able to verify that your software is up to date.</string>
+    <string name="wifi_and_mobile_skipped_message" product="tablet">WARNING: If you skip Wi\u2011Fi, your tablet won\'t have an Internet connection to use for any initial downloads or updates.</string>
+    <!-- Text warning about skipping Wi-Fi without a mobile connect (device) [CHAR LIMIT=NONE] -->
+    <string name="wifi_and_mobile_skipped_message" product="device">WARNING: If you skip Wi\u2011Fi, your device won\'t have an Internet connection to use for any initial downloads or updates.</string>
     <!-- Text warning about skipping Wi-Fi without a mobile connect (phone) [CHAR LIMIT=NONE] -->
-    <string name="wifi_and_mobile_skipped_message" product="default">WARNING: Until you have an internet connection, the phone won\'t be able to verify that your software is up to date.</string>
+    <string name="wifi_and_mobile_skipped_message" product="default">WARNING: If you skip Wi\u2011Fi, your phone won\'t have an Internet connection to use for any initial downloads or updates.</string>
     <!-- Text alerting that Wi-Fi couldn't connect (tablet) [CHAR LIMIT=NONE] -->
     <string name="wifi_connect_failed_message" product="tablet">The tablet was unable to connect to this Wi\u2011Fi network.</string>
+    <!-- Text alerting that Wi-Fi couldn't connect (device) [CHAR LIMIT=NONE] -->
+    <string name="wifi_connect_failed_message" product="device">The device was unable to connect to this Wi\u2011Fi network.</string>
     <!-- Text alerting that Wi-Fi couldn't connect (phone) [CHAR LIMIT=NONE] -->
     <string name="wifi_connect_failed_message" product="default">The phone was unable to connect to this Wi\u2011Fi network.</string>
 
@@ -1634,6 +1774,10 @@
     <!-- Wifi AP settings-->
     <!-- Label for Wifi tether checkbox. Toggles Access Point on/off -->
     <string name="wifi_tether_checkbox_text">Portable Wi\u2011Fi hotspot</string>
+    <!-- Label for Wifi tether checkbox. Toggles Access Point on/off  [CHAR LIMIT=30] -->
+    <string name="wifi_hotspot_checkbox_text">Wi\u2011Fi hotspot</string>
+    <!-- Label for Wifi tether checkbox summary. Toggles Access Point on/off  [CHAR LIMIT=40] -->
+    <string name="wifi_hotspot_checkbox_text_summary">Use cellular connection to provide Wi\u2011Fi network</string>
     <!-- Summary text when turning hotspot on -->
     <string name="wifi_tether_starting">Turning hotspot on\u2026</string>
     <!-- Summary text when turning hotspot off -->
@@ -1644,6 +1788,10 @@
     <string name="wifi_tether_failed_subtext">Portable Wi\u2011Fi hotspot error</string>
     <!-- Used to open the ssid and security dialog for Wifi Access Point -->
     <string name="wifi_tether_configure_ap_text">Set up Wi\u2011Fi hotspot</string>
+    <!-- Used to open the ssid and security dialog for Wifi Access Point.  [CHAR LIMIT=30]-->
+    <string name="wifi_hotspot_configure_ap_text">Wi\u2011Fi hotspot setup</string>
+    <!-- Summary Used to open the ssid and security dialog for Wifi Access Point.  [CHAR LIMIT=40] -->
+    <string name="wifi_hotspot_configure_ap_text_summary">AndroidAP WPA2 PSK portable Wi\u2011Fi 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\u2011Fi hotspot</string>
     <!-- Default access point SSID used for tethering -->
@@ -1857,6 +2005,8 @@
     <string name="accelerometer_summary_off" product="default">Switch orientation automatically when rotating phone</string>
     <!-- Sound & display settings screen, setting option name to change brightness level -->
     <string name="brightness">Brightness level</string>
+    <!-- Sound & display settings screen, setting option name to change brightness level [CHAR LIMIT=30] -->
+    <string name="brightness_title">Brightness</string>
     <!-- Sound & display settings screen, setting option summary to change brightness level -->
     <string name="brightness_summary">Adjust the brightness of the screen</string>
     <!-- Sound & display settings screen, setting option name to enable adaptive brightness [CHAR LIMIT=30] -->
@@ -1865,6 +2015,8 @@
     <string name="auto_brightness_summary">Optimize brightness level for available light</string>
     <!-- Sound & display settings screen, setting option name to change screen timeout -->
     <string name="screen_timeout">Sleep</string>
+    <!-- Sound & display settings screen, setting option name to change screen timeout [CHAR LIMIT=30] -->
+    <string name="screen_timeout_title">Screen turns off</string>
     <!-- Sound & display settings screen, setting option summary to change screen timeout -->
     <string name="screen_timeout_summary">After <xliff:g id="timeout_description">%1$s</xliff:g> of inactivity</string>
     <!-- Wallpaper settings title [CHAR LIMIT=30] -->
@@ -1900,88 +2052,91 @@
     <!-- [CHAR LIMIT=40] Sound & display settings screen, title of dialog for picking font size -->
     <string name="dialog_title_font_size">Font size</string>
 
-    <!-- SIM lock settings title -->
+    <!-- SIM lock settings title  [CHAR LIMIT=40] -->
     <string name="sim_lock_settings">SIM card lock settings</string>
-    <!-- Security & location settings screen, setting option name -->
+    <!-- Security & location settings screen, setting option name  [CHAR LIMIT=40] -->
     <string name="sim_lock_settings_category">Set up SIM card lock</string>
-    <!-- Security & location settings screen, section heading for settings related to sim card locking -->
+    <!-- Security & location settings screen, section heading for settings related to sim card locking  [CHAR LIMIT=40] -->
     <string name="sim_lock_settings_title">SIM card lock</string>
-    <!-- SIM card lock settings screen, setting check box label -->
+    <!-- SIM card lock settings screen, setting check box label  [CHAR LIMIT=40] -->
     <string name="sim_pin_toggle">Lock SIM card</string>
-    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected -->
+    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected  [CHAR LIMIT=40] -->
     <string name="sim_lock_on" product="tablet">Require PIN to use tablet</string>
-    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected -->
+    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected  [CHAR LIMIT=40] -->
     <string name="sim_lock_on" product="default">Require PIN to use phone</string>
-    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear -->
+    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear  [CHAR LIMIT=40] -->
     <string name="sim_lock_off" product="tablet">Require PIN to use tablet</string>
-    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear -->
+    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear  [CHAR LIMIT=40] -->
     <string name="sim_lock_off" product="default">Require PIN to use phone</string>
-    <!-- SIM card lock settings screen, setting option name to change the SIM PIN -->
+    <!-- SIM card lock settings screen, setting option name to change the SIM PIN  [CHAR LIMIT=40] -->
     <string name="sim_pin_change">Change SIM PIN</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
     <string name="sim_enter_pin">SIM PIN</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
     <string name="sim_enable_sim_lock">Lock SIM card</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
     <string name="sim_disable_sim_lock">Unlock SIM card</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
     <string name="sim_enter_old">Old SIM PIN</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
     <string name="sim_enter_new">New SIM PIN</string>
-    <string name="sim_reenter_new">Re-type new PIN</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
+    <!-- SIM card lock settings screen, Re-type new PIN.  [CHAR LIMIT=40] -->
+    <string name="sim_reenter_new">Re\u2011type new PIN</string>
+    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
     <string name="sim_change_pin">SIM PIN</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered  [CHAR LIMIT=40] -->
     <string name="sim_bad_pin">Incorrect PIN</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match -->
+    <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match  [CHAR LIMIT=40] -->
     <string name="sim_pins_dont_match">PINs don\'t match</string>
-    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
+    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN  [CHAR LIMIT=40] -->
     <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-->
+    <!-- SIM card lock settings screen, SIM PIN dialog message when the entered PIN is correct [CHAR LIMIT=40] -->
     <string name="sim_change_succeeded">SIM PIN changed successfully</string>
-    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
+    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN [CHAR LIMIT=40] -->
     <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: -->
+    <!-- SIM card lock settings screen, SIM PIN dialog button labels: [CHAR LIMIT=40] -->
     <string name="sim_enter_ok">OK</string>
-    <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
+    <!-- SIM card lock settings screen, SIM PIN dialog button labels: [CHAR LIMIT=40] -->
     <string name="sim_enter_cancel">Cancel</string>
+    <!-- Multiple SIMs found title.  [CHAR LIMIT=40] -->
+    <string name="sim_multi_sims_title">Multiple SIMs found</string>
+    <!-- Multiple SIMs found summary.  [CHAR LIMIT=100] -->
+    <string name="sim_multi_sims_summary">Choose the SIM you prefer for cellular data.</string>
 
     <!-- Instructions telling the user that they entered the wrong SIM PIN for the last time.
-         Displayed in a dialog box.  -->
+         Displayed in a dialog box.  [CHAR LIMIT=100] -->
     <string name="wrong_pin_code_pukked">Incorrect SIM PIN code you must now contact your carrier to unlock your device.</string>
-    <!-- Instructions telling the user that they entered the wrong SIM PIN while trying
-         to unlock the keyguard.  Displayed in a dialog box.  -->
+    <!-- Instructions telling the user that they entered the wrong SIM PIN while trying to unlock the keyguard.  Displayed in a dialog box.  [CHAR LIMIT=100] -->
     <plurals name="wrong_pin_code">
         <item quantity="one">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempt before you must contact your carrier to unlock your device.</item>
         <item quantity="other">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempts.</item>
     </plurals>
-    <!-- Instructions telling the user that the operation to unlock the keyguard
-         with SIM PIN failed. Displayed in one line in a large font.  -->
+    <!-- Instructions telling the user that the operation to unlock the keyguard with SIM PIN failed. Displayed in one line in a large font.  [CHAR LIMIT=40] -->
     <string name="pin_failed">SIM PIN operation failed!</string>
 
-    <!-- Advanced (used for diagnostics) device info activity title -->
+    <!-- Advanced (used for diagnostics) device info activity title [CHAR LIMIT=40] -->
     <string name="device_info_settings" product="tablet">Tablet status</string>
-    <!-- Advanced (used for diagnostics) device info activity title -->
+    <!-- Advanced (used for diagnostics) device info activity title [CHAR LIMIT=40] -->
     <string name="device_info_settings" product="default">Phone status</string>
 
-    <!-- About phone screen, list item title.  Takes the user to the screen for seeing and installing system updates. -->
+    <!-- About phone screen, list item title.  Takes the user to the screen for seeing and installing system updates. [CHAR LIMIT=40] -->
     <string name="system_update_settings_list_item_title">System updates</string>
-    <!-- About phone screen, list item summary.  Takes the user to the screen for seeing and installing system updates. -->
+    <!-- About phone screen, list item summary.  Takes the user to the screen for seeing and installing system updates. [CHAR LIMIT=40] -->
     <string name="system_update_settings_list_item_summary">""</string>
 
-    <!-- About phone screen, status item label -->
+    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
     <string name="firmware_version">Android version</string>
-    <!-- About phone screen, status item label-->
+    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
     <string name="model_number">Model number</string>
-    <!-- About phone screen, fcc equipment id label-->
+    <!-- About phone screen, fcc equipment id label  [CHAR LIMIT=40] -->
     <string name="fcc_equipment_id">Equipment ID</string>
-    <!-- About phone screen,  setting option name-->
+    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
     <string name="baseband_version">Baseband version</string>
-    <!-- About phone screen,  setting option name-->
+    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
     <string name="kernel_version">Kernel version</string>
-    <!-- About phone screen,  setting option name-->
+    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
     <string name="build_number">Build number</string>
-    <!-- About phone screen,  setting option name-->
+    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
     <string name="selinux_status">SELinux status</string>
 
     <!-- About phone screen, show when a value of some status item is unavailable. -->
@@ -2021,11 +2176,11 @@
     <!-- About phone, status item title.  The ICCID of the current LTE device. [CHAR LIMIT=30] -->
     <string name="status_icc_id">ICCID</string>
     <!-- About phone, status item title for the type of data phone network we're connected to, for example 3G or Edge or GPRS -->
-    <string name="status_network_type">Mobile network type</string>
+    <string name="status_network_type">Cellular network type</string>
     <!-- About phone, status item title for the latest area info cell broadcast received (Brazil only). -->
     <string name="status_latest_area_info">Operator info</string>
     <!-- About phone, status item title. The status of data access.  For example, the value may be "Connected" -->
-    <string name="status_data_state">Mobile network state</string>
+    <string name="status_data_state">Cellular network state</string>
     <!-- About phone, status item title. The status of whether we have service.  for example, the value may be "In service" -->
     <string name="status_service_state">Service state</string>
     <!-- About phone, status item title. The  current cell tower signal strength -->
@@ -2255,6 +2410,8 @@
     <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 [CHAR LIMIT=30] -->
+    <string name="device_reset_title">Reset device</string>
     <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading -->
     <string name="master_clear_title">Factory data reset</string>
     <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
@@ -2358,6 +2515,8 @@
     <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 unavailable subtext - shown when USB is not connected -->
+    <string name="usb_tethering_turnon_subtext">Connect to turn on</string>
     <!-- USB errored subtext - shown when USB is broken for some reason -->
     <string name="usb_tethering_errored_subtext">USB tethering error</string>
 
@@ -2377,6 +2536,8 @@
     <!-- Bluetooth connected subtext - shown when multiple devices are tethered over Bluetooth [CHAR LIMIT=60]-->
     <string name="bluetooth_tethering_devices_connected_subtext" product="default">Sharing this phone\'s Internet connection to <xliff:g id="connectedDeviceCount">%1$d</xliff:g> devices</string>
     <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=50]-->
+    <string name="bluetooth_tethering_off_subtext_config">Sharing this <xliff:g id="device_name">%1$d</xliff:g>\'s Internet connection</string>
+    <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=50]-->
     <string name="bluetooth_tethering_off_subtext" product="tablet">Not sharing this tablet\'s Internet connection</string>
     <!-- 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>
@@ -2391,7 +2552,7 @@
     <string name="tethering_help_button_text">Help</string>
 
     <!-- Wireless controls, item title to go into the network settings -->
-    <string name="network_settings_title">Mobile networks</string>
+    <string name="network_settings_title">Cellular networks</string>
 
     <!-- Mobile plan [CHAR LIMIT=35]-->
     <string name="manage_mobile_plan_title" translatable="true">Mobile plan</string>
@@ -2446,14 +2607,14 @@
     <!-- [CHAR LIMIT=30] Location mode screen, screen title -->
     <string name="location_mode_screen_title">Location mode</string>
     <!-- [CHAR LIMIT=130] Location mode screen, description for high accuracy mode -->
-    <string name="location_mode_high_accuracy_description">Use GPS, Wi\u2011Fi, and mobile networks to determine location </string>
+    <string name="location_mode_high_accuracy_description">Use GPS, Wi\u2011Fi, and cellular networks to determine location </string>
     <!-- [CHAR LIMIT=130] Location mode screen, description for battery saving mode -->
-    <string name="location_mode_battery_saving_description">Use Wi\u2011Fi and mobile networks to determine location</string>
+    <string name="location_mode_battery_saving_description">Use Wi\u2011Fi and cellular networks to determine location</string>
     <!-- [CHAR LIMIT=130] Location mode screen, description for sensors only mode -->
     <string name="location_mode_sensors_only_description">Use GPS to determine your location</string>
 
     <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for Google location service (cell ID, wifi, etc.) -->
-    <string name="location_network_based">Wi\u2011Fi &amp; mobile network location</string>
+    <string name="location_network_based">Wi\u2011Fi &amp; cellular network location</string>
     <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary for Google location service check box-->
     <string name="location_neighborhood_level">Let apps use Google\'s location service to estimate your location faster. Anonymous location data will be collected and sent to Google.</string>
     <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary when Use wireless networks check box is selected, for wifi-only devices -->
@@ -2623,6 +2784,10 @@
     <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 title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  [CHAR LIMIT=30] -->
+    <string name="install_applications_title">Allow all app sources</string>
+    <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  [CHAR LIMIT=65] -->
+    <string name="install_unknown_applications_title">Lets you install apps from sources other than Google Play</string>
     <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  -->
     <string name="install_unknown_applications">Allow installation of apps from unknown sources</string>
     <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
@@ -3619,7 +3784,7 @@
     <!-- [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 -->
-    <string name="battery_stats_phone_signal_label">Mobile network signal</string>
+    <string name="battery_stats_phone_signal_label">Cellular network signal</string>
     <!-- Battery usage during last unplugged period -->
     <string name="battery_stats_last_duration">@string/menu_stats_last_unplugged</string>
     <!-- CPU awake time title -->
@@ -4134,6 +4299,8 @@
     <string name="backup_configure_account_title">Backup account</string>
     <!-- Default summary text of the "Configure backup account" setting [CHAR LIMIT=80]-->
     <string name="backup_configure_account_default_summary">No account is currently storing backed up data</string>
+    <!-- Auto-restore menu title [CHAR LIMIT=30] -->
+    <string name="include_app_data_title">Include app data</string>
     <!-- Auto-restore menu title -->
     <string name="auto_restore_title">Automatic restore</string>
     <!-- Summary text of the "automatic restore" setting -->
@@ -4584,6 +4751,18 @@
 
     <!-- Activity title for network data usage summary. [CHAR LIMIT=25] -->
     <string name="data_usage_summary_title">Data usage</string>
+    <!-- Activity title for Appk data usage summary. [CHAR LIMIT=25] -->
+    <string name="data_usage_app_summary_title">App data usage</string>
+    <!-- Message about carrier data accounting.  [CHAR LIMIT=100] -->
+    <string name="data_usage_accounting">Carrier data accounting may differ from your device.</string>
+    <!-- Title for app usage. [CHAR LIMIT=40] -->
+    <string name="data_usage_app">App usage</string>
+    <!-- Title for app usage. [CHAR LIMIT=40] -->
+    <string name="data_usage_app_info_label">APP INFO</string>
+    <!-- Title for cellular data usage. [CHAR LIMIT=40] -->
+    <string name="data_usage_cellular_data">Cellular data</string>
+    <!-- Title for setting data limit. [CHAR LIMIT=40] -->
+    <string name="data_usage_data_limit">Set data limit</string>
     <!-- Title for option to pick visible time range from a list available usage periods. [CHAR LIMIT=25] -->
     <string name="data_usage_cycle">Data usage cycle</string>
     <!-- Title for checkbox menu option to enable mobile data when roaming. [CHAR LIMIT=26] -->
@@ -4593,7 +4772,7 @@
     <!-- Title for checkbox menu option to show 4G mobile data usage separate from other mobile data usage. [CHAR LIMIT=26] -->
     <string name="data_usage_menu_split_4g">Separate 4G usage</string>
     <!-- Title for checkbox menu option to show Wi-Fi data usage. [CHAR LIMIT=26] -->
-    <string name="data_usage_menu_show_wifi">Show Wi\u2011Fi usage</string>
+    <string name="data_usage_menu_show_wifi">Show Wi\u2011Fi</string>
     <!-- Title for checkbox menu option to show Ethernet data usage. [CHAR LIMIT=26] -->
     <string name="data_usage_menu_show_ethernet">Show Ethernet usage</string>
     <!-- Title for menu option to configure metered networks. [CHAR LIMIT=26] -->
@@ -4616,9 +4795,9 @@
     <string name="data_usage_app_restricted">restricted</string>
 
     <!-- Body of dialog shown to request confirmation that mobile data will be disabled. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_disable_mobile">Disable mobile data?</string>
+    <string name="data_usage_disable_mobile">Turn off cellular data?</string>
     <!-- Checkbox label that will disable mobile network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
-    <string name="data_usage_disable_mobile_limit">Set mobile data limit</string>
+    <string name="data_usage_disable_mobile_limit">Set cellular data limit</string>
     <!-- Checkbox label that will disable 4G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
     <string name="data_usage_disable_4g_limit">Set 4G data limit</string>
     <!-- Checkbox label that will disable 2G-3G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
@@ -4631,38 +4810,42 @@
     <!-- 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] -->
-    <string name="data_usage_tab_mobile">Mobile</string>
+    <string name="data_usage_tab_mobile">Cellular</string>
     <!-- Tab title for showing 4G data usage. [CHAR LIMIT=10] -->
     <string name="data_usage_tab_4g">4G</string>
     <!-- Tab title for showing 2G and 3G data usage. [CHAR LIMIT=10] -->
     <string name="data_usage_tab_3g">2G-3G</string>
 
     <!-- Title shown when current operation applies to mobile networks. [CHAR LIMIT=10] -->
-    <string name="data_usage_list_mobile">Mobile</string>
+    <string name="data_usage_list_mobile">Cellular</string>
     <!-- Title shown when current operation applies to no networks. [CHAR LIMIT=10] -->
     <string name="data_usage_list_none">None</string>
 
     <!-- Toggle switch title for enabling all mobile data network connections. [CHAR LIMIT=32] -->
-    <string name="data_usage_enable_mobile">Mobile data</string>
+    <string name="data_usage_enable_mobile">Cellular data</string>
     <!-- Toggle switch title for enabling 2G and 3G data network connections. [CHAR LIMIT=32] -->
     <string name="data_usage_enable_3g">2G-3G data</string>
     <!-- Toggle switch title for enabling 4G data network connection. [CHAR LIMIT=32] -->
     <string name="data_usage_enable_4g">4G data</string>
 
+    <!-- Data Usage Foreground label.  [CHAR LIMIT=40] -->
+    <string name="data_usage_forground_label">Foreground:</string>
+    <!-- Data Usage Background label.  [CHAR LIMIT=40] -->
+    <string name="data_usage_forground_label">Background:</string>
     <!-- Button title for launching application-specific data usage settings. [CHAR LIMIT=32] -->
     <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>
+    <string name="data_usage_app_restrict_background">Restrict app 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 networks. Non-mobile networks will be used if available.</string>
+    <string name="data_usage_app_restrict_background_summary">Disable background data on cellular networks.</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>
+    <string name="data_usage_app_restrict_background_summary_disabled">To restrict background data for this app, first set a cellular 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 only mobile networks are available.\n\nYou can find more appropriate data usage controls in the settings available 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 only cellular networks are 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>
+    <string name="data_usage_restrict_denied_dialog">Restricting background data is possible only when you\'ve set a cellular data limit.</string>
     <!--  Title of dialog shown when user enables global auto sync [CHAR LIMIT=32] -->
     <string name="data_usage_auto_sync_on_dialog_title">Turn auto-sync data on?</string>
     <!--  Body of dialog shown when user enables global auto sync, for tablet [CHAR LIMIT=none] -->
@@ -4689,18 +4872,18 @@
     <!-- 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_mobile" product="tablet">Your mobile data connection will be disabled when the specified limit is reached.\n\nSince data usage is measured by your tablet, and your carrier may account for usage differently, consider using a conservative limit.</string>
+    <string name="data_usage_limit_dialog_mobile" product="tablet">Your tablet will turn off cellular data once it reaches the limit you set.\n\nSince data usage is measured by your tablet, and your carrier may account for usage differently, consider setting a conservative limit.</string>
     <!-- Body of dialog shown before user limits mobile data usage. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_limit_dialog_mobile" product="default">Your mobile data connection will be disabled when the specified limit is reached.\n\nSince data usage is measured by your phone, and your carrier may account for usage differently, consider using a conservative limit.</string>
+    <string name="data_usage_limit_dialog_mobile" product="default">Your phone will turn off cellular data once it reaches the limit you set.\n\nSince data usage is measured by your phone, and your carrier may account for usage differently, consider setting a conservative limit.</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 you\'re connected to a Wi\u2011Fi network.</string>
+    <string name="data_usage_restrict_background">If you restrict background cellular data, some apps and services won\'t work unless you\'re connected to Wi\u2011Fi.</string>
     <!-- Body of dialog shown before user restricts background data usage. This is for multiuser tablets. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_restrict_background_multiuser" product="tablet">If you restrict background mobile data, some apps and services won\'t work unless you\'re connected to a Wi\u2011Fi network.\n\nThis setting affects all users on this tablet.</string>
+    <string name="data_usage_restrict_background_multiuser" product="tablet">If you restrict background cellular data, some apps and services won\'t work unless you\'re connected to Wi\u2011Fi.\n\nThis setting affects all users on this tablet.</string>
     <!-- Body of dialog shown before user restricts background data usage. This is for multiuser phones. [CHAR LIMIT=NONE] -->
-    <string name="data_usage_restrict_background_multiuser" product="default">If you restrict background mobile data, some apps and services won\'t work unless you\'re connected to a Wi\u2011Fi network.\n\nThis setting affects all users on this phone.</string>
+    <string name="data_usage_restrict_background_multiuser" product="default">If you restrict background cellular data, some apps and services won\'t work unless you\'re connected to Wi\u2011Fi.\n\nThis setting affects all users on this phone.</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>
@@ -4726,7 +4909,7 @@
     <!-- Dialog body for selecting paid networks. [CHAR LIMIT=NONE] -->
     <string name="data_usage_metered_body">Select the Wi\u2011Fi networks which are mobile hotspots.  Apps can be restricted from using these networks when in the background.  Apps may also warn before using these networks for large downloads.</string>
     <!-- Header for list of mobile networks. [CHAR LIMIT=32] -->
-    <string name="data_usage_metered_mobile">Mobile networks</string>
+    <string name="data_usage_metered_mobile">Cellular networks</string>
     <!-- Header for list of Wi-Fi networks. [CHAR LIMIT=32] -->
     <string name="data_usage_metered_wifi">Wi\u2011Fi networks</string>
     <!-- Body text prompting user to enable Wi-Fi to configure metered networks. [CHAR LIMIT=64] -->
@@ -5002,6 +5185,8 @@
 
     <!-- NFC payment settings --><skip/>
     <string name="nfc_payment_settings_title">Tap &amp; pay</string>
+    <!-- Google Wallet label.  [CHAR LIMIT=40] --><skip/>
+    <string name="google_wallet">Google Wallet</string>
     <!-- String shown when there are no NFC payment applications installed -->
     <string name="nfc_payment_no_apps">Pay with just a tap</string>
     <!-- String shown before a checkbox, allowing the user to indicate that he wants foreground apps
@@ -5010,6 +5195,8 @@
     <!-- String shown when there are no NFC payment applications installed, clickable, pointing to
          a website to learn more-->
     <string name="nfc_payment_learn_more">Learn more</string>
+    <!-- NFC More... title.  [CHAR LIMIT=40] -->
+    <string name="nfc_more_title">More...</string>
     <string name="nfc_payment_menu_item_add_service">Find apps</string>
     <!-- Label for the dialog that is shown when the user is asked to set a
          preferred payment application -->
@@ -5030,7 +5217,7 @@
 
     <!--  Help URLs for some screens. Not specified here. Specified in product overlays --><skip/>
     <!-- Help menu label [CHAR LIMIT=20] -->
-    <string name="help_label">Help</string>
+    <string name="help_label">Help &amp; feedback</string>
     <!-- Help URL, WiFi [DO NOT TRANSLATE] -->
     <string name="help_url_wifi" translatable="false"></string>
     <!-- Help URL, Bluetooth [DO NOT TRANSLATE] -->
@@ -5071,8 +5258,45 @@
     <!-- User picture title [CHAR LIMIT=30] -->
     <string name="user_picture_title">Photo ID</string>
 
-    <!-- Cell Broadcast settings title [CHAR LIMIT=50] -->
-    <string name="cell_broadcast_settings">Cell broadcasts</string>
+    <!-- Extreme threats title.  [CHAR LIMIT=30] -->
+    <string name="extreme_threats_title">Extreme threats</string>
+    <!-- Extreme threats summary.  [CHAR LIMIT=60] -->
+    <string name="extreme_threats_summary">Receive alerts for extreme threats to life and property</string>
+    <!-- Severe threats title.  [CHAR LIMIT=30] -->
+    <string name="severe_threats_title">Severe threats</string>
+    <!-- Extreme threats summary.  [CHAR LIMIT=60] -->
+    <string name="severe_threats_summary">Receive alerts for severe threats to life and property</string>
+    <!-- Amber alerts title.  [CHAR LIMIT=30] -->
+    <string name="amber_alerts_title">AMBER alerts</string>
+    <!-- Amber alerts summary.  [CHAR LIMIT=60] -->
+    <string name="amber_alerts_summary">Receive bulletins about child abductions</string>
+    <!-- repeat title.  [CHAR LIMIT=30] -->
+    <string name="repeat_title">Repeat</string>
+
+    <!-- Call Manager enable settings title.  [CHAR LIMIT=50] -->
+    <string name="call_manager_enable_title">Enable Call Manager</string>
+    <!-- Call Manager enable settings summary.  [CHAR LIMIT=80] -->
+    <string name="call_manager_enable_summary">Allow this service to manage how your calls are made.</string>
+    <!-- Call Manager settings title.  [CHAR LIMIT=50] -->
+    <string name="call_manager_title">Call Manager</string>
+    <!-- Call Manager settings summary.  [CHAR LIMIT=50] -->
+    <string name="call_manager_summary">Hangouts</string>
+    <!-- Cell Broadcast settings title.  [CHAR LIMIT=50] -->
+    <string name="cell_broadcast_settings">Emergency broadcasts</string>
+    <!-- Network operators settings title.  [CHAR LIMIT=50] -->
+    <string name="network_operators_settings">Network operators</string>
+    <!-- Access point names title.  [CHAR LIMIT=50] -->
+    <string name="access_point_names">Access point names</string>
+    <!-- Enhaced 4G LTE Mode title.  [CHAR LIMIT=50] -->
+    <string name="enhanced_4g_lte_mode_title">Enhanced 4G LTE Mode</string>
+    <!-- Enhaced 4G LTE Mode summary.  [CHAR LIMIT=100] -->
+    <string name="enhanced_4g_lte_mode_summary">Use LTE data to enhance voice and communications (Recommended)</string>
+    <!-- Preferred network type title.  [CHAR LIMIT=50] -->
+    <string name="preferred_network_type_title">Preferred network type</string>
+    <!-- Preferred network type summary.  [CHAR LIMIT=100] -->
+    <string name="preferred_network_type_summary">LTE (recommended)</string>
+    <!-- Work SIM title.  [CHAR LIMIT=50] -->
+    <string name="work_sim_title">Work SIM</string>
 
     <!-- User app limits screen title [CHAR LIMIT=35] -->
     <string name="user_restrictions_title">Application and content restrictions</string>
@@ -5098,6 +5322,8 @@
     <!-- Restrictions title for allowing NFC transfers [CHAR LIMIT=35] -->
     <string name="restriction_nfc_enable_title">NFC</string>
     <!-- Restrictions summary for allowing NFC transfers (tablet) [CHAR LIMIT=100] -->
+    <string name="restriction_nfc_enable_summary_config">Allow data exchange when this <xliff:g id="device_name">%1$s</xliff:g> touches another NFC device</string>
+    <!-- Restrictions summary for allowing NFC transfers (tablet) [CHAR LIMIT=100] -->
     <string name="restriction_nfc_enable_summary" product="tablet">Allow data exchange when the tablet touches another device</string>
     <!-- Restrictions summary for allowing NFC transfers (phone) [CHAR LIMIT=100] -->
     <string name="restriction_nfc_enable_summary" product="default">Allow data exchange when the phone touches another device</string>
@@ -5121,6 +5347,70 @@
     <!-- Text to display in regulatory info screen (from device overlay). -->
     <string name="regulatory_info_text"></string>
 
+    <!-- Title for SIM card settings during Setup Wizard.  [CHAR LIMIT=40] -->
+    <string name="sim_setup_wizard_title">SIM cards</string>
+    <!-- Title for SIM settings title settings during Setup Wizard.  [CHAR LIMIT=40] -->
+    <string name="sim_settings_title">SIM cards</string>
+    <!-- Message that SIM cards have changed.  [CHAR LIMIT=40] -->
+    <string name="sim_cards_changed_message">SIM cards have changed</string>
+    <!-- Message smmary that SIM cards have changed.  [CHAR LIMIT=60] -->
+    <string name="sim_cards_changed_message_summary">Touch to set activities</string>
+    <!-- Message that Cellular data is unavailable.  [CHAR LIMIT=40] -->
+    <string name="sim_cellular_data_unavailable">Cellular data is unavailable</string>
+    <!-- Message summary that Cellular data is unavailable.  [CHAR LIMIT=60] -->
+    <string name="sim_cellular_data_unavailable_summary">Touch to select a data SIM</string>
+    <!-- Checkbox to always use for calles.  [CHAR LIMIT=40] -->
+    <string name="sim_calls_always_use">Always use this for calls</string>
+    <!-- Title for selecting a SIM card.  [CHAR LIMIT=40] -->
+    <string name="sim_select_card">Select a SIM card</string>
+    <!-- Label for a numbered SIM card.  [CHAR LIMIT=40] -->
+    <string name="sim_card_number_title">SIM <xliff:g id="card_number">%1$d</xliff:g></string>
+    <!-- Name label of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_editor_name">SIM name</string>
+    <!-- Title label of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_editor_title">SIM card</string>
+    <!-- Carrier label of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_editor_carrier">Carrier</string>
+    <!-- Number label of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_editor_number">Number</string>
+    <!-- Color label of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_editor_color">SIM color</string>
+    <!-- Display label numbers of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_editor_num_format">Display numbers</string>
+    <!-- Select label Title of Sim Editor.  [CHAR LIMIT=40] -->
+    <string name="sim_card_select_title">Select SIM card</string>
+    <!-- Orange label.  [CHAR LIMIT=40] -->
+    <string name="color_orange">Orange</string>
+    <!-- Purple label.  [CHAR LIMIT=40] -->
+    <string name="color_purple">Purple</string>
+    <!-- Message informing the user that no SIM card is inserted  [CHAR LIMIT=60] -->
+    <string name="sim_no_inserted_msg">No SIM cards inserted</string>
+    <!-- SIM status title  [CHAR LIMIT=40] -->
+    <string name="sim_status_title">SIM status</string>
+    <!-- SIM status summary [CHAR LIMIT=60] -->
+    <string name="sim_status_summary">SIM related information</string>
+    <!-- Title for call back. [CHAR LIMIT=60] -->
+    <string name="sim_call_back_title">Call back from default SIM</string>
+    <!-- Title for outgoing back. [CHAR LIMIT=60] -->
+    <string name="sim_outgoing_call_title">SIM for outgoing calls</string>
+    <!-- Title for other call settings. [CHAR LIMIT=60] -->
+    <string name="sim_other_call_settings">Other call settings</string>
+    <!-- Preferred Network offload title.  [CHAR LIMIT=25] -->
+    <string name="preferred_network_offload_title">Preferred network Offload</string>
+    <!-- Preferred Network offload Header.  [CHAR LIMIT=25] -->
+    <string name="preferred_network_offload_header">Disable Network Name Broadcast</string>
+    <!-- Preferred Network offload Footer.  [CHAR LIMIT=100] -->
+    <string name="preferred_network_offload_footer">Disable Network Name Broadcast protects from third parties getting access to your network information.</string>
+    <!-- Preferred Network offload Popup.  [CHAR LIMIT=100] -->
+    <string name="preferred_network_offload_popup">Disabling Network Name Broadcast will prevent automatic connection to hidden networks.</string>
+
+    <!-- This is a divider in the SIM cards preferences that is the header of various settings where the user chooses which SIM to use for phone calls, data, and SMS messages [CHAR LIMIT=50] -->
+    <string name="sim_pref_divider">Activities</string>
+    <!-- When a user chooses this "Ask first" preference for the SIM to use for phone calls, they'll be prompted to choose a SIM every time they initiate a call [CHAR LIMIT=50] -->
+    <string name="sim_calls_ask_first_prefs_title">Ask first</string>
+    <!-- When a SIM preference hasn't been selected yet, this string is displayed as the pref summary until the user chooses a SIM subscription from the preference list [CHAR LIMIT=50] -->
+    <string name="sim_selection_required_pref">Selection required</string>
+
     <!--Dashboard strings-->
     <!-- Text to describe the dashboard fragment title [CHAR LIMIT=16] -->
     <string name="dashboard_title">Settings</string>
diff --git a/res/values/themes.xml b/res/values/themes.xml
index 4e80612..8142bb5 100644
--- a/res/values/themes.xml
+++ b/res/values/themes.xml
@@ -35,6 +35,7 @@
         <item name="switchBarMarginStart">0dip</item>
         <item name="switchBarMarginEnd">0dip</item>
         <item name="wifi_signal">@drawable/wifi_signal_dark</item>
+        <item name="dashboardBackgroundColor">@color/dashboard_background_color</item>
     </style>
 
     <style name="SetupWizardWifiTheme.Light" parent="android:Theme.Material.Light.NoActionBar">
@@ -51,6 +52,7 @@
         <item name="switchBarMarginStart">0dip</item>
         <item name="switchBarMarginEnd">0dip</item>
         <item name="wifi_signal">@drawable/wifi_signal_light</item>
+        <item name="dashboardBackgroundColor">@color/dashboard_background_color</item>
     </style>
 
     <style name="Theme.WifiDialog" parent="@*android:style/Theme.Material.Dialog.Alert">
@@ -94,6 +96,7 @@
 
         <item name="switchBarMarginStart">@dimen/switchbar_margin_start</item>
         <item name="switchBarMarginEnd">@dimen/switchbar_margin_end</item>
+        <item name="dashboardBackgroundColor">@color/dashboard_background_color</item>
 
         <!-- Redefine the ActionBar style for contentInsetStart -->
         <item name="android:actionBarStyle">@style/Theme.ActionBar</item>
@@ -161,4 +164,9 @@
         <item name="android:actionBarStyle">@style/Theme.ActionBar</item>
     </style>
 
+    <style name="Theme.NotificationStation" parent="@android:style/Theme.Material">
+        <item name="switchBarMarginStart">0dip</item>
+        <item name="switchBarMarginEnd">0dip</item>
+        <item name="dashboardBackgroundColor">@android:color/transparent</item>
+    </style>
 </resources>
diff --git a/src/com/android/settings/Settings.java b/src/com/android/settings/Settings.java
index ada1b0d..895e9ea 100644
--- a/src/com/android/settings/Settings.java
+++ b/src/com/android/settings/Settings.java
@@ -40,6 +40,7 @@
     public static class SpellCheckersSettingsActivity extends SettingsActivity { /* empty */ }
     public static class LocalePickerActivity extends SettingsActivity { /* empty */ }
     public static class UserDictionarySettingsActivity extends SettingsActivity { /* empty */ }
+    public static class HomeSettingsActivity extends SettingsActivity { /* empty */ }
     public static class DisplaySettingsActivity extends SettingsActivity { /* empty */ }
     public static class DeviceInfoSettingsActivity extends SettingsActivity { /* empty */ }
     public static class ApplicationSettingsActivity extends SettingsActivity { /* empty */ }
diff --git a/src/com/android/settings/SettingsActivity.java b/src/com/android/settings/SettingsActivity.java
index e2aeaf2..087540b 100644
--- a/src/com/android/settings/SettingsActivity.java
+++ b/src/com/android/settings/SettingsActivity.java
@@ -239,6 +239,7 @@
             SpellCheckersSettings.class.getName(),
             UserDictionaryList.class.getName(),
             UserDictionarySettings.class.getName(),
+            HomeSettings.class.getName(),
             DisplaySettings.class.getName(),
             DeviceInfoSettings.class.getName(),
             ManageApplications.class.getName(),
diff --git a/src/com/android/settings/inputmethod/InputMethodAndSubtypeEnabler.java b/src/com/android/settings/inputmethod/InputMethodAndSubtypeEnabler.java
index 51f5e14..2819d93 100644
--- a/src/com/android/settings/inputmethod/InputMethodAndSubtypeEnabler.java
+++ b/src/com/android/settings/inputmethod/InputMethodAndSubtypeEnabler.java
@@ -28,7 +28,6 @@
 import android.preference.PreferenceCategory;
 import android.preference.PreferenceScreen;
 import android.text.TextUtils;
-import android.util.Log;
 import android.view.inputmethod.InputMethodInfo;
 import android.view.inputmethod.InputMethodManager;
 import android.view.inputmethod.InputMethodSubtype;
@@ -45,16 +44,15 @@
 import java.util.List;
 
 public class InputMethodAndSubtypeEnabler extends SettingsPreferenceFragment {
-    private static final String TAG = InputMethodAndSubtypeEnabler.class.getSimpleName();
-    private AlertDialog mDialog = null;
     private boolean mHaveHardKeyboard;
-    final private HashMap<String, List<Preference>> mInputMethodAndSubtypePrefsMap =
+    private final HashMap<String, List<Preference>> mInputMethodAndSubtypePrefsMap =
             new HashMap<>();
-    final private HashMap<String, CheckBoxPreference> mAutoSelectionPrefsMap = new HashMap<>();
+    private final HashMap<String, CheckBoxPreference> mAutoSelectionPrefsMap = new HashMap<>();
     private InputMethodManager mImm;
     // TODO: Change mInputMethodInfoList to Map
     private List<InputMethodInfo> mInputMethodInfoList;
-    private String mInputMethodId;
+    private Collator mCollator;
+    private AlertDialog mDialog = null;
 
     @Override
     public void onCreate(final Bundle icicle) {
@@ -67,11 +65,22 @@
         // single Activity (see InputMethodAndSubtypeEnablerActivity). It should be available
         // from a preference argument when the preference is launched as a part of the other
         // Activity (like a right pane of 2-pane Settings app)
-        mInputMethodId = getStringExtraFromIntentOrArguments(
+        final String targetImi = getStringExtraFromIntentOrArguments(
                 android.provider.Settings.EXTRA_INPUT_METHOD_ID);
 
         mInputMethodInfoList = mImm.getInputMethodList();
-        setPreferenceScreen(createPreferenceHierarchy());
+        mCollator = Collator.getInstance();
+
+        final PreferenceScreen root = getPreferenceManager().createPreferenceScreen(getActivity());
+        final int imiCount = mInputMethodInfoList.size();
+        for (int index = 0; index < imiCount; ++index) {
+            final InputMethodInfo imi = mInputMethodInfoList.get(index);
+            // Add subtype preferences of this IME when it is specified or no IME is specified.
+            if (imi.getId().equals(targetImi) || TextUtils.isEmpty(targetImi)) {
+                addInputMethodSubtypePreferences(imi, root);
+            }
+        }
+        setPreferenceScreen(root);
     }
 
     private String getStringExtraFromIntentOrArguments(final String name) {
@@ -102,97 +111,104 @@
                 .getInstance(getActivity()).refreshAllInputMethodAndSubtypes();
         InputMethodAndSubtypeUtil.loadInputMethodSubtypeList(
                 this, getContentResolver(), mInputMethodInfoList, mInputMethodAndSubtypePrefsMap);
-        updateAutoSelectionCB();
+        updateAutoSelectionPreferences();
     }
 
     @Override
     public void onPause() {
         super.onPause();
         // Clear all subtypes of all IMEs to make sure
-        clearImplicitlyEnabledSubtypes(null);
+        updateImplicitlyEnabledSubtypes(null /* targetImiId */, false /* check */);
         InputMethodAndSubtypeUtil.saveInputMethodSubtypeList(this, getContentResolver(),
                 mInputMethodInfoList, mHaveHardKeyboard);
     }
 
+    // TODO: Stop overriding this method. Instead start using {@link OnPreferenceChangedListener}.
     @Override
     public boolean onPreferenceTreeClick(final PreferenceScreen preferenceScreen,
             final Preference preference) {
+        if (!(preference instanceof CheckBoxPreference)) {
+            return super.onPreferenceTreeClick(preferenceScreen, preference);
+        }
+        final CheckBoxPreference chkPref = (CheckBoxPreference) preference;
 
-        if (preference instanceof CheckBoxPreference) {
-            final CheckBoxPreference chkPref = (CheckBoxPreference) preference;
-
-            for (final String imiId : mAutoSelectionPrefsMap.keySet()) {
-                if (mAutoSelectionPrefsMap.get(imiId) == chkPref) {
-                    // We look for the first preference item in subtype enabler.
-                    // The first item is used for turning on/off subtype auto selection.
-                    // We are in the subtype enabler and trying selecting subtypes automatically.
-                    setSubtypeAutoSelectionEnabled(imiId, chkPref.isChecked());
-                    return super.onPreferenceTreeClick(preferenceScreen, preference);
-                }
-            }
-
-            final String id = chkPref.getKey();
-            if (chkPref.isChecked()) {
-                InputMethodInfo selImi = null;
-                final int N = mInputMethodInfoList.size();
-                for (int i = 0; i < N; i++) {
-                    final InputMethodInfo imi = mInputMethodInfoList.get(i);
-                    if (id.equals(imi.getId())) {
-                        selImi = imi;
-                        if (InputMethodUtils.isSystemIme(imi)) {
-                            InputMethodAndSubtypeUtil.setSubtypesPreferenceEnabled(
-                                    this, mInputMethodInfoList, id, true);
-                            // This is a built-in IME, so no need to warn.
-                            return super.onPreferenceTreeClick(preferenceScreen, preference);
-                        }
-                        break;
-                    }
-                }
-                if (selImi == null) {
-                    return super.onPreferenceTreeClick(preferenceScreen, preference);
-                }
-                chkPref.setChecked(false);
-                if (mDialog == null) {
-                    mDialog = (new AlertDialog.Builder(getActivity()))
-                            .setTitle(android.R.string.dialog_alert_title)
-                            .setCancelable(true)
-                            .setPositiveButton(android.R.string.ok,
-                                    new DialogInterface.OnClickListener() {
-                                        @Override
-                                        public void onClick(DialogInterface dialog, int which) {
-                                            chkPref.setChecked(true);
-                                            InputMethodAndSubtypeUtil.setSubtypesPreferenceEnabled(
-                                                    InputMethodAndSubtypeEnabler.this,
-                                                    mInputMethodInfoList, id, true);
-                                        }
-
-                            })
-                            .setNegativeButton(android.R.string.cancel,
-                                    new DialogInterface.OnClickListener() {
-                                        @Override
-                                        public void onClick(DialogInterface dialog, int which) {
-                                        }
-
-                            })
-                            .create();
-                } else {
-                    if (mDialog.isShowing()) {
-                        mDialog.dismiss();
-                    }
-                }
-                mDialog.setMessage(getResources().getString(
-                        R.string.ime_security_warning,
-                        selImi.getServiceInfo().applicationInfo.loadLabel(getPackageManager())));
-                mDialog.show();
-            } else {
-                InputMethodAndSubtypeUtil.setSubtypesPreferenceEnabled(
-                        this, mInputMethodInfoList, id, false);
-                updateAutoSelectionCB();
+        for (final String imiId : mAutoSelectionPrefsMap.keySet()) {
+            if (mAutoSelectionPrefsMap.get(imiId) == chkPref) {
+                // We look for the first preference item in subtype enabler. The first item is used
+                // for turning on/off subtype auto selection. We are in the subtype enabler and
+                // trying selecting subtypes automatically.
+                setAutoSelectionSubtypesEnabled(imiId, chkPref.isChecked());
+                return super.onPreferenceTreeClick(preferenceScreen, preference);
             }
         }
+
+        final String id = chkPref.getKey();
+        // Turns off a subtype.
+        if (!chkPref.isChecked()) {
+            // TODO: Because no preference on this screen has {@link InputMethodInfo} id as a key,
+            // the following setSubtypesPreferenceEnabled call is effectively no-operation and
+            // can be removed.
+            InputMethodAndSubtypeUtil.setSubtypesPreferenceEnabled(
+                    this, mInputMethodInfoList, id, false);
+            updateAutoSelectionPreferences();
+            return super.onPreferenceTreeClick(preferenceScreen, preference);
+        }
+
+        // Turns on a subtype.
+        final InputMethodInfo imi = getInputMethodInfoById(id);
+        // TODO: Because no preference on this screen has {@link InputMethodInfo} id as a key,
+        // <code>imi</code> is always null and the following code can be removed.
+        if (imi == null) {
+            return super.onPreferenceTreeClick(preferenceScreen, preference);
+        }
+        // Turns on a system IME's subtype.
+        if (InputMethodUtils.isSystemIme(imi)) {
+            InputMethodAndSubtypeUtil.setSubtypesPreferenceEnabled(
+                    this, mInputMethodInfoList, id, true);
+            // This is a built-in IME, so no need to warn.
+            return super.onPreferenceTreeClick(preferenceScreen, preference);
+        }
+        // Turns on a 3rd party IME's subtype.
+        // Turns off a subtype before showing a security warning dialog.
+        chkPref.setChecked(false);
+        if (mDialog != null && mDialog.isShowing()) {
+            mDialog.dismiss();
+        }
+        final AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
+        builder.setCancelable(true);
+        builder.setTitle(android.R.string.dialog_alert_title);
+        final CharSequence label = imi.getServiceInfo().applicationInfo
+                .loadLabel(getPackageManager());
+        builder.setMessage(getString(R.string.ime_security_warning, label));
+        builder.setPositiveButton(android.R.string.ok, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(final DialogInterface dialog, final int which) {
+                // The user explicitly enable the subtype.
+                chkPref.setChecked(true);
+                InputMethodAndSubtypeUtil.setSubtypesPreferenceEnabled(
+                        InputMethodAndSubtypeEnabler.this, mInputMethodInfoList, id, true);
+            }
+        });
+        builder.setNegativeButton(android.R.string.cancel, new DialogInterface.OnClickListener() {
+            @Override
+            public void onClick(final DialogInterface dialog, final int which) {}
+        });
+        mDialog = builder.create();
+        mDialog.show();
         return super.onPreferenceTreeClick(preferenceScreen, preference);
     }
 
+    private InputMethodInfo getInputMethodInfoById(final String imiId) {
+        final int imiCount = mInputMethodInfoList.size();
+        for (int index = 0; index < imiCount; ++index) {
+            final InputMethodInfo imi = mInputMethodInfoList.get(index);
+            if (imi.getId().equals(imiId)) {
+                return imi;
+            }
+        }
+        return null;
+    }
+
     @Override
     public void onDestroy() {
         super.onDestroy();
@@ -202,173 +218,150 @@
         }
     }
 
-    private PreferenceScreen createPreferenceHierarchy() {
-        // Root
-        final PreferenceScreen root = getPreferenceManager().createPreferenceScreen(getActivity());
+    private void addInputMethodSubtypePreferences(final InputMethodInfo imi,
+            final PreferenceScreen root) {
         final Context context = getActivity();
+        final int subtypeCount = imi.getSubtypeCount();
+        if (subtypeCount <= 1) {
+            return;
+        }
+        final String imiId = imi.getId();
+        final PreferenceCategory keyboardSettingsCategory = new PreferenceCategory(context);
+        root.addPreference(keyboardSettingsCategory);
+        final PackageManager pm = getPackageManager();
+        final CharSequence label = imi.loadLabel(pm);
 
-        final Collator collator = Collator.getInstance();
-        final int N = (mInputMethodInfoList == null ? 0 : mInputMethodInfoList.size());
-        for (int i = 0; i < N; ++i) {
-            final InputMethodInfo imi = mInputMethodInfoList.get(i);
-            final int subtypeCount = imi.getSubtypeCount();
-            if (subtypeCount <= 1) {
-                continue;
-            }
-            final String imiId = imi.getId();
-            // Add this subtype to the list when no IME is specified or when the IME of this
-            // subtype is the specified IME.
-            if (!TextUtils.isEmpty(mInputMethodId) && !mInputMethodId.equals(imiId)) {
-                continue;
-            }
-            final PreferenceCategory keyboardSettingsCategory = new PreferenceCategory(context);
-            root.addPreference(keyboardSettingsCategory);
-            final PackageManager pm = getPackageManager();
-            final CharSequence label = imi.loadLabel(pm);
+        keyboardSettingsCategory.setTitle(label);
+        keyboardSettingsCategory.setKey(imiId);
+        // TODO: Use toggle Preference if images are ready.
+        final CheckBoxPreference autoSelectionPref = new CheckBoxPreference(context);
+        mAutoSelectionPrefsMap.put(imiId, autoSelectionPref);
+        keyboardSettingsCategory.addPreference(autoSelectionPref);
 
-            keyboardSettingsCategory.setTitle(label);
-            keyboardSettingsCategory.setKey(imiId);
-            // TODO: Use toggle Preference if images are ready.
-            final CheckBoxPreference autoCB = new CheckBoxPreference(context);
-            mAutoSelectionPrefsMap.put(imiId, autoCB);
-            keyboardSettingsCategory.addPreference(autoCB);
+        final PreferenceCategory activeInputMethodsCategory = new PreferenceCategory(context);
+        activeInputMethodsCategory.setTitle(R.string.active_input_method_subtypes);
+        root.addPreference(activeInputMethodsCategory);
 
-            final PreferenceCategory activeInputMethodsCategory = new PreferenceCategory(context);
-            activeInputMethodsCategory.setTitle(R.string.active_input_method_subtypes);
-            root.addPreference(activeInputMethodsCategory);
-
-            boolean isAutoSubtype = false;
-            CharSequence autoSubtypeLabel = null;
-            final ArrayList<Preference> subtypePreferences = new ArrayList<>();
-            if (subtypeCount > 0) {
-                for (int j = 0; j < subtypeCount; ++j) {
-                    final InputMethodSubtype subtype = imi.getSubtypeAt(j);
-                    if (subtype.overridesImplicitlyEnabledSubtype()) {
-                        if (!isAutoSubtype) {
-                            isAutoSubtype = true;
-                            autoSubtypeLabel = subtype.getDisplayName(context,
-                                    imi.getPackageName(), imi.getServiceInfo().applicationInfo);
-                        }
-                    } else {
-                        final CheckBoxPreference chkbxPref = new InputMethodSubtypePreference(
-                                context, subtype, imi);
-                        subtypePreferences.add(chkbxPref);
-                    }
-                }
-                Collections.sort(subtypePreferences, new Comparator<Preference>() {
-                    @Override
-                    public int compare(Preference lhs, Preference rhs) {
-                        if (lhs instanceof InputMethodSubtypePreference) {
-                            return ((InputMethodSubtypePreference)lhs).compareTo(rhs, collator);
-                        }
-                        return lhs.compareTo(rhs);
-                    }
-                });
-                for (int j = 0; j < subtypePreferences.size(); ++j) {
-                    activeInputMethodsCategory.addPreference(subtypePreferences.get(j));
-                }
-                mInputMethodAndSubtypePrefsMap.put(imiId, subtypePreferences);
-            }
-            if (isAutoSubtype) {
-                if (TextUtils.isEmpty(autoSubtypeLabel)) {
-                    Log.w(TAG, "Title for auto subtype is empty.");
-                    autoCB.setTitle("---");
-                } else {
-                    autoCB.setTitle(autoSubtypeLabel);
+        CharSequence autoSubtypeLabel = null;
+        final ArrayList<Preference> subtypePreferences = new ArrayList<>();
+        for (int index = 0; index < subtypeCount; ++index) {
+            final InputMethodSubtype subtype = imi.getSubtypeAt(index);
+            if (subtype.overridesImplicitlyEnabledSubtype()) {
+                if (autoSubtypeLabel == null) {
+                    autoSubtypeLabel = subtype.getDisplayName(
+                            context, imi.getPackageName(), imi.getServiceInfo().applicationInfo);
                 }
             } else {
-                autoCB.setTitle(R.string.use_system_language_to_select_input_method_subtypes);
+                final Preference subtypePref = new InputMethodSubtypePreference(
+                        context, subtype, imi);
+                subtypePreferences.add(subtypePref);
             }
         }
-        return root;
+        Collections.sort(subtypePreferences, new Comparator<Preference>() {
+            @Override
+            public int compare(final Preference lhs, final Preference rhs) {
+                if (lhs instanceof InputMethodSubtypePreference) {
+                    return ((InputMethodSubtypePreference) lhs).compareTo(rhs, mCollator);
+                }
+                return lhs.compareTo(rhs);
+            }
+        });
+        final int prefCount = subtypePreferences.size();
+        for (int index = 0; index < prefCount; ++index) {
+            final Preference pref = subtypePreferences.get(index);
+            activeInputMethodsCategory.addPreference(pref);
+        }
+        mInputMethodAndSubtypePrefsMap.put(imiId, subtypePreferences);
+        if (TextUtils.isEmpty(autoSubtypeLabel)) {
+            autoSelectionPref.setTitle(
+                    R.string.use_system_language_to_select_input_method_subtypes);
+        } else {
+            autoSelectionPref.setTitle(autoSubtypeLabel);
+        }
     }
 
-    private boolean isNoSubtypesExplicitlySelected(String imiId) {
-        boolean allSubtypesOff = true;
+    private boolean isNoSubtypesExplicitlySelected(final String imiId) {
         final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
         for (final Preference pref : subtypePrefs) {
             if (pref instanceof CheckBoxPreference && ((CheckBoxPreference)pref).isChecked()) {
-                allSubtypesOff = false;
-                break;
+                return false;
             }
         }
-        return allSubtypesOff;
+        return true;
     }
 
-    private void setSubtypeAutoSelectionEnabled(String imiId, boolean autoSelectionEnabled) {
-        final CheckBoxPreference autoSelectionCB = mAutoSelectionPrefsMap.get(imiId);
-        if (autoSelectionCB == null) {
+    private void setAutoSelectionSubtypesEnabled(final String imiId,
+            final boolean autoSelectionEnabled) {
+        final CheckBoxPreference autoSelectionPref = mAutoSelectionPrefsMap.get(imiId);
+        if (autoSelectionPref == null) {
             return;
         }
-        autoSelectionCB.setChecked(autoSelectionEnabled);
+        autoSelectionPref.setChecked(autoSelectionEnabled);
         final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
-        for (final Preference subtypePref : subtypePrefs) {
-            if (subtypePref instanceof CheckBoxPreference) {
+        for (final Preference pref : subtypePrefs) {
+            if (pref instanceof CheckBoxPreference) {
                 // When autoSelectionEnabled is true, all subtype prefs need to be disabled with
                 // implicitly checked subtypes. In case of false, all subtype prefs need to be
                 // enabled.
-                subtypePref.setEnabled(!autoSelectionEnabled);
+                pref.setEnabled(!autoSelectionEnabled);
                 if (autoSelectionEnabled) {
-                    ((CheckBoxPreference)subtypePref).setChecked(false);
+                    ((CheckBoxPreference)pref).setChecked(false);
                 }
             }
         }
         if (autoSelectionEnabled) {
             InputMethodAndSubtypeUtil.saveInputMethodSubtypeList(
                     this, getContentResolver(), mInputMethodInfoList, mHaveHardKeyboard);
-            setCheckedImplicitlyEnabledSubtypes(imiId);
+            updateImplicitlyEnabledSubtypes(imiId, true /* check */);
         }
     }
 
-    private void setCheckedImplicitlyEnabledSubtypes(String targetImiId) {
-        updateImplicitlyEnabledSubtypes(targetImiId, true);
-    }
-
-    private void clearImplicitlyEnabledSubtypes(String targetImiId) {
-        updateImplicitlyEnabledSubtypes(targetImiId, false);
-    }
-
-    private void updateImplicitlyEnabledSubtypes(String targetImiId, boolean check) {
+    private void updateImplicitlyEnabledSubtypes(final String targetImiId, final boolean check) {
         // When targetImiId is null, apply to all subtypes of all IMEs
         for (final InputMethodInfo imi : mInputMethodInfoList) {
             final String imiId = imi.getId();
-            if (targetImiId != null && !targetImiId.equals(imiId)) {
-                continue;
-            }
-            final CheckBoxPreference autoCB = mAutoSelectionPrefsMap.get(imiId);
+            final CheckBoxPreference autoSelectionPref = mAutoSelectionPrefsMap.get(imiId);
             // No need to update implicitly enabled subtypes when the user has unchecked the
             // "subtype auto selection".
-            if (autoCB == null || !autoCB.isChecked()) {
+            if (autoSelectionPref == null || !autoSelectionPref.isChecked()) {
                 continue;
             }
-            final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
-            final List<InputMethodSubtype> implicitlyEnabledSubtypes =
-                    mImm.getEnabledInputMethodSubtypeList(imi, true);
-            if (subtypePrefs == null || implicitlyEnabledSubtypes == null) {
+            if (imiId.equals(targetImiId) || targetImiId == null) {
+                updateImplicitlyEnabledSubtypesOf(imi, check);
+            }
+        }
+    }
+
+    private void updateImplicitlyEnabledSubtypesOf(final InputMethodInfo imi, final boolean check) {
+        final String imiId = imi.getId();
+        final List<Preference> subtypePrefs = mInputMethodAndSubtypePrefsMap.get(imiId);
+        final List<InputMethodSubtype> implicitlyEnabledSubtypes =
+                mImm.getEnabledInputMethodSubtypeList(imi, true);
+        if (subtypePrefs == null || implicitlyEnabledSubtypes == null) {
+            return;
+        }
+        for (final Preference pref : subtypePrefs) {
+            if (!(pref instanceof CheckBoxPreference)) {
                 continue;
             }
-            for (final Preference subtypePref : subtypePrefs) {
-                if (subtypePref instanceof CheckBoxPreference) {
-                    final CheckBoxPreference cb = (CheckBoxPreference)subtypePref;
-                    cb.setChecked(false);
-                    if (check) {
-                        for (final InputMethodSubtype subtype : implicitlyEnabledSubtypes) {
-                            String implicitlyEnabledSubtypePrefKey = imiId + subtype.hashCode();
-                            if (cb.getKey().equals(implicitlyEnabledSubtypePrefKey)) {
-                                cb.setChecked(true);
-                                break;
-                            }
-                        }
+            final CheckBoxPreference subtypePref = (CheckBoxPreference)pref;
+            subtypePref.setChecked(false);
+            if (check) {
+                for (final InputMethodSubtype subtype : implicitlyEnabledSubtypes) {
+                    final String implicitlyEnabledSubtypePrefKey = imiId + subtype.hashCode();
+                    if (subtypePref.getKey().equals(implicitlyEnabledSubtypePrefKey)) {
+                        subtypePref.setChecked(true);
+                        break;
                     }
                 }
             }
         }
     }
 
-    private void updateAutoSelectionCB() {
+    private void updateAutoSelectionPreferences() {
         for (final String imiId : mInputMethodAndSubtypePrefsMap.keySet()) {
-            setSubtypeAutoSelectionEnabled(imiId, isNoSubtypesExplicitlySelected(imiId));
+            setAutoSelectionSubtypesEnabled(imiId, isNoSubtypesExplicitlySelected(imiId));
         }
-        setCheckedImplicitlyEnabledSubtypes(null);
+        updateImplicitlyEnabledSubtypes(null /* targetImiId */, true /* check */);
     }
 }
diff --git a/src/com/android/settings/location/LocationSettings.java b/src/com/android/settings/location/LocationSettings.java
index 184c387..474a857 100644
--- a/src/com/android/settings/location/LocationSettings.java
+++ b/src/com/android/settings/location/LocationSettings.java
@@ -73,7 +73,6 @@
 
         mSwitchBar = activity.getSwitchBar();
         mSwitch = mSwitchBar.getSwitch();
-        mSwitchBar.addOnSwitchChangeListener(this);
         mSwitchBar.show();
     }
 
@@ -81,7 +80,6 @@
     public void onDestroyView() {
         super.onDestroyView();
 
-        mSwitchBar.removeOnSwitchChangeListener(this);
         mSwitchBar.hide();
     }
 
@@ -94,6 +92,7 @@
     public void onResume() {
         super.onResume();
         createPreferenceHierarchy();
+        mSwitchBar.addOnSwitchChangeListener(this);
         mValidListener = true;
     }
 
@@ -105,6 +104,7 @@
             // Ignore exceptions caused by race condition
         }
         super.onPause();
+        mSwitchBar.removeOnSwitchChangeListener(this);
         mValidListener = false;
     }
 
