<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- Strings for Dialog yes button -->
    <string name="yes">"Yes"</string>

    <!-- Strings for Dialog no button -->
    <string name="no">"No"</string>

    <!-- Strings for Dialog create button -->
    <string name="create">Create</string>

    <!-- Device Info --> <skip />
    <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
    <string name="device_info_default">Unknown</string>

    <!-- 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. 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. System (Updates, data, accessibility, about phone). [CHAR LIMIT=40] -->
    <string name="header_category_system">SYSTEM</string>

    <!-- Phone info -->
    <!-- Phone Info screen. Button label to turn on the radio . Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="turn_on_radio">Turn on radio</string>
    <!-- Phone Info screen. Button label to turn off the radio . Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="turn_off_radio">Turn off radio</string>

    <!-- Phone SMS over IMS on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="sms_over_ims_on">Turn on SMS over IMS</string>
    <!-- Phone SMS over IMS off. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="sms_over_ims_off">Turn off SMS over IMS</string>

    <!-- Phone SMS over IMS IMS registration required on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="ims_reg_required_on">Turn on IMS registration required</string>
    <!-- Phone IMS registration required off. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="ims_reg_required_off">Turn off IMS registration required</string>

    <!-- Phone ram dump on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="lte_ram_dump_on">Turn on lte ram dump</string>
    <!-- Phone ram dump off. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="lte_ram_dump_off">Turn off lte ram dump</string>

    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewADN">View SIM address book</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewFDN">View Fixed Dialing Numbers</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewSDN">View Service Dialing Numbers</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_getPDP">Get PDP list</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_in">In service</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_out">Out of service</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_emergency">Emergency calls only</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_off">Radio off</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_roaming_in">Roaming</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_roaming_not">Not roaming</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_phone_idle">Idle</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_phone_ringing">Ringing</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_phone_offhook">Call in progress</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_disconnected">Disconnected</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_connecting">Connecting</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_connected">Connected</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_suspended">Suspended</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_unknown">unknown</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_packets">pkts</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_bytes">bytes</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_dbm">dBm</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_asu">asu</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_lac">LAC</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_cid">CID</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed. Unmounts the SD card from the phone, meaning it will become available for an attached computer  [CHAR LIMIT=25] -->
    <string name="sdcard_unmount" product="nosdcard">Unmount USB storage</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed. Unmounts the SD card from the phone, meaning it will become available for an attached computer  -->
    <string name="sdcard_unmount" product="default">Unmount SD card</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed. Formats the SD card in the phone, meaning it will be erased and reformatted [CHAR LIMIT=25] -->
    <string name="sdcard_format" product="nosdcard">Erase USB storage</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed. Formats the SD card in the phone, meaning it will be erased and reformatted -->
    <string name="sdcard_format" product="default">Erase SD card</string>

    <!-- choice for the font size spinner -->
    <string name="small_font">Small</string>
    <!-- choice for the font size spinner -->
    <string name="medium_font">Medium</string>
    <!-- choice for the font size spinner -->
    <string name="large_font">Large</string>

    <!-- Do not translate. label for font size preview.  Does not need to be translated. -->
    <string name="font_size_preview_text">Servez à ce monsieur une bière et des kiwis.</string>
    <!-- Button. Chosen when they want to save the chosen text size. -->
    <string name="font_size_save">OK</string>

    <!-- Title for a notification shown. [CHAR LIMIT=25] -->
    <string name="sdcard_setting" product="nosdcard">USB storage</string>
    <!-- Title for a notification shown. -->
    <string name="sdcard_setting" product="default">SD card</string>

    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_label">Battery status:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_power_label">Power plug:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_scale_label">Battery scale:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_level_label">Battery level:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_label">Battery health:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_technology_label">Battery technology:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_voltage_label">Battery voltage:</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_voltage_units">mV</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_temperature_label">Battery temperature:</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_temperature_units">\u00B0 C</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_uptime">Time since boot:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_awake_battery">Awake time on battery:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_awake_plugged">Awake time when charging:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_screen_on">Screen ON time:</string>

    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_unknown">Unknown</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_charging">Charging</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_charging_ac">(AC)</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_charging_usb">(USB)</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_discharging">Discharging</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_not_charging">Not charging</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_full">Full</string>

    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_power_unplugged">Unplugged</string>
    <string name="battery_info_power_ac">AC</string>
    <string name="battery_info_power_usb">USB</string>
    <string name="battery_info_power_ac_usb">AC+USB</string>
    <string name="battery_info_power_unknown">Unknown</string>

    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_unknown">Unknown</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_good">Good</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_overheat">Overheat</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_dead">Dead</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_over_voltage">Over voltage</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_unspecified_failure">Unknown error</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_cold">Cold</string>

    <!-- Used as setting title (for checkbox) on second screen after selecting Bluetooth settings -->
    <string name="bluetooth">Bluetooth</string>
    <!-- Bluetooth settings screen, check box label when the Bluetooth device can be seen by others -->
    <string name="bluetooth_visibility">Discoverable</string>
    <!-- Bluetooth settings screen, summary after selecting Discoverable check box [CHAR LIMIT=50] -->
    <string name="bluetooth_is_discoverable">Visible to all nearby Bluetooth devices (<xliff:g id="discoverable_time_period">%1$s</xliff:g>)</string>
    <!-- Bluetooth settings screen, summary when Discoverable duration is set to "forever" [CHAR LIMIT=50] -->
    <string name="bluetooth_is_discoverable_always">Visible to all nearby Bluetooth devices</string>
    <!-- Bluetooth settings screen, summary text when not discoverable and no paired devices [CHAR LIMIT=50] -->
    <string name="bluetooth_not_visible_to_other_devices">Not visible to other Bluetooth devices</string>
    <!-- Bluetooth settings screen, summary text when not discoverable with paired devices [CHAR LIMIT=50] -->
    <string name="bluetooth_only_visible_to_paired_devices">Only visible to paired devices</string>
    <!-- Bluetooth settings screen, Discoverable checkbox summary text -->
    <string name="bluetooth_not_discoverable">Make device discoverable</string>
    <!-- Bluetooth settings screen, option name to pick discoverability timeout duration (a list dialog comes up) -->
    <string name="bluetooth_visibility_timeout">Visibility timeout</string>
    <!-- Bluetooth settings screen, Discoverable timout list dialog summary text -->
    <string name="bluetooth_visibility_timeout_summary">Set how long device will be discoverable</string>
    <!-- Bluetooth settings screen, check box label whether or not to allow
        bluetooth voice dialing when lock screen is up-->
    <string name="bluetooth_lock_voice_dialing">Lock voice dialing</string>
    <!-- Bluetooth settings screen, lock voice dialing checkbox summary text -->
    <string name="bluetooth_lock_voice_dialing_summary">
      Prevent use of the bluetooth dialer when the screen is locked
    </string>
    <!-- Bluetooth settings screen, heading above the list of nearby bluetooth devices -->
    <string name="bluetooth_devices">Bluetooth devices</string>
    <!-- Bluetooth settings screen, title for the current bluetooth name setting -->
    <string name="bluetooth_device_name">Device name</string>
    <!-- Bluetooth settings screen, image description for device details button. This opens the screen to rename, unpair, etc. a single device. -->
    <string name="bluetooth_device_details">Device settings</string>
    <!-- Bluetooth settings screen, image description for profile of a device details button. -->
    <string name="bluetooth_profile_details">Profile settings</string>
    <!-- Bluetooth settings screen, summary text when there isn't a name set (for the name setting) -->
    <string name="bluetooth_name_not_set">No name set, using account name</string>
    <!-- Bluetooth settings screen, menu item to scan for nearby bluetooth devices -->
    <string name="bluetooth_scan_for_devices">Scan for devices</string>
    <!-- Bluetooth settings screen, menu item to change this device's Bluetooth name. [CHAR LIMIT=30] -->
    <string name="bluetooth_rename_device" product="tablet">Rename tablet</string>
    <!-- Bluetooth settings screen, menu item to change this device's Bluetooth name. [CHAR LIMIT=30] -->
    <string name="bluetooth_rename_device" product="default">Rename phone</string>
    <!-- Bluetooth settings screen, confirmation button for rename device dialog. [CHAR LIMIT=20] -->
    <string name="bluetooth_rename_button">Rename</string>
    <!-- Bluetooth settings.  Dialog title to confirm disconnecting from all profiles of a device. [CHAR LIMIT=30] -->
    <string name="bluetooth_disconnect_title">Disconnect?</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles">This will end your connection with:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b></string>

    <!-- Bluetooth settings.  Dialog title to disable a single profile of a device. [CHAR LIMIT=40] -->
    <string name="bluetooth_disable_profile_title">Disable profile?</string>
    <!-- Bluetooth settings.  Message for disabling a profile of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disable_profile_message">This will disable:&lt;br>&lt;b><xliff:g id="profile_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>From:&lt;br>&lt;b><xliff:g id="device_name">%2$s</xliff:g>&lt;/b></string>

    <!-- Bluetooth settings.  Message when connected to a device. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected">Connected</string>
    <!-- Bluetooth settings.  Message when connected to a device, except for phone audio. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_headset">Connected (no phone)</string>
    <!-- Bluetooth settings.  Message when connected to a device, except for media audio. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_a2dp">Connected (no media)</string>
    <!-- Bluetooth settings.  Message when connected to a device, except for phone/media audio. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_headset_no_a2dp">Connected (no phone or media)</string>
    <!-- Bluetooth settings.  Message when a device is disconnected -->
    <string name="bluetooth_disconnected">Disconnected</string>
    <!-- Bluetooth settings.  Message when disconnecting from a device -->
    <string name="bluetooth_disconnecting">Disconnecting\u2026</string>
    <!-- Bluetooth settings.  Message when connecting to a device -->
    <string name="bluetooth_connecting">Connecting\u2026</string>
    <!-- Bluetooth settings.  Message when the device state is unknown -->
    <string name="bluetooth_unknown" />
    <!--Bluetooth settings screen, summary text under individual Bluetooth devices when pairing -->
    <string name="bluetooth_pairing">Pairing\u2026</string>
    <!--Bluetooth settings screen, summary text for Bluetooth device with no name -->
    <string name="bluetooth_device">Unnamed Bluetooth device</string>
    <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices -->
    <string name="progress_scanning">Searching</string>
    <!--Bluetooth settings screen, text that appears when scanning for devices is finished and no nearby bluetooth device was found [CHAR LIMIT=40]-->
    <string name="bluetooth_no_devices_found">No nearby Bluetooth devices were found.</string>
    <!-- Notification ticker text (shown in the status bar) when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_ticker">Bluetooth pairing request</string>
    <!-- Notification title when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_title">Pairing request</string>
    <!-- Notification message when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_message">Touch to pair with <xliff:g id="device_name">%1$s</xliff:g>.</string>
    <!-- Bluetooth settings screen, menu to show the list of received files [CHAR LIMIT=30] -->
    <string name="bluetooth_show_received_files">Show received files</string>

    <!-- Strings for BluetoothDevicePicker -->
    <string name="device_picker">Bluetooth device chooser</string>

    <!-- Strings for dialog title when asking to the user whether to allow an app to enable discovery mode -->
    <string name="bluetooth_permission_request">"Bluetooth permission request"</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth -->
    <string name="bluetooth_ask_enablement">"An app wants to turn on Bluetooth. Allow?"</string>

    <!-- Strings for asking to the user whether to allow an app to enable discovery mode -->
    <string name="bluetooth_ask_discovery" product="tablet">"An app on your tablet wants to make your tablet discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>
    <!-- Strings for asking to the user whether to allow an app to enable discovery mode -->
    <string name="bluetooth_ask_discovery" product="default">"An app on your phone wants to make your phone discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>

    <!-- Strings for asking to the user whether to allow an app to enable lasting discovery mode  -->
    <string name="bluetooth_ask_lasting_discovery" product="tablet">"An app on your tablet wants to make your tablet \u201calways discoverable\u201d by other Bluetooth devices. Allow?"</string>
    <string name="bluetooth_ask_lasting_discovery" product="default">"An app on your phone wants to make your phone \u201calways discoverable\u201d by other Bluetooth devices. Allow?"</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet">"An app on your tablet wants to turn on Bluetooth and make your tablet discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
    <string name="bluetooth_ask_enablement_and_discovery" product="default">"An app on your phone wants to turn on Bluetooth and make your phone discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Allow?"</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet">"An app on your tablet wants to turn on Bluetooth and make your tablet discoverable by other devices. Allow?"</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default">"An app on your phone wants to turn on Bluetooth and make your phone discoverable by other devices. Allow?"</string>

    <!-- Strings for msg to display to user while bluetooth is turning on [CHAR LIMIT=60] -->
    <string name="bluetooth_turning_on">"Turning Bluetooth on\u2026"</string>

    <!-- Strings for msg to display to user while bluetooth is turning off [CHAR LIMIT=60] -->
    <string name="bluetooth_turning_off">"Turning Bluetooth off\u2026"</string>

    <!-- Strings for device profile auto connect setting -->
    <string name="bluetooth_auto_connect">Auto-connect</string>

    <!-- Activity label of BluetoothPermissionActivity [CHAR LIMIT=none]-->
    <string name="bluetooth_connection_permission_request">"Bluetooth connection request"</string>

    <!-- Notification message when a remote Bluetooth device wants to connect to a Bluetooth profile [CHAR LIMIT=none]-->
    <string name="bluetooth_connection_notif_message">"Touch to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022."</string>

    <!-- Bluetooth connection permission Alert Activity text [CHAR LIMIT=none]-->
    <string name="bluetooth_connection_dialog_text">"Do you want to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022?"</string>

    <!-- Activity label of BluetoothPbPermissionActivity, also used as Strings in the permission dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_phonebook_request">"Phone book request"</string>

    <!-- Bluetooth phone book permission Alert Activity text [CHAR LIMIT=none] -->
    <string name="bluetooth_pb_acceptance_dialog_text">%1$s wants to access your contacts and call history. Give access to %2$s?</string>

    <!-- Bluetooth phone book permission Alert Activity checkbox text [CHAR LIMIT=none] -->
    <string name="bluetooth_pb_remember_choice">Don\'t ask again</string>

    <!-- Date & time settings screen title -->
    <string name="date_and_time">Date &amp; time settings</string>
    <!-- Date/time settings.  Summary of the checkbox for choosing between 12 hour time or 24 hour time.  Sample of 12-hour time -->
    <string name="date_time_12_hour_sample">1:00 pm</string>
    <!-- Date/time settings.  Summary of the checkbox for choosing between 12 hour time or 24 hour time.  Sample of 24-hour time -->
    <string name="date_time_24_hour_sample">13:00</string>
    <!-- The title of the activity to pick a time zone. -->
    <string name="choose_timezone">Choose time zone</string>
    <!-- Do not translate. Used as the value for a setting. -->
    <string name="default_date_format"><xliff:g id="default_date_format">MM/dd/yyyy</xliff:g></string>

    <!-- The option in the date-format picker for using the normal format
         called for by the user's locale. -->
    <string name="normal_date_format">Regional (<xliff:g id="date" example="12-31-2009">%s</xliff:g>)</string>

    <!-- Label of preview text when tweaking font size -->
    <string name="display_preview_label">Preview:</string>
    <!-- Label for chosen font size -->
    <string name="display_font_size_label">Font size:</string>

    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_data_label"><xliff:g id="data">Data:</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_sendbroadcast_text">Send <xliff:g id="broadcast">broadcast</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_action_label"><xliff:g id="action">Action</xliff:g>:</string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_startactivity_text">Start <xliff:g id="activity">activity</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_resource_label"><xliff:g id="resource">Resource</xliff:g>: </string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_account_label">Account: </string>

    <!-- HTTP proxy settings title -->
    <string name="proxy_settings_title">Proxy settings</string>
    <!-- HTTP proxy settings. Button to clear the proxy box. -->
    <string name="proxy_clear_text">Clear</string>
    <!-- HTTP proxy settings. The port number label. -->
    <string name="proxy_port_label">Proxy port</string>
    <!-- HTTP proxy settings. The hint text field for port. -->
    <string name="proxy_port_hint" translatable="false">8080</string>
    <!-- HTTP proxy settings. The exclusion list label. -->
    <string name="proxy_exclusionlist_label">Bypass proxy for</string>
    <!-- HTTP proxy settings. The hint text for proxy exclusion list. [CHAR LIMIT=50]-->
    <string name="proxy_exclusionlist_hint">example.com,mycomp.test.com,localhost</string>
    <!-- HTTP proxy settings. The button to restore the defaults. -->
    <string name="proxy_defaultView_text">Restore defaults</string>
    <!-- HTTP proxy settings. The button to save. -->
    <string name="proxy_action_text">Done</string>
    <!-- HTTP proxy settings. The text field for the hostname -->
    <string name="proxy_hostname_label">Proxy hostname</string>
    <!-- HTTP proxy settings. The hint text field for the hostname. [CHAR LIMIT=50] -->
    <string name="proxy_hostname_hint">proxy.example.com</string>
    <!-- HTTP proxy settings. Title if there is an error-->
    <string name="proxy_error">Attention</string>
    <!-- HTTP proxy settings. Button to get rid of error box-->
    <string name="proxy_error_dismiss">OK</string>
    <!-- HTTP proxy settings. The error if the hostname is not valid -->
    <string name="proxy_error_invalid_host">The hostname you typed isn\'t valid.</string>
    <!-- HTTP proxy settings. The error if the exclusion list is not valid -->
    <string name="proxy_error_invalid_exclusion_list">The exclusion list you typed isn\'t properly formatted. Type a comma-separated list of excluded domains.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_port">You need to complete the port field.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_host_set_port">The port field must be empty if the host field is empty.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_invalid_port">The port you typed isn\'t valid.</string>
    <!-- HTTP proxy settings. Warning message about limited application support [CHAR LIMIT=100]-->
    <string name="proxy_warning_limited_support">The HTTP proxy is used by the browser but may not be used by the other apps.</string>

    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_location_label">Location:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_neighboring_location_label">Neighboring CID:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_attempts_label">Data attempts:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->

    <string name="radio_info_gprs_service_label">GPRS service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_roaming_label">Roaming:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_imei_label">IMEI:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_redirect_label">Call redirect:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_resets_label">Number of PPP reset since boot:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gsm_disconnects_label">GSM disconnects:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_current_network_label">Current network:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_successes_label">Data successes:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_received_label">PPP received:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gsm_service_label">GSM service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_strength_label">Signal strength:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_status_label">Call status:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_sent_label">PPP sent:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_radio_resets_label">Radio resets:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_message_waiting_label">Message waiting:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_phone_number_label">Phone number:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_band_mode_label">Select radio band</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_network_type_label">Network type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_set_perferred_label">Set preferred network type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_ipaddr">Ping IpAddr:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_hostname">Ping Hostname(www.google.com):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_http_client_test">HTTP Client test:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="ping_test_label">Run ping test</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_label">SMSC:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_update_label">Update</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_refresh_label">Refresh</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_toggle_dns_check_label">Toggle DNS check</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="oem_radio_info_label">OEM-specific Info/Settings</string>

    <!-- Band Mode Selection -->
    <!-- Band mode screen.  Title of activity. -->
    <string name="band_mode_title">Set GSM/UMTS band</string>
    <!-- Band mode screen.  Loading message. -->
    <string name="band_mode_loading">Loading band list\u2026</string>
    <!-- Band mode screen. Button caption to set the bandmode. -->
    <string name="band_mode_set">Set</string>
    <!-- Band mode screen. Status message when unsuccessful. -->
    <string name="band_mode_failed">Unsuccessful</string>
    <!-- Band mode screen. Statusm essage when successful. -->
    <string name="band_mode_succeeded">Successful</string>

    <!-- Instructions after the user changes the mass storage settings -->
    <string name="sdcard_changes_instructions">Changes take effect when USB cable is reconnected.</string>
    <!-- Enable USB mass storage mode checkbox title -->
    <string name="sdcard_settings_screen_mass_storage_text">Enable USB mass storage</string>
    <!-- The label for total bytes on SD card -->
    <string name="sdcard_settings_total_bytes_label">Total bytes:</string>
    <!-- Message when there is no SD card present [CHAR LIMIT=30] -->
    <string name="sdcard_settings_not_present_status" product="nosdcard">USB storage not mounted.</string>
    <!-- Message when there is no SD card present -->
    <string name="sdcard_settings_not_present_status" product="default">No SD card.</string>
    <!-- Th label for the available (free) sapce on the SD card -->
    <string name="sdcard_settings_available_bytes_label">Available bytes:</string>
    <!-- Message when the SD card is being used by the computer as mass storage [CHAR LIMIT=30] -->
    <string name="sdcard_settings_mass_storage_status" product="nosdcard">USB storage is being used as a mass storage device.</string>
    <!-- Message when the SD card is being used by the computer as mass storage -->
    <string name="sdcard_settings_mass_storage_status" product="default">SD card is being used as a mass storage device.</string>
    <!-- Message when it is safe to remove the SD card [CHAR LIMIT=30] -->
    <string name="sdcard_settings_unmounted_status" product="nosdcard">It\'s now safe to remove the USB storage.</string>
    <!-- Message when it is safe to remove the SD card -->
    <string name="sdcard_settings_unmounted_status" product="default">It\'s now safe to remove the SD card.</string>
    <!-- Error message when the SD card was removed without properly unmounting [CHAR LIMIT=30] -->
    <string name="sdcard_settings_bad_removal_status" product="nosdcard">USB storage was removed while still in use!</string>
    <!-- Error message when the SD card was removed without properly unmounting -->
    <string name="sdcard_settings_bad_removal_status" product="default">SD card was removed while still in use!</string>
    <!-- Label for used bytes on the SD card -->
    <string name="sdcard_settings_used_bytes_label">Used bytes:</string>
    <!-- Message when it is scanning the SD card for new files [CHAR LIMIT=30]  -->
    <string name="sdcard_settings_scanning_status" product="nosdcard">Scanning USB storage for media\u2026</string>
    <!-- Message when it is scanning the SD card for new files -->
    <string name="sdcard_settings_scanning_status" product="default">Scanning SD card for media\u2026</string>
    <!-- Message when the SD card is mounted as read only [CHAR LIMIT=30] -->
    <string name="sdcard_settings_read_only_status" product="nosdcard">USB storage mounted read-only.</string>
    <!-- Message when the SD card is mounted as read only -->
    <string name="sdcard_settings_read_only_status" product="default">SD card mounted read-only.</string>
    <!-- SetupWizard strings used by DateTimeSettingsSetupWizard.  The button label for going to the next screen without storing the setting. [CHAR LIMIT=5] -->
    <string name="skip_label">Skip</string>
    <!-- SetupWizard strings used by DateTimeSettingsSetupWizard.  The button label for going to the next screen. -->
    <string name="next_label">Next</string>

    <!-- LocalePicker -->
    <!-- Title for the locale picker activity -->
    <string name="language_picker_title">Language</string>

    <!-- The title of the dialog to pick an activity.  This is shown when there are multiple activities that can do a particular action.  For example, suppose you click on the "Share" menu item in the Browser.  Since you can share the webpage URL via many communication methods, this dialog would come up with choices like "Email", "IM", etc.  This is a generic message, and the previous example is a single possible scenario (so please don't assume it's for the browser or anything :) ). -->
    <string name="activity_picker_label">Choose activity</string>
    <!-- Do not translate. -->
    <string name="debug_intent_sender_label">Debug intent sender</string>
    <!-- The title of the activity to see random device info. -->
    <string name="device_info_label">Device info</string>
    <!-- The title of the activity to see battery info. -->
    <string name="battery_info_label">Battery info</string>
    <!-- The title of the activity to adjust display settings -->
    <string name="display_label">Screen</string>
    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label" product="tablet">Tablet info</string>
    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label" product="default">Phone info</string>
    <!-- The title of the activity to adjust SD card settings [CHAR LIMIT=25] -->
    <string name="sd_card_settings_label" product="nosdcard">USB storage</string>
    <!-- The title of the activity to adjust SD card settings-->
    <string name="sd_card_settings_label" product="default">SD card</string>
    <!-- The title of the activity to adjust proxy settings -->
    <string name="proxy_settings_label">Proxy settings</string>

    <!-- ======================================================================================= -->
    <!-- NEW STUFF -->
    <!-- ======================================================================================= -->

    <!-- Button label for generic cancel action -->
    <string name="cancel">Cancel</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] -->
    <string name="settings_label_launcher">Settings</string>
    <!-- Label for option to select a settings panel as a shortcut -->
    <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">More\u2026</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-Fi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</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 -->
    <string name="roaming_enable">Connect to data services when roaming</string>
    <!-- mobile network settings screen, setting option summary text when check box is clear -->
    <string name="roaming_disable">Connect to data services when roaming</string>
    <!-- mobile network settings screen, dialog message when you are roaming and clear the "Data roaming" check box -->
    <string name="roaming_reenable_message">You have lost data connectivity because you left your home network with data roaming turned off.</string>
    <!-- mobile network settings screen, button on dialog box that appears when you are roaming and clear the "Data roaming" check box -->
    <string name="roaming_turn_it_on_button">Turn it on</string>
    <!-- mobile network settings screen, message in dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_warning">When you allow data roaming, you may incur significant roaming charges!</string>
    <!-- mobile network settings screen, title of dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_reenable_title">Allow data roaming?</string>
    <!-- mobile network settings screen, setting option name -->
    <string name="networks">Operator selection</string>
    <!-- mobile network settings screen, setting option summary text -->
    <string name="sum_carrier_select">Choose a network operator</string>

    <!-- Date and time settings --><skip />
    <!-- Main Settings screen setting option name to go into the date and time settings-->
    <string name="date_and_time_settings_title">Date &amp; time</string>
    <!-- Title for Date & Time settings screen in SetupWizard [CHAR LIMIT=40] -->
    <string name="date_and_time_settings_title_setup_wizard">Set date and time</string>
    <!-- Main Settings screen setting option summary text for the item to go into the date and time settings. -->
    <string name="date_and_time_settings_summary">Set date, time, time zone, &amp; formats</string>
    <!-- Date & time setting screen setting check box title if the date and time should be determined automatically [CHAR LIMIT=25] -->
    <string name="date_time_auto">Automatic date &amp; time</string>
    <!-- Date & time setting screen setting option summary text when Automatic check box is selected
        (that is, when date and time should be determined automatically) [CHAR LIMIT=100] -->
    <string name="date_time_auto_summaryOn">Use network-provided time</string>
    <!-- Date & time setting screen setting option summary text when Automatic check box is clear
        [CHAR LIMIT=100] -->
    <string name="date_time_auto_summaryOff">Use network-provided time</string>
    <!-- Date & time setting screen setting check box title if the time zone should be determined automatically [CHAR LIMIT=25] -->
    <string name="zone_auto">Automatic time zone</string>
    <!-- Date & time setting screen setting option summary text when Automatic time zone check box is selected (that is, when date and time should be determined automatically)
        [CHAR LIMIT=100]  -->
    <string name="zone_auto_summaryOn">Use network-provided time zone</string>
    <!-- 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 -->
    <string name="date_time_24hour">Use 24-hour format</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_time">Set time</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 -->
    <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.) -->
    <string name="date_time_date_format">Choose date format</string>
    <!-- Menu item on Select time zone screen -->
    <string name="zone_list_menu_sort_alphabetically">Sort alphabetically</string>
    <!-- Menu item on Select time zone screen -->
    <string name="zone_list_menu_sort_by_timezone">Sort by time zone</string>
    <!-- Title string shown above DatePicker, letting a user select system date
         [CHAR LIMIT=20] -->
    <string name="date_picker_title">Date</string>
    <!-- Title string shown above TimePicker, letting a user select system time
         [CHAR LIMIT=20] -->
    <string name="time_picker_title">Time</string>

    <!-- Security Settings --><skip />

    <!-- Security settings screen when using face unlock, setting option name to start an activity that allows the user to improve accuracy by adding additional enrollment faces -->
    <string name="biometric_weak_improve_matching_title">Improve face matching</string>
<!-- On the security settings screen when using face unlock.  This checkbox is used to toggle whether liveliness detection is required.  If it is checked the user must blink during unlock to prove it's not a photo  -->
    <string name="biometric_weak_liveliness_title">Liveness check</string>
    <!-- On the security settings screen when using face unlock.  The summary of the liveliness checkbox -->
    <string name="biometric_weak_liveliness_summary" msgid="7980026533493781616">Require eye blink while unlocking</string>

    <!-- Security settings screen, setting option name to change screen timeout -->
    <string name="lock_after_timeout">Automatically lock</string>
    <!-- Security settings screen, setting option summary to change screen timeout -->
    <string name="lock_after_timeout_summary"><xliff:g id="timeout_string">%1$s</xliff:g> after sleep</string>
    <!-- Text shown next to checkbox for showing owner info on LockScreen [CHAR LIMIT=50]-->
    <string name="show_owner_info_on_lockscreen_label">Show owner info on lock screen</string>
    <!-- Text shown for title of owner info setting [CHAR LIMIT=20]-->
    <string name="owner_info_settings_title">Owner info</string>
    <!-- Text shown for summary of owner info setting [CHAR LIMIT=40]-->
    <string name="owner_info_settings_summary"></string>
    <!-- Hint text shown in owner info edit text [CHAR LIMIT=50] -->
    <string name="owner_info_settings_edit_text_hint">Type text to display on the lock screen</string>
    <!-- Main Settings screen setting option title for the item to take you to the location screen -->
    <string name="location_settings_title">Location services</string>
    <!-- Main Settings screen setting option title for the item to take you to the security screen -->
    <string name="security_settings_title">Security</string>
    <!-- Main Settings screen setting option summary text for the item tot ake you to the security and location screen -->
    <string name="security_settings_summary">Set My Location, screen unlock, SIM card lock, credential storage lock</string>
    <!-- Main Settings screen setting option summary text for the item to take you to the CDMA security and location screen -->
    <string name="cdma_security_settings_summary">Set My Location, screen unlock, credential storage lock</string>
    <!-- In the security screen, the header title for settings related to  Passwords-->
    <string name="security_passwords_title">Passwords</string>

    <!-- Title of the preferences category for preference items to control encryption -->
    <string name="crypt_keeper_settings_title">Encryption</string>

    <!-- Title of the preferences item to control encryption -->
    <string name="crypt_keeper_encrypt_title" product="tablet">Encrypt tablet</string>
    <!-- Title of the preferences item to control encryption -->
    <string name="crypt_keeper_encrypt_title" product="default">Encrypt phone</string>

    <!-- Summary of the preferences item to control encryption, when encryption is inactive -->
    <string name="crypt_keeper_encrypt_summary" product="tablet">
    Require a numeric PIN or password to decrypt your tablet each time you
    power it on</string>
    <!-- Summary of the preferences item to control encryption, when encryption is inactive -->
    <string name="crypt_keeper_encrypt_summary" product="default">
    Require a numeric PIN or password to decrypt your phone each time you
    power it on</string>
    <!-- Summary of the preferences item to control encryption, when encryption is active -->
    <string name="crypt_keeper_encrypted_summary">Encrypted</string>

    <!-- Informational text in the first confirmation screen before starting device encryption -->
    <string name="crypt_keeper_desc" product="tablet">
    You can encrypt your accounts, settings, downloaded apps and their data,
    media, and other files. Once you encrypt your tablet, you need to type a numeric PIN
    or password to decrypt it each time you power it on. You can\'t decrypt your tablet
    except by performing a factory data reset, erasing all your data.\n\nEncryption takes
    an hour or more. You must start with a charged battery and keep your tablet plugged in
    until encryption is complete. If you interrupt the encryption process, you will lose
    some or all of your data.</string>
    <!-- Informational text in the first confirmation screen before starting device encryption -->
    <string name="crypt_keeper_desc" product="default">
    You can encrypt your accounts, settings, downloaded apps and their data,
    media, and other files. Once you encrypt your phone, you need to type a numeric PIN or
    password to decrypt it each time you power it on. You can\'t decrypt your phone
    except by performing a factory data reset, erasing all your data.\n\nEncryption takes
    an hour or more. You must start with a charged battery and keep your phone plugged in
    until encryption is complete. If you interrupt the encryption process, you will lose
    some or all of your data.</string>

    <!-- Button text to start encryption process -->
    <string name="crypt_keeper_button_text" product="tablet">Encrypt tablet</string>
    <!-- Button text to start encryption process -->
    <string name="crypt_keeper_button_text" product="default">Encrypt phone</string>

    <!-- Warning string that will be displayed when encryption cannot be started -->
    <string name="crypt_keeper_low_charge_text">Charge your battery and try again.</string>
    <!-- Warning string that will be displayed when encryption cannot be started -->
    <string name="crypt_keeper_unplugged_text">Plug in your charger and try again.</string>

    <!-- Dialog title, shown when encryption cannot proceed because a PIN/Password is needed -->
    <string name="crypt_keeper_dialog_need_password_title">No lock screen PIN or password</string>
    <!-- Dialog message, shown when encryption cannot proceed because a PIN/Password is needed -->
    <string name="crypt_keeper_dialog_need_password_message">You need to set a lock screen PIN or
    password before you can start encryption.</string>

    <!-- Title of the final confirmation screen before starting device encryption -->
    <string name="crypt_keeper_confirm_title">Encrypt?</string>
    <!-- Warning text in the final confirmation screen before starting device encryption -->
    <string name="crypt_keeper_final_desc" product="tablet">
    The encryption operation is irreversible and if you interrupt it, you\'ll lose data.
    Encryption takes an hour or more, during which the tablet will restart several times.
    </string>
    <!-- Warning text in the final confirmation screen before starting device encryption -->
    <string name="crypt_keeper_final_desc" product="default">
    The encryption operation is irreversible and if you interrupt it, you\'ll lose data.
    Encryption takes an hour or more, during which the phone will restart several times.
    </string>

    <!-- Title of the progress screen while encrypting the device -->
    <string name="crypt_keeper_setup_title">Encrypting</string>

    <!-- Informational text on the progress screen while encrypting the device -->
    <string name="crypt_keeper_setup_description" product="tablet">Wait while your tablet
    is being encrypted. <xliff:g id="percent" example="50">^1</xliff:g>% complete.</string>
    <!-- Informational text on the progress screen while encrypting the device -->
    <string name="crypt_keeper_setup_description" product="default">Wait while your phone
    is being encrypted. <xliff:g id="percent" example="50">^1</xliff:g>% complete.</string>

    <!-- Informational text on the password entry screen when password entry fails-->
    <string name="crypt_keeper_cooldown">Try again in <xliff:g id="delay" example="15">^1</xliff:g> seconds.</string>

    <!-- Informational text on the password entry screen prompting the user for their password -->
    <string name="crypt_keeper_enter_password">Type your password</string>

    <!-- Title of the encryption screen when encrypting the device failed -->
    <string name="crypt_keeper_failed_title">Encryption unsuccessful</string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_failed_summary" product="tablet">
      Encryption was interrupted and can\'t complete. As a result, the data on
      your tablet is no longer accessible.
      \n\n
      To resume using your tablet, you need to perform a factory reset.
      When you set up your tablet after the reset, you\'ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_failed_summary" product="default">
      Encryption was interrupted and can\'t complete. As a result, the data on
      your phone is no longer accessible.
      \n\nTo resume using your phone, you need to perform a factory reset.
      When you set up your phone after the reset, you\'ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Image button description to switch input method -->
    <string name="crypt_keeper_switch_input_method">Switch input method</string>

    <!-- Unlock Picker Settings --><skip />

    <!-- Security Picker --><skip />
    <!--  Title for security picker to choose the unlock method: None/Pattern/PIN/Password [CHAR LIMIT=22] -->
    <string name="lock_settings_picker_title">Choose screen lock</string>

    <!--  Title for security picker when choosing a facelock's backup unlock method: Pattern/PIN [CHAR LIMIT=22] -->
    <string name="backup_lock_settings_picker_title">Choose backup lock</string>

    <!--  Main Security lock settings --><skip />
    <!--  Title for PreferenceScreen to launch picker for security method when there is none [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_launch_picker_title">Screen lock</string>

    <!--  Title for PreferenceScreen to change security method: None/Pattern/PIN/Password [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_launch_picker_change_title">Change lock screen</string>

    <!--  Summary for PreferenceScreen to changeecurity method: None/Pattern/PIN/Password [CHAR LIMIT=45]  -->
    <string name="unlock_set_unlock_launch_picker_change_summary">Change or disable pattern, PIN, or password security</string>

    <!--  Summary for PreferenceScreen to changeecurity method: None/Pattern/PIN/Password [CHAR LIMIT=45]  -->
    <string name="unlock_set_unlock_launch_picker_enable_summary">Choose a method to lock the screen</string>

    <!-- Info explaining the backup lock which is used for facelock -->
    <string name="unlock_backup_info_summary">When Face Unlock can\'t see you, how do you want to unlock?</string>

    <!-- Title for preference that disables unlock security [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_off_title">None</string>
    <!-- Summary for preference that disables unlock security [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_off_summary"></string>

    <!-- Title for preference that disables unlock security [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_none_title">Slide</string>
    <!-- Summary for preference that disables unlock security [CHAR LIMIT=45]-->
    <string name="unlock_set_unlock_none_summary">No security</string>

    <!-- Title for preference that guides the user through a weak biometric lock [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_biometric_weak_title">Face Unlock</string>
    <!-- Summary for preference that disables unlock security [CHAR LIMIT=45]-->
    <string name="unlock_set_unlock_biometric_weak_summary">Low security, experimental</string>

    <!-- Title for preference that guides the user through creating an unlock pattern [CHAR LIMIT=22]-->
    <string name="unlock_set_unlock_pattern_title">Pattern</string>
    <!-- Summary for preference that guides the user through creating an unlock pattern [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_pattern_summary">Medium security</string>

    <!-- Title for preference that guides the user through creating an unlock PIN (Personal Identification Number) [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_pin_title">PIN</string>
    <!-- Summary for preference that guides the user through creating an unlock PIN (Personal Identification Number) [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_pin_summary">Medium to high security</string>

    <!-- Title for preference that guides the user through creating an unlock password [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_password_title">Password</string>
    <!-- Title for preference that guides the user through creating an unlock password [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_password_summary">High security</string>

    <!-- Summary for preference that has been disabled by because of the DevicePolicyAdmin, or because device encryption is enabled, or because there are credentials in the credential storage [CHAR LIMIT=50] -->
    <string name="unlock_set_unlock_disabled_summary">Disabled by administrator, encryption policy, or credential storage</string>

    <!-- Summary for "Configure lockscreen" when lock screen is off [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_off">None</string>
    <!-- Summary for "Configure lockscreen" when security is disabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_none">Slide</string>
    <!-- Summary for "Configure lockscreen" when security biometric weak is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_biometric_weak">Face Unlock</string>
    <!-- Summary for "Configure lockscreen" when security pattern is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_pattern">Pattern</string>
    <!-- Summary for "Configure lockscreen" when security PIN is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_pin">PIN</string>
    <!-- Summary for "Configure lockscreen" when security password is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_password">Password</string>

    <!-- Title for option to turn of password/pin/pattern unlock. [CHAR LIMIT=22] -->
    <string name="unlock_disable_lock_title">Turn off screen lock</string>

    <!-- Summary shown under unlock_disable_lock_title when pattern is in use and can be removed [CHAR LIMIT=45] -->
    <string name="unlock_disable_lock_pattern_summary">Remove unlock pattern</string>
    <!-- Summary shown under unlock_disable_lock_title when PIN is in use and can be removed [CHAR LIMIT=45]-->
    <string name="unlock_disable_lock_pin_summary">Remove unlock PIN</string>
    <!-- Summary shown under unlock_disable_lock_title when password is in use and can be removed [CHAR LIMIT=45]-->
    <string name="unlock_disable_lock_password_summary">Remove unlock password</string>

    <!-- Title shown on security settings to allow the user to change their lockscreen pattern [CHAR LIMIT=22] -->
    <string name="unlock_change_lock_pattern_title">Change unlock pattern</string>
    <!-- Title shown on security settings to allow the user to change their lockscreen PIN [CHAR LIMIT=22] -->
    <string name="unlock_change_lock_pin_title">Change unlock PIN</string>
    <!-- Title shown on security settings to allow the user to change their lockscreen password [CHAR LIMIT=22]-->
    <string name="unlock_change_lock_password_title">Change unlock password</string>

    <!-- Hint shown in dialog screen when password is too short -->
    <string name="lockpassword_password_too_short">Password must be at least %d characters</string>
    <!-- Hint shown in dialog screen when PIN is too short -->
    <string name="lockpassword_pin_too_short">PIN must be at least %d characters</string>

    <!-- Hint shown after minimum password criteria is met -->
    <string name="lockpassword_press_continue">Touch Continue when done</string>

    <!-- Hint shown after minimum password criteria is met -->
    <string name="lockpassword_continue_label">Continue</string>

    <!-- Error shown in popup when password is too long -->
    <string name="lockpassword_password_too_long">Password must be fewer than <xliff:g id="number" example="17">%d</xliff:g> characters.</string>
    <!-- Error shown in popup when PIN is too long -->
    <string name="lockpassword_pin_too_long">PIN must be fewer than <xliff:g id="number" example="17">%d</xliff:g> digits.</string>

    <!-- Error shown when in PIN mode and user enters a non-digit -->
    <string name="lockpassword_pin_contains_non_digits">PIN must contain only digits 0-9.</string>

    <!-- Error shown when in PIN mode and PIN has been used recently. Please keep this string short! -->
    <string name="lockpassword_pin_recently_used">Device administrator doesn\'t allow using a recent PIN.</string>

    <!-- Error shown when in PASSWORD mode and user enters an invalid character -->
    <string name="lockpassword_illegal_character">Password contains an illegal character.</string>

    <!-- Error shown when in PASSWORD mode and password is all digits -->
    <string name="lockpassword_password_requires_alpha">Password must contain at least one letter.</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain any digits -->
    <string name="lockpassword_password_requires_digit">Password must contain at least one digit.</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain any symbols -->
    <string name="lockpassword_password_requires_symbol">Password must contain at least one symbol.</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of letters -->
    <plurals name="lockpassword_password_requires_letters">
        <item quantity="one">Password must contain at least 1 letter.</item>
        <item quantity="other">Password must contain at least %d letters.</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of lowercase letters -->
    <plurals name="lockpassword_password_requires_lowercase">
        <item quantity="one">Password must contain at least 1 lowercase letter.</item>
        <item quantity="other">Password must contain at least %d lowercase letters.</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of uppercase letters -->
    <plurals name="lockpassword_password_requires_uppercase">
        <item quantity="one">Password must contain at least 1 uppercase letter.</item>
        <item quantity="other">Password must contain at least %d uppercase letters.</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of numerical digits -->
    <plurals name="lockpassword_password_requires_numeric">
        <item quantity="one">Password must contain at least 1 numerical digit.</item>
        <item quantity="other">Password must contain at least %d numerical digits.</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of special symbols -->
    <plurals name="lockpassword_password_requires_symbols">
        <item quantity="one">Password must contain at least 1 special symbol.</item>
        <item quantity="other">Password must contain at least %d special symbols.</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of non-letter characters -->
    <plurals name="lockpassword_password_requires_nonletter">
        <item quantity="one">Password must contain at least 1 non-letter character.</item>
        <item quantity="other">Password must contain at least %d non-letter characters.</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password has been used recently. Please keep this string short! -->
    <string name="lockpassword_password_recently_used">Device administrator doesn\'t allow using a recent password.</string>

    <!-- Label for ChoosePassword/PIN OK button -->
    <string name="lockpassword_ok_label">OK</string>

    <!-- Label for ChoosePassword/PIN OK button -->
    <string name="lockpassword_cancel_label">Cancel</string>

    <!-- Label for LockPatternTutorial Cancel button -->
    <string name="lockpattern_tutorial_cancel_label">Cancel</string>

    <!-- Label for LockPatternTutorial Continue button -->
    <string name="lockpattern_tutorial_continue_label">Next</string>

    <!-- Toast shown when lock pattern or password successfully setup. [CHAR LIMIT=64] -->
    <string name="lock_setup" msgid="5507462851158901718">Setup is complete.</string>

    <!-- In the security screen, the header title for settings related to device admins -->
    <string name="device_admin_title">Device administration</string>

    <!-- Title of preference to manage device admins -->
    <string name="manage_device_admin">Device administrators</string>

    <!-- Summary of preference to manage device policies -->
    <string name="manage_device_admin_summary">View or deactivate device administrators</string>

    <!-- Bluetooth settings -->
    <!-- Bluetooth settings check box title on Main Settings screen -->
    <string name="bluetooth_quick_toggle_title">Bluetooth</string>
    <!-- Bluetooth settings check box summary for turning on bluetooth -->
    <string name="bluetooth_quick_toggle_summary">Turn on Bluetooth</string>
    <!--Used as title on second screen after selecting Bluetooth settings -->
    <string name="bluetooth_settings">Bluetooth</string>
    <!--Wireless controls screen, settings title for the item to take you to the bluetooth settings screen -->
    <string name="bluetooth_settings_title">Bluetooth</string>
    <!--Wireless controls screen, settings summary for the item tot ake you to the bluetooth settings screen -->
    <string name="bluetooth_settings_summary">Manage connections, set device name &amp; discoverability</string>

    <!-- ======================================================================================= -->
    <!-- Note: The opening brackets of HTML style tags are escaped (e.g. "<b>" is "&lt;b>") in   -->
    <!--   the following resources to enable formatting followed by HTML styling, as described   -->
    <!--   here:  http://developer.android.com/guide/topics/resources/string-resource.html       -->
    <!-- ======================================================================================= -->

    <!-- Title for the dialog to enter PIN. [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_request">Bluetooth pairing request</string>

    <!-- Message when bluetooth dialog for pin entry is showing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_pin_msg">To pair with:<xliff:g id="bold">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold">&lt;/b>&lt;br>&lt;br></xliff:g>Type the device\'s required PIN:</string>

    <!-- Message when bluetooth dialog for passkey entry is showing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_passkey_msg">To pair with:<xliff:g id="bold">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold">&lt;/b>&lt;br>&lt;br></xliff:g>Type the device\'s required passkey:</string>

    <!-- Checkbox label for alphanumeric PIN entry (default is numeric PIN). [CHAR LIMIT=50] -->
    <string name="bluetooth_enable_alphanumeric_pin">PIN contains letters or symbols</string>

    <!-- Bluetooth PIN hint text (below the text entry box). [CHAR LIMIT=30] -->
    <string name="bluetooth_pin_values_hint">Usually 0000 or 1234</string>

    <!-- Pairing dialog text to remind user to enter the PIN on the other device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_pin_other_device">You may also need to type this PIN on the other device.</string>
    <!-- Pairing dialog text to remind user to enter the passkey on the other device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_passkey_other_device">You may also need to type this passkey on the other device.</string>

    <!-- Message for confirmation of passkey to complete pairing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_confirm_passkey_msg">To pair with:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Make sure it is showing this passkey:&lt;br>&lt;b><xliff:g id="passkey">%2$s</xliff:g>&lt;/b></string>

    <!-- Message when bluetooth incoming pairing request for (2.1 devices) dialog is showing -->
    <string name="bluetooth_incoming_pairing_msg">From:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Pair with this device?</string>

    <!-- Message when bluetooth dialog when passkey or pin needs to be displayed. -->
    <string name="bluetooth_display_passkey_pin_msg">To pair with:<xliff:g id="bold1">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold1">&lt;/b>&lt;br>&lt;br></xliff:g>Type on it:<xliff:g id="bold2">&lt;br>&lt;b></xliff:g><xliff:g id="passkey">%2$s</xliff:g><xliff:g id="end_bold2">&lt;/b></xliff:g>, then press Return or Enter.</string>

    <!-- Button text for accepting an incoming pairing request. [CHAR LIMIT=20] -->
    <string name="bluetooth_pairing_accept">Pair</string>
    <!-- Button text for declining an incoming pairing request. [CHAR LIMIT=20] -->
    <string name="bluetooth_pairing_decline">Cancel</string>

    <!-- Title for BT error dialogs. -->
    <string name="bluetooth_error_title"></string>
    <!-- Message for the error dialog when BT pairing fails generically. -->
    <string name="bluetooth_pairing_error_message">Couldn\'t pair with <xliff:g id="device_name">%1$s</xliff:g>.</string>
    <!-- Message for the error dialog when BT pairing fails because the PIN /
    Passkey entered is incorrect. -->
    <string name="bluetooth_pairing_pin_error_message">Couldn\'t pair with <xliff:g id="device_name">%1$s</xliff:g> because of an incorrect PIN or passkey.</string>
    <!-- Message for the error dialog when BT pairing fails because the other device is down. -->
    <string name="bluetooth_pairing_device_down_error_message">Can\'t communicate with <xliff:g id="device_name">%1$s</xliff:g>.</string>
    <!-- Message for the error dialog when BT pairing fails because the other device rejected the pairing. -->
    <string name="bluetooth_pairing_rejected_error_message">Pairing rejected by <xliff:g id="device_name">%1$s</xliff:g>.</string>

    <!-- Message for the error dialog when BT connecting operation fails generically. -->
    <string name="bluetooth_connecting_error_message">Couldn\'t connect to <xliff:g id="device_name">%1$s</xliff:g>.</string>

    <!-- Bluetooth settings: The title of the preference (list item) that initiates a scan for devices -->
    <string name="bluetooth_preference_scan_title">Scan for devices</string>
    <!-- Bluetooth settings: The title of the action button that initiates a search for nearby devices [CHAR LIMIT=20] -->
    <string name="bluetooth_search_for_devices">Search for devices</string>
    <!-- Bluetooth settings: The title of the action button while a search for nearby devices is in progress [CHAR LIMIT=20] -->
    <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: 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 available devices during and after scanning. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_found_devices">Available devices</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. -->
    <string name="bluetooth_device_context_disconnect">Disconnect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will first pair, and then connect to all profiles on the device. -->
    <string name="bluetooth_device_context_pair_connect">Pair &amp; connect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will remove pairing with the device. -->
    <string name="bluetooth_device_context_unpair">Unpair</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect and remove pairing with the device. -->
    <string name="bluetooth_device_context_disconnect_unpair">Disconnect &amp; unpair</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will take the user to another screen where they can choose exactly which profiles to connect to. -->
    <string name="bluetooth_device_context_connect_advanced">Options\u2026</string>
    <!-- Bluetooth settings.  Menu option to Bluetooth advanced settings [CHAR LIMIT=20]-->
    <string name="bluetooth_menu_advanced">Advanced</string>
    <!-- Bluetooth settings. Title of the advanced bluetooth settings screen [CHAR LIMIT=30]-->
    <string name="bluetooth_advanced_titlebar">Advanced Bluetooth</string>
    <!-- Bluetooth settings. Text displayed when Bluetooth is off and device list is empty [CHAR LIMIT=50]-->
    <string name="bluetooth_empty_list_bluetooth_off">To see devices, turn Bluetooth on.</string>


    <!-- Bluetooth settings.  The title of the screen to pick which profiles to connect to on the device.  For example, headphones may have both A2DP and headset, this allows the user to choose which one he wants to connect to. -->
    <string name="bluetooth_connect_specific_profiles_title">Connect to\u2026</string>

    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the A2DP profile. -->
    <string name="bluetooth_profile_a2dp">Media audio</string>
    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the headset or handsfree profile. -->
    <string name="bluetooth_profile_headset">Phone audio</string>
    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the OPP profile. -->
    <string name="bluetooth_profile_opp">File transfer</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the HID profile. -->
    <string name="bluetooth_profile_hid">Input device</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the PAN profile (accessing Internet through remote device). [CHAR LIMIT=40]-->
    <string name="bluetooth_profile_pan">Internet access</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the PAN profile (sharing this device's Internet connection). [CHAR LIMIT=40]-->
    <string name="bluetooth_profile_pan_nap">Internet connection sharing</string>

    <!-- Bluetooth settings.  Message for disconnecting from the A2DP profile. [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_a2dp_profile"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from media audio.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the headset profile. [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_headset_profile"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from handsfree audio.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the HID profile. [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_hid_profile"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from input device.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the PAN profile (user role). [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_pan_user_profile">Internet access via <xliff:g id="device_name">%1$s</xliff:g> will be disconnected.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the PAN profile (NAP role). [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from sharing this tablet\'s Internet connection.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the PAN profile (NAP role). [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_pan_nap_profile" product="default"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from sharing this phone\'s Internet connection.</string>

    <!-- Bluetooth settings.  Connection options screen.  The title of the screen. [CHAR LIMIT=40] -->
    <string name="bluetooth_device_advanced_title">Paired Bluetooth device</string>
    <!-- Bluetooth settings.  Connection options screen.  The title of the checkbox that controls whether the device is in "online" mode or "offline" mode.  This essentially is the checkbox that controls whether any checks / unchecks on a profile should be applied immediately, or next time the device is connected. -->
    <string name="bluetooth_device_advanced_online_mode_title">Connect</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary of the online mode checkbox.  This describes what the setting does in the context of the screen. -->
    <string name="bluetooth_device_advanced_online_mode_summary">Connect to Bluetooth device</string>
    <!-- Bluetooth settings.  Connection options screen.  The title of the header that is above all of the profiles. -->
    <string name="bluetooth_device_advanced_profile_header_title">Profiles</string>
    <!-- Bluetooth settings. Connection options screen. Title for option to rename the device. [CHAR LIMIT=30] -->
    <string name="bluetooth_device_advanced_rename_device">Rename</string>
    <!-- Bluetooth settings. Connection options screen. Title for checkbox to enable incoming file transfers [CHAR LIMIT=30] -->
    <string name="bluetooth_device_advanced_enable_opp_title">Allow incoming file transfers</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the A2DP checkbox preference when A2DP is connected. -->
    <string name="bluetooth_a2dp_profile_summary_connected">Connected to media audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the headset checkbox preference when headset is connected. -->
    <string name="bluetooth_headset_profile_summary_connected">Connected to phone audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference when OPP is connected. -->
    <string name="bluetooth_opp_profile_summary_connected">Connected to file transfer server</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference when OPP is not connected. -->
    <string name="bluetooth_opp_profile_summary_not_connected">Not connected to file transfer server</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the HID checkbox preference when HID is connected. -->
    <string name="bluetooth_hid_profile_summary_connected">Connected to input device</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the checkbox preference when PAN is connected (user role). [CHAR LIMIT=25]-->
    <string name="bluetooth_pan_user_profile_summary_connected">Connected to device for Internet access</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the checkbox preference when PAN is connected (NAP role). [CHAR LIMIT=25]-->
    <string name="bluetooth_pan_nap_profile_summary_connected">Sharing local Internet connection with device</string>

    <!-- Bluetooth settings.  Connection options screen.  The summary for the A2DP checkbox preference that describes how checking it will set the A2DP profile as preferred. -->
    <string name="bluetooth_a2dp_profile_summary_use_for">Use for media audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the headset checkbox preference that describes how checking it will set the headset profile as preferred. -->
    <string name="bluetooth_headset_profile_summary_use_for">Use for phone audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference that describes how checking it will set the OPP profile as preferred. -->
    <string name="bluetooth_opp_profile_summary_use_for">Use for file transfer</string>
    <!-- Bluetooth settings. Connection options screen. The summary
         for the HID checkbox preference that describes how checking it
         will set the HID profile as preferred. -->
    <string name="bluetooth_hid_profile_summary_use_for">Use for input</string>
    <!-- Bluetooth settings. Connection options screen. The summary
         for the PAN checkbox preference that describes how checking it
         will set the PAN profile as preferred. -->
    <string name="bluetooth_pan_profile_summary_use_for">Use for Internet access</string>

    <!-- Bluetooth settings.  Dock Setting Title -->
    <string name="bluetooth_dock_settings">Dock Settings</string>
    <!-- Bluetooth settings.  Dock Setting Dialog Title -->
    <string name="bluetooth_dock_settings_title">Use dock for audio</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Checkbox selection 1: Use dock as speaker phone -->
    <string name="bluetooth_dock_settings_headset">As speaker phone</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Checkbox selection 2: Use dock for media audio -->
    <string name="bluetooth_dock_settings_a2dp">For music and media</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Remember setting and don't ask user again -->
    <string name="bluetooth_dock_settings_remember">Remember settings</string>

    <!-- NFC settings -->
    <!-- Used in the 1st-level settings screen to turn on NFC -->
    <string name="nfc_quick_toggle_title">NFC</string>
    <!-- Description of NFC in the 1st level settings screen, for a tablet. [CHAR LIMIT=NONE] -->
    <string name="nfc_quick_toggle_summary" product="tablet">Allow data exchange when the tablet touches another device</string>
    <!-- Description of NFC in the 1st level settings screen, for a phone. [CHAR LIMIT=NONE] -->
    <string name="nfc_quick_toggle_summary" product="default">Allow data exchange when the phone touches another device</string>

    <!-- Used to enter the Android Beam sharing preferences screen. This phrase is a trademark. [CHAR LIMIT=32] -->
    <string name="android_beam_settings_title">Android Beam</string>
    <!-- Used to describe the on state of the Android Beam feature [CHAR LIMIT=NONE] -->
    <string name="android_beam_on_summary">Ready to transmit app content via NFC</string>
    <!-- Used to describe the off state of the Android Beam feature [CHAR LIMIT=NONE] -->
    <string name="android_beam_off_summary">Off</string>
    <!-- Used to describe the enabled state of the Android Beam feature when NFC, which it relies on, is turned off [CHAR LIMIT=NONE] -->
    <string name="android_beam_disabled_summary">Unavailable because NFC is turned off</string>
    <!-- Used in the Android Beam sharing preferences screen. This phrase is a trademark. [CHAR LIMIT=32] -->
    <string name="android_beam_label">Android Beam</string>
    <!-- Explanation of the Android Beam feature in the Android Beam settings panel. The use of "beam" here is as a verb and not considered trademarked. [CHAR LIMIT=NONE] -->
    <string name="android_beam_explained">When this feature is turned on, you can beam app content to another NFC-capable device by holding the devices close together. For example, you can beam Browser pages, YouTube videos, People contacts, and more.\n\nJust bring the devices together (typically back to back) and then touch your screen. The app determines what gets beamed.</string>

    <!-- Network service discovery settings -->
    <!-- Used in the 1st-level settings screen to turn on NSD -->
    <string name="nsd_quick_toggle_title">Network service discovery</string>
    <!-- Description of NFC in the 1st level settings screen. [CHAR LIMIT=NONE] -->
    <string name="nsd_quick_toggle_summary">Allow apps on other devices to discover apps on this device</string>

    <!-- Wi-Fi Settings --> <skip />
    <!-- Used in the 1st-level settings screen to turn on Wi-Fi -->
    <string name="wifi_quick_toggle_title">Wi-Fi</string>
    <!-- Used in the 1st-level settings screen as the turn-on summary -->
    <string name="wifi_quick_toggle_summary">Turn on Wi-Fi</string>
    <!-- Used in the 1st-level settings screen to go to the 2nd-level settings screen  [CHAR LIMIT=20]-->
    <string name="wifi_settings">Wi-Fi</string>
    <!-- Title of the Wi-fi settings screen -->
    <string name="wifi_settings_category">Wi-Fi settings</string>
    <!-- Title of the Wi-fi settings entry in the left top level menu -->
    <string name="wifi_settings_title">Wi-Fi</string>
    <!-- Summary text of the Wi-fi settings screen -->
    <string name="wifi_settings_summary">Set up &amp; manage wireless access points</string>
    <!-- Used in the 1st-level settings screen to turn on Wi-Fi  [CHAR LIMIT=60] -->
    <string name="wifi_setup_wizard_title">Select Wi-Fi</string>
    <!-- Summary text when turning Wi-Fi or bluetooth on -->
    <string name="wifi_starting">Turning Wi-Fi on\u2026</string>
    <!-- Summary text when turning Wi-Fi or bluetooth off -->
    <string name="wifi_stopping">Turning off Wi-Fi\u2026</string>
    <!-- Summary text when Wi-Fi or bluetooth has error -->
    <string name="wifi_error">Error</string>
    <!-- Toast message when Wi-Fi or bluetooth is disallowed in airplane mode -->
    <string name="wifi_in_airplane_mode">In Airplane mode</string>
    <!-- Toast message when Wi-Fi cannot scan for networks -->
    <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 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-Fi network unless it has a good Internet connection</string>
    <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? -->
    <string name="wifi_setting_sleep_policy_title">Keep Wi-Fi on during sleep</string>
    <!-- Generic error message when the sleep policy could not be set. -->
    <string name="wifi_setting_sleep_policy_error">There was a problem changing the setting</string>
    <!-- Action bar text message to manually add a wifi network [CHAR LIMIT=20]-->
    <string name="wifi_add_network">Add network</string>
    <!-- Header for the list of wifi networks-->
    <string name="wifi_access_points">Wi-Fi networks</string>
    <!-- Menu option to do WPS Push Button [CHAR LIMIT=25]-->
    <string name="wifi_menu_wps_pbc">WPS Push Button</string>
    <!-- Menu option to do WPS Pin Entry [CHAR LIMIT=25]-->
    <string name="wifi_menu_wps_pin">WPS Pin Entry</string>
    <!-- Menu option to launch Wi-Fi Direct settings [CHAR LIMIT=20]-->
    <string name="wifi_menu_p2p">Wi-Fi Direct</string>
    <!-- Menu option to scan Wi-Fi networks -->
    <string name="wifi_menu_scan">Scan</string>
    <!-- Menu option to Wi-Fi advanced settings -->
    <string name="wifi_menu_advanced">Advanced</string>
    <!-- Menu option to connect to a Wi-Fi network -->
    <string name="wifi_menu_connect">Connect to network</string>
    <!-- Menu option to delete a Wi-Fi network -->
    <string name="wifi_menu_forget">Forget network</string>
    <!-- Menu option to modify a Wi-Fi network configuration -->
    <string name="wifi_menu_modify">Modify network</string>
    <!-- Wi-Fi settings. text displayed when Wi-Fi is off and network list is empty [CHAR LIMIT=50]-->
    <string name="wifi_empty_list_wifi_off">To see available networks, turn Wi-Fi on.</string>
    <!-- Wi-Fi settings. text displayed when Wi-Fi is on and network list is empty [CHAR LIMIT=50]-->
    <string name="wifi_empty_list_wifi_on">Searching for Wi-Fi networks\u2026</string>
    <!-- Wi-Fi settings. title for setup other network button [CHAR LIMIT=35]-->
    <string name="wifi_other_network">Other network\u2026</string>
    <!-- Wi-Fi settings. content description for more button [CHAR LIMIT=50]-->
    <string name="wifi_more">More</string>
    <!-- Wi-Fi settings. wps menu title [CHAR LIMIT=25]-->
    <string name="wifi_setup_wps">Automatic setup (WPS)</string>

    <!-- Dialog for Access Points --> <skip />
    <!-- Label to show/hide advanced options -->
    <string name="wifi_show_advanced">Show advanced options</string>
    <!-- Title for the WPS setup dialog [CHAR LIMIT=50] -->
    <string name="wifi_wps_setup_title">Wi-Fi Protected Setup</string>
    <!-- Message in WPS dialog at start up [CHAR LIMIT=150] -->
    <string name="wifi_wps_setup_msg">Starting WPS\u2026</string>
    <!-- Message in WPS dialog for PBC after start up [CHAR LIMIT=150] -->
    <string name="wifi_wps_onstart_pbc">Press the Wi-Fi Protected Setup button on your router. It may be called \"WPS\" or contain this symbol:</string>
    <!-- Message in WPS dialog for PIN after start up [CHAR LIMIT=150] -->
    <string name="wifi_wps_onstart_pin">Enter pin <xliff:g id="number">%1$s</xliff:g> on your Wi-Fi router. The setup can take upto two minutes to complete.</string>
    <!-- Text displayed when WPS succeeds [CHAR LIMIT=150] -->
    <string name="wifi_wps_complete">WPS succeeded. Connecting to the network\u2026</string>
    <!-- Text displayed when Wi-Fi is connected through WPS [CHAR LIMIT=150] -->
    <string name="wifi_wps_connected">Connected to Wi-Fi network <xliff:g id="network_name">%s</xliff:g></string>
    <!-- Text displayed when WPS setup is in progress [CHAR LIMIT=150] -->
    <string name="wifi_wps_in_progress">WPS is already in progress and can take upto two minutes to complete</string>
    <!-- Text displayed when WPS fails to start [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_generic">WPS failed. Please try again in a few minutes.</string>
    <!-- Text displayed when WPS fails due to WEP [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_wep">The wireless router security setting (WEP) is not supported</string>
     <!-- Text displayed when WPS fails to TKIP [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_tkip">The wireless router security setting (TKIP) is not supported</string>
     <!-- Text displayed when WPS fails due to authentication issues [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_auth">Authentication failure. Please try again.</string>
     <!-- Text displayed when WPS fails due to another session [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_overlap">Another WPS session was detected. Please try again in a few minutes.</string>
    <!-- Label for the SSID of the network -->
    <string name="wifi_ssid">Network SSID</string>
    <!-- Label for the security of the connection -->
    <string name="wifi_security">Security</string>
    <!-- Label for the signal strength of the connection -->
    <string name="wifi_signal">Signal strength</string>
    <!-- Label for the status of the connection -->
    <string name="wifi_status">Status</string>
    <!-- Label for the link speed of the connection -->
    <string name="wifi_speed">Link speed</string>
    <!-- Label for the IP address of the connection -->
    <string name="wifi_ip_address">IP address</string>
    <!-- Hint text for the IP address -->
    <string name="wifi_ip_address_hint" translatable="false">192.168.1.128</string>
    <!-- Label for the EAP method of the network -->
    <string name="wifi_eap_method">EAP method</string>
    <!-- Label for the phase2 -->
    <string name="please_select_phase2">Phase 2 authentication</string>
    <!-- Label for the EAP CA certificate of the network -->
    <string name="wifi_eap_ca_cert">CA certificate</string>
    <!-- Label for the EAP user certificate of the network -->
    <string name="wifi_eap_user_cert">User certificate</string>
    <!-- Label for the EAP identity of the network -->
    <string name="wifi_eap_identity">Identity</string>
    <!-- Label for the EAP anonymous identity of the network -->
    <string name="wifi_eap_anonymous">Anonymous identity</string>
    <!-- Label for the password of the secured network -->
    <string name="wifi_password">Password</string>
    <!-- Label for the check box to show password -->
    <string name="wifi_show_password">Show password</string>
    <!-- Label for the spinner to show ip settings [CHAR LIMIT=25] -->
    <string name="wifi_ip_settings">IP settings</string>
    <!-- Hint for unchanged fields -->
    <string name="wifi_unchanged">(unchanged)</string>
    <!-- Hint for unspecified fields -->
    <string name="wifi_unspecified">(unspecified)</string>
    <!-- Summary for the remembered network. -->
    <string name="wifi_remembered">Saved</string>
    <!-- Status for networks disabled for unknown reason -->
    <string name="wifi_disabled_generic">Disabled</string>
    <!-- Status for networked disabled from a DNS or DHCP failure -->
    <string name="wifi_disabled_network_failure">Avoided poor Internet connection</string>
    <!-- Status for networks disabled from authentication failure (wrong password
         or certificate). -->
    <string name="wifi_disabled_password_failure">Authentication problem</string>
    <!-- Summary for the remembered network but currently not in range. -->
    <string name="wifi_not_in_range">Not in range</string>
    <!-- Substring of status line when Wi-Fi Protected Setup (WPS) is available and
         string is listed first [CHAR LIMIT=20]-->
    <string name="wifi_wps_available_first_item">WPS available</string>
    <!-- Substring of wifi status when Wi-Fi Protected Setup (WPS) is available and
         string is listed after a wifi_secured_* string-->
    <string name="wifi_wps_available_second_item">\u0020(WPS available)</string>
    <!-- Substring of wifi status for wifi with authentication.  This version is for when the
         string is first in the list (titlecase in english) -->
    <string name="wifi_secured_first_item">Secured with <xliff:g id="wifi_security_short">%1$s</xliff:g></string>
    <!-- Substring of wifi status for wifi with authentication.  This version is for when the
         string is not first in the list (lowercase in english) -->
    <string name="wifi_secured_second_item">, secured with <xliff:g id="wifi_security_short">%1$s</xliff:g></string>

    <!-- Do not translate.  Concise terminology for wifi with WEP security -->
    <string name="wifi_security_short_wep">WEP</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA security -->
    <string name="wifi_security_short_wpa">WPA</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA2 security -->
    <string name="wifi_security_short_wpa2">WPA2</string>
    <!-- Do not translate.  Concise terminology for wifi with both WPA/WPA2 security -->
    <string name="wifi_security_short_wpa_wpa2">WPA/WPA2</string>
    <!-- Do not translate.  Concise terminology for wifi with unknown PSK type -->
    <string name="wifi_security_short_psk_generic">@string/wifi_security_short_wpa_wpa2</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP security -->
    <string name="wifi_security_short_eap">802.1x</string>

    <!-- Used in Wi-Fi settings dialogs when Wi-Fi does not have any security. -->
    <string name="wifi_security_none">None</string>

    <!-- Do not translate.  Terminology for wifi with WEP security -->
    <string name="wifi_security_wep">WEP</string>
    <!-- Do not translate.  Terminology for wifi with WPA security -->
    <string name="wifi_security_wpa">WPA PSK</string>
    <!-- Do not translate.  Terminology for wifi with WPA2 security -->
    <string name="wifi_security_wpa2">WPA2 PSK</string>
    <!-- Do not translate.  Terminology for wifi with both WPA/WPA2 security, or unknown -->
    <string name="wifi_security_wpa_wpa2">WPA/WPA2 PSK</string>
    <!-- Do not translate.  Terminology for wifi with unknown PSK type -->
    <string name="wifi_security_psk_generic">@string/wifi_security_wpa_wpa2</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP security -->
    <string name="wifi_security_eap">802.1x EAP</string>


    <!-- Button label to connect to a Wi-Fi network -->
    <string name="wifi_connect">Connect</string>
    <!-- Failured notification for connect -->
    <string name="wifi_failed_connect_message">Failed to connect to network</string>
    <!-- Button label to delete a Wi-Fi network -->
    <string name="wifi_forget">Forget</string>
    <!-- Failured notification for forget -->
    <string name="wifi_failed_forget_message">Failed to forget network</string>
    <!-- Button label to save a Wi-Fi network configuration -->
    <string name="wifi_save">Save</string>
    <!-- Failured notification for save -->
    <string name="wifi_failed_save_message">Failed to save network</string>
    <!-- Button label to dismiss the dialog -->
    <string name="wifi_cancel">Cancel</string>

    <!-- Wi-Fi Advanced Settings --> <skip />
    <!-- Wi-Fi settings screen, advanced, settings section.  This is a header shown above advanced wifi settings. -->
    <string name="wifi_advanced_titlebar">Advanced Wi-Fi</string>
    <!-- Wi-Fi settings screen, setting title for setting the band [CHAR LIMIT=50]-->
    <string name="wifi_setting_frequency_band_title">Wi-Fi frequency band</string>
    <!-- Wi-Fi settings screen, setting summary for setting the wifi frequency band [CHAR LIMIT=50]-->
    <string name="wifi_setting_frequency_band_summary">Specify the frequency range of operation</string>
    <!-- Wi-Fi settings screen, error message when the frequency band could not be set [CHAR LIMIT=50]. -->
    <string name="wifi_setting_frequency_band_error">There was a problem setting the frequency band.</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the Wi-Fi device's MAC address. -->
    <string name="wifi_advanced_mac_address_title">MAC address</string>
    <!-- Title of the screen to adjust IP settings -->
    <!-- Wi-Fi settings screen, advanced, title of the item to show the Wi-Fi device's current IP address. -->
    <string name="wifi_advanced_ip_address_title">IP address</string>

    <!-- Wifi Advanced settings.  Used as a label under the shortcut icon that goes to Wifi advanced settings. [CHAR LIMIT=20]-->
    <string name="wifi_advanced_settings_label">IP settings</string>
    <!-- Menu item to save the IP settings -->
    <string name="wifi_ip_settings_menu_save">Save</string>
    <!-- Menu ietm to cancel the IP settings -->
    <string name="wifi_ip_settings_menu_cancel">Cancel</string>
    <!-- Error message if the IP address is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_ip_address">Type a valid IP address.</string>
    <!-- Error message if the gateway is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_gateway">Type a valid gateway address.</string>
    <!-- Error message if the dns is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_dns">Type a valid DNS address.</string>
    <!-- Error message if the network prefix length is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_network_prefix_length">Type a network prefix length between 0 and 32.</string>
    <!-- Label for the DNS (first one) -->
    <string name="wifi_dns1">DNS 1</string>
    <!-- Hint text for DNS -->
    <string name="wifi_dns1_hint" translatable="false">8.8.8.8</string>
    <!-- Label for the DNS (second one)-->
    <string name="wifi_dns2">DNS 2</string>
    <!-- Hint text for DNS -->
    <string name="wifi_dns2_hint" translatable="false">4.4.4.4</string>
    <!-- Label for the gateway of the network -->
    <string name="wifi_gateway">Gateway</string>
    <!-- Hint text for the gateway -->
    <string name="wifi_gateway_hint" translatable="false">192.168.1.1</string>
    <!-- Label for the network prefix of the network [CHAR LIMIT=25]-->
    <string name="wifi_network_prefix_length">Network prefix length</string>
    <!-- Hint text for network prefix length -->
    <string name="wifi_network_prefix_length_hint" translatable="false">24</string>


    <!-- Wi-Fi p2p / Wi-Fi Direct settings -->
    <!-- Used in the 1st-level settings screen to launch Wi-fi Direct settings [CHAR LIMIT=25] -->
    <string name="wifi_p2p_settings_title">Wi-Fi Direct</string>
    <string name="wifi_p2p_device_info">Device information</string>
    <string name="wifi_p2p_persist_network">Remember this connection</string>
    <!-- Menu option to discover peers-->
    <string name="wifi_p2p_menu_search">Search for devices</string>
    <!-- Menu option when discovery is in progress [CHAR LIMIT=25] -->
    <string name="wifi_p2p_menu_searching">Searching\u2026</string>
    <!-- Menu option to Rename-->
    <string name="wifi_p2p_menu_rename">Rename device</string>
    <!-- Title for available p2p devices -->
    <string name="wifi_p2p_peer_devices">Peer devices</string>
    <!-- Toast text for a failed connection initiation -->
    <string name="wifi_p2p_failed_connect_message">Couldn\'t connect.</string>
    <!-- Message text for failure to rename -->
    <string name="wifi_p2p_failed_rename_message">Failed to rename device.</string>
    <!-- Title for disconnect dialog -->
    <string name="wifi_p2p_disconnect_title">Disconnect?</string>
    <!-- Message text for disconnection from one device-->
    <string name="wifi_p2p_disconnect_message">If you disconnect, your connection with <xliff:g id="peer_name">%1$s</xliff:g> will end.</string>
    <!-- Message text for disconnection from multiple devices-->
    <string name="wifi_p2p_disconnect_multiple_message">If you disconnect, your connection with <xliff:g id="peer_name">%1$s</xliff:g> and <xliff:g id="peer_count">%2$s</xliff:g> other devices will end.</string>
    <!-- Title for cancel connect dialog -->
    <string name="wifi_p2p_cancel_connect_title">Cancel invitation?</string>
    <!-- Message text for disconnection from one device-->
    <string name="wifi_p2p_cancel_connect_message">Do you want to cancel invitation to connect with <xliff:g id="peer_name">%1$s</xliff:g>?</string>

    <!-- Wifi AP settings-->
    <!-- Label for wifi tether checkbox. Toggles Access Point on/off -->
    <string name="wifi_tether_checkbox_text">Portable Wi-Fi hotspot</string>
    <!-- Subtext for wifi tether checkbox on success -->
    <string name="wifi_tether_enabled_subtext">Portable hotspot <xliff:g id="network_ssid">%1$s</xliff:g> active</string>
    <!-- Subtext for wifi tether checkbox on failure -->
    <string name="wifi_tether_failed_subtext">Portable Wi-Fi hotspot error</string>
    <!-- Used to open the ssid and security dialog for Wifi Access Point -->
    <string name="wifi_tether_configure_ap_text">Set up Wi-Fi hotspot</string>
    <!-- Subtext on configuration preference to indicate SSID and security chosen -->
    <string name="wifi_tether_configure_subtext"><xliff:g id="network_ssid">%1$s</xliff:g> <xliff:g id="network_security">%2$s</xliff:g> portable Wi-Fi hotspot</string>
    <!-- Default access point SSID used for tethering -->
    <string name="wifi_tether_configure_ssid_default">AndroidHotspot</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Wi-Fi Testing on the diagnostic screen-->
    <string name="testing_wifi_info" translatable="false">Wi-Fi information</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager disableNetwork API-->
    <string name="disableNetwork" translatable="false">disableNetwork</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager enableNetwork API-->
    <string name="enableNetwork" translatable="false">enableNetwork</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager disconnect API-->
    <string name="disconnect" translatable="false">disconnect</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager getConfiguredNetworks API-->
    <string name="getConfiguredNetworks" translatable="false">getConfiguredNetworks</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager getConnectionInfo API-->
    <string name="getConnectionInfo" translatable="false">getConnectionInfo</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_api_test" translatable="false">Wi-Fi API</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_status_test" translatable="false">Wi-Fi status</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Button text on Wifi Status screen-->
    <string name="wifi_update" translatable="false">Refresh stats</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="wifi_state_label" translatable="false">Wi-Fi state:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="network_state_label" translatable="false">Network state:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
        Label on Wifi Status screen-->
    <string name="supplicant_state_label" translatable="false">Supplicant state:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="rssi_label" translatable="false">RSSI:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="bssid_label" translatable="false">BSSID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="ssid_label" translatable="false">SSID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="hidden_ssid_label" translatable="false">Hidden SSID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="ipaddr_label" translatable="false">IPaddr:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="macaddr_label" translatable="false">MAC addr:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="networkid_label" translatable="false">Network ID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="link_speed_label" translatable="false">Link speed:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="scan_list_label" translatable="false">Scan results:</string>

    <!-- wifi state values-->
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_disabling" translatable="false">Disabling</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_disabled" translatable="false">Disabled</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_enabling" translatable="false">Enabling</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_enabled" translatable="false">Enabled</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_unknown" translatable="false">Unknown</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_config_info" translatable="false">Wi-Fi config</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Configuration screen-->
    <string name="config_list_label" translatable="false">Configured networks</string>

    <!-- Sound and alerts settings -->
    <skip/>
    <!-- Main Settings screen setting option name to go into the display settings screen -->
    <string name="display_settings_title">Display</string>
    <!-- Sound settings screen heading -->
    <string name="sound_settings">Sound</string>
    <!-- Sound settings screen, setting option name to pick ringtone (a list dialog comes up)-->
    <string name="ringtone_title">Phone ringtone</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="ringtone_summary">""</string>
    <!-- Sound settings screen, volume title -->
    <string name="all_volume_title">Volumes</string>
    <!-- Sound settings screen, music effects title [CHAR LIMIT=30]-->
    <string name="musicfx_title">Music effects</string>
    <!-- Sound settings screen, setting option name -->
    <string name="ring_volume_title">Ringer volume</string>
    <!-- Sound settings screen, setting option name checkbox -->
    <string name="vibrate_in_silent_title">Vibrate when silent</string>
    <!-- Sound settings screen, setting option name -->
    <string name="notification_sound_title">Default notification</string>
    <!-- Sound settings screen, notification light repeat pulsing title -->
    <string name="notification_pulse_title">Pulse notification light</string>
    <!-- Sound settings screen, the title of the volume bar to adjust the incoming call volume -->
    <string name="incoming_call_volume_title">Ringtone</string>
    <!-- Sound settings screen, the title of the volume bar to adjust the notification volume -->
    <string name="notification_volume_title">Notification</string>
    <!-- Sound settings screen, the caption of the checkbox for having the notification volume be
         the same as the incoming call volume. -->
    <string name="checkbox_notification_same_as_incoming_call">Use incoming call volume for notifications</string>
    <!-- Sound settings screen, setting option title-->
    <string name="notification_sound_dialog_title">Choose notification ringtone</string>
    <!-- Sound settings screen, setting option name -->
    <string name="media_volume_title">Media</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="media_volume_summary">Set volume for music and videos</string>
    <!-- Sound settings screen, alarm volume slider title -->
    <string name="alarm_volume_title">Alarm</string>
    <!-- Sound settings screen, dock settings summary-->
    <string name="dock_settings_summary">Audio settings for the attached dock</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="dtmf_tone_enable_title">Dial pad touch tones</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="sound_effects_enable_title">Touch sounds</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="lock_sounds_enable_title">Screen lock sound</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="haptic_feedback_enable_title">Vibrate on touch</string>
    <!-- Sound settings screen, setting option name checkbox to enable/disable audio recording features that improve audio recording in noisy environments -->
    <string name="audio_record_proc_title">Noise cancellation</string>
    <!-- Volume description for media volume -->
    <string name="volume_media_description">Music, video, games, &amp; other media</string>
    <!-- Volume description for ringtone and notification volume -->
    <string name="volume_ring_description">Ringtone &amp; notifications</string>
    <!-- Volume description for notification volume -->
    <string name="volume_notification_description">Notifications</string>
    <!-- Volume description for alarm volume -->
    <string name="volume_alarm_description">Alarms</string>
    <!-- Image description for ringer volume mute button. -->
    <string name="volume_ring_mute">Mute ringtone &amp; notifications</string>
    <!-- Image description for media volume mute button. -->
    <string name="volume_media_mute">Mute music &amp; other media</string>
    <!-- Image description for notification volume mute button. -->
    <string name="volume_notification_mute">Mute notifications</string>
    <!-- Image description for alarm volume mute button. -->
    <string name="volume_alarm_mute">Mute alarms</string>
    <!-- Sound settings screen, setting option name checkbox. About vibration setting
         during incoming calls. [CHAR LIMIT=30] -->
    <string name="vibrate_when_ringing_title">Vibrate when ringing</string>

    <!-- Dock settings title, top level -->
    <string name="dock_settings">Dock</string>
    <!-- Dock settings title -->
    <string name="dock_settings_title">Dock settings</string>
    <!-- Dock audio settings -->
    <string name="dock_audio_settings_title">Audio</string>
    <!-- Dock audio summary for docked to desk dock -->
    <string name="dock_audio_summary_desk">Settings for the attached desktop dock</string>
    <!-- Dock audio summary for docked to car dock -->
    <string name="dock_audio_summary_car">Settings for the attached car dock</string>
    <!-- Dock audio summary for undocked -->
    <string name="dock_audio_summary_none" product="tablet">Tablet not docked</string>
    <!-- Dock audio summary for undocked -->
    <string name="dock_audio_summary_none" product="default">Phone not docked</string>
    <!-- Dock audio summary for docked to unknown -->
    <string name="dock_audio_summary_unknown">Settings for the attached dock</string>
    <!-- Dock not found dialog title -->
    <string name="dock_not_found_title">Dock not found</string>
    <!-- Dock not found dialog text -->
    <string name="dock_not_found_text" product="tablet">You need to dock the tablet before setting up dock audio.</string>
    <!-- Dock not found dialog text -->
    <string name="dock_not_found_text" product="default">You need to dock the phone before setting up dock audio.</string>
    <!-- Dock settings screen, dock events SFX setting check box label -->
    <string name="dock_sounds_enable_title">Dock insert sound</string>
    <!-- Dock settings screen, setting option summary text when check box is selected -->
    <string name="dock_sounds_enable_summary_on" product="tablet">Play sound when inserting or removing tablet from dock</string>
    <!-- Dock settings screen, setting option summary text when check box is selected -->
    <string name="dock_sounds_enable_summary_on" product="default">Play sound when inserting or removing phone from dock</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="dock_sounds_enable_summary_off" product="tablet">Don\'t play sound when inserting or removing tablet from dock</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="dock_sounds_enable_summary_off" product="default">Don\'t play sound when inserting or removing phone from dock</string>

    <!-- Account settings header. [CHAR LIMIT=30] -->
    <string name="account_settings">Accounts</string>

    <!-- Main Settings screen, setting option name to go into search settings -->
    <string name="search_settings">Search</string>
    <!-- Main Settings screen, setting option summary to go into search settings -->
    <string name="search_settings_summary">Manage search settings and history</string>

    <!-- Display settings --><skip/>
    <!-- Sound & display settings screen, section header for settings related to display -->
    <string name="display_settings">Display</string>
    <!-- Sound & display settings screen, accelerometer-based rotation check box label -->
    <string name="accelerometer_title">Auto-rotate screen</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is selected -->
    <string name="accelerometer_summary_on" product="tablet">Switch orientation automatically when rotating tablet</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is selected -->
    <string name="accelerometer_summary_on" product="default">Switch orientation automatically when rotating phone</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is clear -->
    <string name="accelerometer_summary_off" product="tablet">Switch orientation automatically when rotating tablet</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is clear -->
    <string name="accelerometer_summary_off" product="default">Switch orientation automatically when rotating phone</string>
    <!-- Sound & display settings screen, setting option name to change brightness -->
    <string name="brightness">Brightness</string>
    <!-- Sound & display settings screen, setting option summary to change brightness -->
    <string name="brightness_summary">Adjust the brightness of the screen</string>
    <!-- Sound & display settings screen, setting option name to change screen timeout -->
    <string name="screen_timeout">Sleep</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] -->
    <string name="wallpaper_settings_title">Wallpaper</string>
    <!-- Wallpaper settings fragment title [CHAR LIMIT=30] -->
    <string name="wallpaper_settings_fragment_title">Choose wallpaper from</string>
    <!-- Display settings screen, trigger for screen saver options -->
    <string name="screensaver_settings_title">Screen Candy</string>
    <!-- Display settings screen, summary for screen saver options, screen saver is turned on -->
    <string name="screensaver_settings_summary_on">Will start upon sleep if connected to power</string>
    <!-- Display settings screen, summary for screen saver options, screen saver is turned off -->
    <string name="screensaver_settings_summary_off">Disabled</string>
    <!-- Screen saver settings, setting option name to select a module -->
    <string name="screensaver_component_title">Selected candy</string>
    <!-- Screen saver settings, setting option name to change activation timeout -->
    <string name="screensaver_timeout_title">When to activate</string>
    <!-- Screen saver settings, setting option summary to change activation timeout -->
    <string name="screensaver_timeout_summary">After <xliff:g id="timeout_description">%1$s</xliff:g> spent idle</string>
    <!-- Screen saver settings, setting option summary to change activation timeout, shown when disabled -->
    <string name="screensaver_timeout_zero_summary">Never</string>
    <!-- Screen saver settings, button allowing the user to test/try the current module -->
    <string name="screensaver_test">Try it!</string>
    <!-- Screen saver settings, checkbox allowing the screen saver to activate automatically when
         the device is docked -->
    <string name="screensaver_activate_on_dock_title">Also start when docked</string>
    <!-- Sound & display settings screen, setting option name to change whether the screen adjusts automatically based on lighting conditions -->
    <string name="automatic_brightness">Automatic brightness</string>
    <!-- [CHAR LIMIT=30] Sound & display settings screen, setting option name to change font size -->
    <string name="title_font_size">Font size</string>
    <!-- Sound & display settings screen, setting option summary displaying the currently selected font size -->
    <string name="summary_font_size" translatable="false">%1$s</string>
    <!-- [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 -->
    <string name="sim_lock_settings">SIM card lock settings</string>
    <!-- Security & location settings screen, setting option name -->
    <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 -->
    <string name="sim_lock_settings_title">SIM card lock</string>
    <!-- SIM card lock settings screen, setting check box label -->
    <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 -->
    <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 -->
    <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 -->
    <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 -->
    <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 -->
    <string name="sim_pin_change">Change SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enter_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enable_sim_lock">Lock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_disable_sim_lock">Unlock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enter_old">Old SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <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 -->
    <string name="sim_change_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered -->
    <string name="sim_bad_pin">Incorrect PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match -->
    <string name="sim_pins_dont_match">PINs don\'t match</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
    <string name="sim_change_failed">Can\'t change PIN.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when the entered PIN is correct-->
    <string name="sim_change_succeeded">SIM PIN changed successfully</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
    <string name="sim_lock_failed">Can\'t change SIM card lock state.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
    <string name="sim_enter_ok">OK</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
    <string name="sim_enter_cancel">Cancel</string>

    <!-- Advanced (used for diagnostics) device info activity title -->
    <string name="device_info_settings" product="tablet">Tablet status</string>
    <!-- Advanced (used for diagnostics) device info activity title -->
    <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. -->
    <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. -->
    <string name="system_update_settings_list_item_summary">""</string>

    <!-- About phone screen, status item label -->
    <string name="firmware_version">Android version</string>
    <!-- About phone screen, status item label-->
    <string name="model_number">Model number</string>
    <!-- About phone screen, fcc equipment id label-->
    <string name="fcc_equipment_id">Equipment ID</string>
    <!-- About phone screen,  setting option name-->
    <string name="baseband_version">Baseband version</string>
    <!-- About phone screen,  setting option name-->
    <string name="kernel_version">Kernel version</string>
    <!-- About phone screen,  setting option name-->
    <string name="build_number">Build number</string>

    <!-- About phone screen, show when a value of some status item is unavailable. -->
    <string name="device_info_not_available">Not available</string>
    <!-- About phone screen, phone status screen title -->
    <string name="device_status_activity_title">Status</string>
    <!-- About phone screen, title of the item to go into the Phone status screen -->
    <string name="device_status">Status</string>
    <!-- About tablet screen, summary of the item that takes you to tablet status screen -->
    <string name="device_status_summary" product="tablet">Status of the battery, network, and other information</string>
    <!-- About phone screen, summary of the item to go into the phone status screen -->
    <string name="device_status_summary" product="default">Phone number, signal, etc.</string>
    <!-- Main settings screen item's title to go into the storage settings screen [CHAR LIMIT=25] -->
    <string name="storage_settings" >Storage</string>
    <!-- Storage settings screen title -->
    <string name="storage_settings_title">Storage settings</string>
    <!-- [CHAR LIMIT=100] Main settings screen item's summary for the SD card and storage settings -->
    <string name="storage_settings_summary" product="nosdcard">Unmount USB storage, view available storage</string>
    <!-- [CHAR LIMIT=100] Main settings screen item's summary for the SD card and storage settings -->
    <string name="storage_settings_summary" product="default">Unmount SD card, view available storage</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_imei">IMEI</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_imei_sv">IMEI SV</string>
    <!-- About tablet, status item title.  The Mobile Directory Number [CHAR LIMIT=30] -->
    <string name="status_number" product="tablet">MDN</string>
    <!-- About phone, status item title.  The phone number of the current device [CHAR LIMIT=30] -->
    <string name="status_number" product="default">My phone number</string>
    <!-- About phone, status item title.  The phone MIN number of the current device.-->
    <string name="status_min_number">MIN</string>
    <!-- About phone, status item title.  The phone MSID number of the current device.-->
    <string name="status_msid_number">MSID</string>
    <!-- About phone, status item title.  The phone PRL Version of the current device.-->
    <string name="status_prl_version">PRL version</string>
    <!-- About phone, status item title.  The phone MEID number of the current LTE/CDMA device. [CHAR LIMIT=30] -->
    <string name="status_meid_number">MEID</string>
    <!-- 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>
    <!-- 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>
    <!-- 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 -->
    <string name="status_signal_strength">Signal strength</string>
    <!-- About phone, status item title, The status for roaming.  For example, the value might be "Not roaming" -->
    <string name="status_roaming">Roaming</string>
    <!-- About phone, status item title. The cell carrier that the user is connected to.  -->
    <string name="status_operator">Network</string>
    <!-- About phone, status item title.  The MAC address of the Wi-Fi network adapter. -->
    <string name="status_wifi_mac_address">Wi-Fi MAC address</string>
    <!-- About phone, status item title.  The bluetooth adapter's hardware address-->
    <string name="status_bt_address">Bluetooth address</string>
    <!-- About phone, status item title.  The hardware serial number. [CHAR LIMIT=30]-->
    <string name="status_serial_number">Serial number</string>
    <!-- About phone, status item value if the actual value is not available. -->
    <string name="status_unavailable">Unavailable</string>
    <!-- About phone, status item title.  How long the device has been running since its last reboot. -->
    <string name="status_up_time">Up time</string>
    <!-- About phone, status item title.  How much time the device has had its main CPU awake. -->
    <string name="status_awake_time">Awake time</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the phone's internal storage  -->
    <string name="internal_memory">Internal storage</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the SD card [CHAR LIMIT=30] -->
    <string name="sd_memory" product="nosdcard">USB storage</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the SD card -->
    <string name="sd_memory" product="default">SD card</string>
    <!-- SD card & phone storage settings title. The amount of free space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section. -->
    <string name="memory_available">Available</string>
    <!-- SD card & phone storage settings screen heading.  The total amount of storage space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section -->
    <string name="memory_size">Total space</string>
    <!-- SD card & phone storage settings summary. Displayed when the total memory usage is being calculated. Will be replaced with a number like "12.3 GB" when finished calucating. [CHAR LIMIT=30] -->
    <string name="memory_calculating_size">Calculating\u2026</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of applications installed. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_apps_usage">Apps (app data &amp; media content)</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of media on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_media_usage">Media</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of /sdcard/Download on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_downloads_usage">Downloads</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of all pictures, videos in /sdcard/DCIM, /sdcard/Pictures folders on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_dcim_usage">Pictures, videos</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of audio files in /sdcard on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_music_usage">Audio (music, ringtones, podcasts, etc.)</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of misc files on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_media_misc_usage">Misc.</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   [CHAR LIMIT=25] -->
    <string name="sd_eject" product="nosdcard">Unmount shared storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   -->
    <string name="sd_eject" product="default">Unmount SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   [CHAR LIMIT=30] -->
    <string name="sd_eject_summary" product="nosdcard">Unmount the internal USB storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   -->
    <string name="sd_eject_summary" product="default">Unmount the SD card so you can safely remove it</string>
    <!-- SD card & phone storage settings item title for toggling PTP mode on and off.  When PTP mode is on the device will appear on the USB bus as a PTP camera device instead of an MTP music player.   -->

    <!-- SD card & phone storage settings item summary that is displayed when no SD card is inserted.  This version of the string can probably never come up on current hardware. [CHAR LIMIT=25] -->
    <string name="sd_insert_summary" product="nosdcard">Insert USB storage for mounting</string>
    <!-- SD card & phone storage settings item summary that is displayed when no SD card is inserted -->
    <string name="sd_insert_summary" product="default">Insert an SD card for mounting</string>

    <!-- Storage setting item that will mount USB storage if it unmounted. A user should never see this. [CHAR LIMIT=25] -->
    <string name="sd_mount" product="nosdcard">Mount USB storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone mounting the SD card. -->
    <string name="sd_mount" product="default">Mount SD card</string>

    <!-- Subtext for Mount USB storage in Storage settings. User should never see this since we use automount. -->
    <string name="sd_mount_summary" product="nosdcard"></string>
    <!-- Subtext for Mount SD Card in Storage settings. User should never see this since we use automount. -->
    <string name="sd_mount_summary" product="default"></string>
    <!-- SD card & phone storage settings item title that will result in the phone formatting the USB storage.   [CHAR LIMIT=25] -->
    <string name="sd_format" product="nosdcard">Erase USB storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone formatting the SD card.   [CHAR LIMIT=25] -->
    <string name="sd_format" product="default">Erase SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.   [CHAR LIMIT=80] -->
    <string name="sd_format_summary" product="nosdcard">Erases all data on the internal USB storage, such as music and photos</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.   [CHAR LIMIT=80] -->
    <string name="sd_format_summary" product="default">Erases all data on the SD card, such as music and photos</string>
    <!-- SD card status when it is mounted as read only. Will be appended to size, starts with an unbreakable space -->
    <string name="read_only">\u0020(Read-only)</string>
    <!-- SD card eject confirmation dialog title   [CHAR LIMIT=25] -->
    <string name="dlg_confirm_unmount_title" product="nosdcard">Unmount USB storage?</string>
    <!-- SD card eject confirmation dialog title   -->
    <string name="dlg_confirm_unmount_title" product="default">Unmount SD card?</string>
    <!-- SD card eject confirmation dialog  [CHAR LIMIT=NONE] -->
    <string name="dlg_confirm_unmount_text" product="nosdcard">If you unmount the USB storage, some apps you are using will stop and may be unavailable until you remount the USB storage.</string>
    <!-- SD card eject confirmation dialog  -->
    <string name="dlg_confirm_unmount_text" product="default">If you unmount the SD card, some apps you are using will stop and may be unavailable until you remount the SD card.</string>
    <!-- SD card eject error dialog title   [CHAR LIMIT=30] -->
    <string name="dlg_error_unmount_title" product="nosdcard"></string>
    <!-- SD card eject error dialog title   -->
    <string name="dlg_error_unmount_title" product="default"></string>
    <!-- SD card eject error dialog text   [CHAR LIMIT=NONE] -->
    <string name="dlg_error_unmount_text" product="nosdcard">Couldn\'t unmount USB storage. Try again later.</string>
    <!-- SD card eject error dialog text   -->
    <string name="dlg_error_unmount_text" product="default">Couldn\'t unmount SD card. Try again later.</string>
    <!-- SD card unmount informative text   [CHAR LIMIT=NONE] -->
    <string name="unmount_inform_text" product="nosdcard">USB storage will be unmounted.</string>
    <!-- SD card unmount informative text   [CHAR LIMIT=NONE] -->
    <string name="unmount_inform_text" product="default">SD card will be unmounted.</string>
    <!-- SD card eject progress title   -->
    <string name="sd_ejecting_title">Unmounting</string>
    <!-- SD card eject progress text   -->
    <string name="sd_ejecting_summary">Unmount in progress</string>

    <!-- Settings item title when storage is running low [CHAR LIMIT=32] -->
    <string name="storage_low_title">Storage space is running out</string>
    <!-- Settings item summary when storage is running low [CHAR LIMIT=NONE] -->
    <string name="storage_low_summary">Some system functions, such as syncing, may not work correctly. Try to free space by deleting or unpinning items, such as apps or media content.</string>

    <!-- Storage setting.  Menu option for USB transfer settings [CHAR LIMIT=30]-->
    <string name="storage_menu_usb">USB computer connection</string>

    <!-- Storage setting.  Title for USB transfer settings [CHAR LIMIT=30]-->
    <string name="storage_title_usb">USB computer connection</string>
    <!-- Storage setting.  USB connection category [CHAR LIMIT=30]-->
    <string name="usb_connection_category">Connect as</string>
    <!-- Storage setting.  Title for MTP checkbox [CHAR LIMIT=30]-->
    <string name="usb_mtp_title">Media device (MTP)</string>
    <!-- Storage setting.  Summary for MTP checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_mtp_summary">Lets you transfer media files on Windows, or using Android File Transfer on Mac (see www.android.com/filetransfer)</string>
    <!-- Storage setting.  Title for PTP checkbox [CHAR LIMIT=30]-->
    <string name="usb_ptp_title">Camera (PTP)</string>
    <!-- Storage setting.  Label for installer CD [CHAR LIMIT=30]-->
    <string name="usb_ptp_summary">Lets you transfer photos using camera software, and transfer any files on computers that don\'t support MTP</string>
    <!-- Storage setting.  Summary for PTP checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_label_installer_cd">"Install file-transfer tools"</string>

    <!-- Phone info screen, section titles: -->
    <string name="battery_status_title">Battery status</string>
    <!-- Phone info screen, section titles: -->
    <string name="battery_level_title">Battery level</string>

    <!-- APN Settings -->
    <!-- APN settings screen title -->
    <string name="apn_settings">APNs</string>
    <!-- Screen title after user selects APNs setting option -->
    <string name="apn_edit">Edit access point</string>
    <!-- Edit access point label summary text when no value has been set -->
    <string name="apn_not_set">Not set</string>
    <!-- Edit access point labels: A label the user can give to the APN to allow him to differentiate it from the others -->
    <string name="apn_name">Name</string>
    <!-- Edit access point labels: The actual access point name-->
    <string name="apn_apn">APN</string>
    <!-- Edit access point labels: The addess of the proxy to use for this APN -->
    <string name="apn_http_proxy">Proxy</string>
    <!-- Edit access point labels: The port number of the proxy to use for this APN -->
    <string name="apn_http_port">Port</string>
    <!-- Edit access point labels: The username that will be used when conencting to this APN-->
    <string name="apn_user">Username</string>
    <!-- Edit access point labels: The password that will be used when connecting to this APN -->
    <string name="apn_password">Password</string>
    <!-- Edit access point labels: The server address to conenct to for this APN -->
    <string name="apn_server">Server</string>
    <!-- Edit access point labels: -->
    <string name="apn_mmsc">MMSC</string>
    <!-- Edit access point labels: The proxy to use for MMS (multimedia messages)-->
    <string name="apn_mms_proxy">MMS proxy</string>
    <!-- Edit access point labels: The port on the proxy used for MMS-->
    <string name="apn_mms_port">MMS port</string>
    <!-- Edit access point labels: -->
    <string name="apn_mcc">MCC</string>
    <!-- Edit access point labels: -->
    <string name="apn_mnc">MNC</string>
    <!-- Edit acces  point labels: Authenticaton type-->
    <string name="apn_auth_type">Authentication type</string>
    <!-- Authentication Typs: None -->
    <string name="apn_auth_type_none">None</string>
    <!-- Authentication Typs: PAP -->
    <string name="apn_auth_type_pap">PAP</string>
    <!-- Authentication Typs: CHAP -->
    <string name="apn_auth_type_chap">CHAP</string>
    <!-- Authentication Typs: PAP or CHAP -->
    <string name="apn_auth_type_pap_chap">PAP or CHAP</string>
    <!-- Edit access point labels: The type of APN -->
    <string name="apn_type">APN type</string>
    <!-- Edit access point labels: The protocol of the APN, e.g., "IPv4", "IPv6", or "IPv4/IPv6". -->
    <string name="apn_protocol">APN protocol</string>
    <!-- Edit access point labels: The protocol of the APN when roaming, e.g., "IPv4", "IPv6", or "IPv4/IPv6". -->
    <string name="apn_roaming_protocol">APN roaming protocol</string>
    <!-- Edit enable/disable of APN -->
    <string name="carrier_enabled">APN enable/disable</string>
    <string name="carrier_enabled_summaryOn">APN enabled</string>
    <string name="carrier_enabled_summaryOff">APN disabled</string>
    <!-- Edit Beaerer Info of APN -->
    <string name="bearer">Bearer</string>
    <!-- Edit access point screen menu option to delete this APN -->
    <string name="menu_delete">Delete APN</string>
    <!-- APNs screen menu option to create a brand spanking new APN -->
    <string name="menu_new">New APN</string>
    <!-- Edit access point screen menu option to save the user's changes for this APN to the persistent storage -->
    <string name="menu_save">Save</string>
    <!-- Edit access point screen menu option to discard the user's changes for this APN -->
    <string name="menu_cancel">Discard</string>
    <!-- APN error dialog title -->
    <string name="error_title"></string>
    <!-- APN error dialog messages: -->
    <string name="error_name_empty">The Name field can\'t be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_apn_empty">The APN can\'t be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_mcc_not3">MCC field must be 3 digits.</string>
    <!-- APN error dialog messages: -->
    <string name="error_mnc_not23">MNC field must be 2 or 3 digits.</string>
    <!-- The message of dialog indicated restoring default APN settings in progress -->
    <string name="restore_default_apn">Restoring default APN settings.</string>
    <!-- APNs screen menu option to reset default APN settings -->
    <string name="menu_restore">Reset to default</string>
    <!-- APNs screen toast message to inform reset default APN settings is completed -->
    <string name="restore_default_apn_completed">Reset default APN settings completed.</string>

    <!-- Master Clear -->
    <!-- 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 -->
    <string name="master_clear_summary" product="tablet">Erases all data on tablet</string>
    <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
    <string name="master_clear_summary" product="default">Erases all data on phone</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc" product="tablet">"This will erase all data from your tablet\'s <b>internal storage</b>, including:\n\n<li>Your Google account</li>\n<li>System and app data and settings</li>\n<li>Downloaded apps</li>"</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc" product="default">"This will erase all data from your phone\'s <b>internal storage</b>, including:\n\n<li>Your Google account</li>\n<li>System and app data and settings</li>\n<li>Downloaded apps"</li></string>
    <!-- SD card & phone storage settings screen, instructions and list of current accounts.  The list of accounts follows this text[CHAR LIMIT=NONE] -->
    <string name="master_clear_accounts" product="default">"\n\nYou are currently signed into the following accounts:\n"</string>
    <!-- SD card & phone storage settings screen, list of items in user data storage (USB storage or SD card) that will be erased during this operation [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_also_erases_external">"<li>Music</li>\n<li>Photos</li>\n<li>Other user data</li>"</string>
    <!-- SD card & phone storage settings screen, instructions about whether to also erase the external storage (SD card) when erasing the internal storage [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_erase_external_storage" product="nosdcard">"\n\nTo clear music, pictures, and other user data, the <b>USB storage</b> needs to be erased."</string>
    <!-- SD card & phone storage settings screen, instructions about whether to also erase the external storage (SD card) when erasing the internal storage [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_erase_external_storage" product="default">"\n\nTo clear music, pictures, and other user data, the <b>SD card</b> needs to be erased."</string>
    <!-- SD card & phone storage settings screen, label for check box to erase USB storage [CHAR LIMIT=30] -->
    <string name="erase_external_storage" product="nosdcard">Erase USB storage</string>
    <!-- SD card & phone storage settings screen, label for check box to erase SD card [CHAR LIMIT=30] -->
    <string name="erase_external_storage" product="default">Erase SD card</string>
    <!-- SD card & phone storage settings screen, description for check box to erase USB storage [CHAR LIMIT=NONE] -->
    <string name="erase_external_storage_description" product="nosdcard">Erase all the data on the internal USB storage, such as music or photos</string>
    <!-- SD card & phone storage settings screen, description for check box to erase USB storage [CHAR LIMIT=NONE] -->
    <string name="erase_external_storage_description" product="default">Erase all the data on the SD card, such as music or photos</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="master_clear_button_text" product="tablet">Reset tablet</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="master_clear_button_text" product="default">Reset phone</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button -->
    <string name="master_clear_final_desc">Erase all your personal information and downloaded apps? You can\'t reverse this action!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset phone button -->
    <string name="master_clear_final_button_text">Erase everything</string>
    <!-- Message to draw an unlock pattern before clearing the device -->
    <string name="master_clear_gesture_prompt">Draw your unlock pattern</string>
    <!-- Explanation of drawing unlock pattern to reset phone -->
    <string name="master_clear_gesture_explanation">You need to draw your unlock pattern to confirm a factory data reset.</string>
    <!-- Master clear failed message -->
    <string name="master_clear_failed">No reset was performed because the System Clear service isn\'t available.</string>
    <!-- Master clear confirmation screen title [CHAR LIMIT=30] -->
    <string name="master_clear_confirm_title">Reset?</string>

    <!-- Media Format -->
    <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading [CHAR LIMIT=25] -->
    <string name="media_format_title" product="nosdcard">Erase USB storage</string>
    <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading -->
    <string name="media_format_title" product="default">Erase SD card</string>
    <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading [CHAR LIMIT=30] -->
    <string name="media_format_summary" product="nosdcard">Erases all data in USB storage</string>
    <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
    <string name="media_format_summary" product="default">Erases all data on the SD card</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
    <string name="media_format_desc" product="nosdcard">Erase all USB storage? You will lose <b>all</b> stored data!</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
    <string name="media_format_desc" product="default">Erase the SD card? You will lose <b>all</b> data on the card!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset [CHAR LIMIT=25] -->
    <string name="media_format_button_text" product="nosdcard">Erase USB storage</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="media_format_button_text" product="default">Erase SD card</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Format media button [CHAR LIMIT=NONE] -->
    <string name="media_format_final_desc" product="nosdcard">Erase the USB storage, deleting all files stored there? You can\'t reverse this action!</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Format media button [CHAR LIMIT=NONE] -->
    <string name="media_format_final_desc" product="default">Erase the SD card, deleting all files stored there? You can\'t reverse this action!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Format media button -->
    <string name="media_format_final_button_text">Erase everything</string>
    <!-- Message to draw an unlock pattern before clearing the device -->
    <string name="media_format_gesture_prompt">Draw your unlock pattern</string>
    <!-- Explanation of drawing unlock pattern to format card [CHAR LIMIT=NONE] -->
    <string name="media_format_gesture_explanation" product="nosdcard">You need to draw your unlock pattern to confirm that you want to erase the USB storage.</string>
    <!-- Explanation of drawing unlock pattern to format card [CHAR LIMIT=NONE] -->
    <string name="media_format_gesture_explanation" product="default">You need to draw your unlock pattern to confirm that you want to erase the SD card.</string>

    <!-- Main settings screen, Call settings title for item to go into the call settings -->
    <string name="call_settings_title">Call settings</string>
    <!-- Main settings screen, Call settings summary for item to go into call settings -->
    <string name="call_settings_summary">Set up voicemail, call forwarding, call waiting, caller ID</string>

    <!-- Tethering controls, item title to go into the tethering settings -->
    <!-- Tethering controls, item title to go into the tethering settings when only USB tethering is available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_usb">USB tethering</string>
    <!-- Tethering controls, item title to go into the tethering settings when only Wifi tethering is available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_wifi">Portable hotspot</string>
    <!-- Tethering controls, item title to go into the tethering settings when only Bluetooth tethering is available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_bluetooth">Bluetooth tethering</string>
    <!-- Tethering controls, item title to go into the tethering settings when USB and Bluetooth tethering are available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_usb_bluetooth">Tethering</string>
    <!-- Tethering controls, item title to go into the tethering settings when USB, Bluetooth and Wifi tethering are available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_all">Tethering &amp; portable hotspot</string>

    <!-- USB Tethering options -->
    <string name="usb_title">USB</string>
    <string name="usb_tethering_button_text">USB tethering</string>
    <!-- USB available subtext - shown when USB is connected but not currently being tethered -->
    <string name="usb_tethering_available_subtext">USB connected, check to tether</string>
    <!-- USB tethered subtext - shown when USB is connected and being tethered -->
    <string name="usb_tethering_active_subtext">Tethered</string>
    <!-- USB storage subtext - shown when tethering is disabled because USB storage is active -->
    <string name="usb_tethering_storage_active_subtext">Can\'t tether when USB storage is in use</string>
    <!-- USB unavailable subtext - shown when USB is not connected -->
    <string name="usb_tethering_unavailable_subtext">USB not connected</string>
    <!-- USB errored subtext - shown when USB is broken for some reason -->
    <string name="usb_tethering_errored_subtext">USB tethering error</string>

    <!-- Bluetooth Tethering settings-->
    <!-- Label for bluetooth tether checkbox [CHAR LIMIT=25]-->
    <string name="bluetooth_tether_checkbox_text">Bluetooth tethering</string>
    <!-- Bluetooth available subtext - shown when Bluetooth tethering is turned on but it is not currently tethered to any devices [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_available_subtext" product="tablet">Sharing this tablet\'s Internet connection</string>
    <!-- Bluetooth available subtext - shown when Bluetooth tethering is turned on but it is not currently tethered to any devices [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_available_subtext" product="default">Sharing this phone\'s Internet connection</string>
    <!-- Bluetooth connected subtext - shown when a device is tethered over Bluetooth [CHAR LIMIT=60]-->
    <string name="bluetooth_tethering_device_connected_subtext" product="tablet">Sharing this tablet\'s Internet connection to 1 device</string>
    <!-- Bluetooth connected subtext - shown when a device is tethered over Bluetooth [CHAR LIMIT=60]-->
    <string name="bluetooth_tethering_device_connected_subtext" product="default">Sharing this phone\'s Internet connection to 1 device</string>
    <!-- Bluetooth connected subtext - shown when multiple devices are tethered over Bluetooth [CHAR LIMIT=60]-->
    <string name="bluetooth_tethering_devices_connected_subtext" product="tablet">Sharing this tablet\'s Internet connection to <xliff:g id="connectedDeviceCount">%1$d</xliff:g> devices</string>
    <!-- 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" 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>
    <!-- Bluetooth errored subtext - shown when Bluetooth is broken for some reason [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_errored_subtext">Not tethered</string>
    <!-- Bluetooth Tethering settings. Error message shown when trying to connect an 8th device [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_overflow_error">Can\'t tether to more than <xliff:g id="maxConnection">%1$d</xliff:g> devices.</string>
    <!-- Bluetooth Tethering settings.  Message for untethering from a bluetooth device [CHAR LIMIT=50]-->
    <string name="bluetooth_untether_blank"><xliff:g id="device_name">%1$s</xliff:g> will be untethered.</string>

    <!-- Tethering help button - calls up a web view with general tethering info -->
    <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>

    <!-- Security & location settings screen, section header for settings relating to location -->
    <string name="location_title">My 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">Google\'s location service</string>
    <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary for Google location service check box-->
    <string name="location_neighborhood_level">Allow anonymous location data to be sent to Google. Also allow permitted apps to use data from sources such as Wi-Fi and mobile networks to determine your approximate location.</string>
    <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary when Use wireless networks check box is selected, for wifi-only devices -->
    <string name="location_neighborhood_level_wifi">Location determined by Wi-Fi</string>
    <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for GPS satellites -->
    <string name="location_gps">GPS satellites</string>
    <!-- [CHAR LIMIT=100] Security & location settings screen, setting check box summary for GPS satellites -->
    <string name="location_street_level">Let apps use GPS to pinpoint your location</string>
    <!-- Security & location settings screen, setting check box label if Assisted GPS should be enabled -->
    <string name="assisted_gps">Use assisted GPS</string>
    <!-- Security & location settings screen, setting summary when Assisted GPS check box is selected -->
    <string name="assisted_gps_enabled">Use server to assist GPS (uncheck to reduce network usage)</string>
    <!-- Security & location settings screen, setting summary when Assisted GPS check box is clear -->
    <string name="assisted_gps_disabled">Use server to assist GPS (uncheck to improve GPS performance)</string>
    <!-- [CHAR_LIMIT=30] Security & location settings screen, setting check box label for Google search -->
    <string name="use_location_title">Location &amp; Google search</string>
    <!-- [CHAR_LIMIT=100] Security & location settings screen, setting check box summary for Google search -->
    <string name="use_location_summary">Let Google use your location to improve search results and other services</string>

    <!-- About --> <skip />
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings" product="tablet">About tablet</string>
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings" product="default">About phone</string>
    <!-- Main settings screen, setting summary for the user to go into the About phone screen-->
    <string name="about_settings_summary">View legal info, status, software version</string>
    <!-- About phone settings screen, setting option name to go to dialog that shows legal info -->
    <string name="legal_information">Legal information</string>
    <!-- About phone settings screen, setting option name to see a list of contributors -->
    <string name="contributors_title">Contributors</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see copyright-related info -->
    <string name="copyright_title">Copyright</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see licensing info -->
    <string name="license_title">License</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see terms and conditions -->
    <string name="terms_title">Terms and conditions</string>

    <!-- Title for actual Settings license activity. --> <skip />
    <!-- About phone settings, Legal information setting option name and title of dialog box holding license info -->
    <string name="settings_license_activity_title">Open source licenses</string>
    <!-- About phone settings screen, Open source license dialog message when licenses cannot be loaded -->
    <string name="settings_license_activity_unavailable">There is a problem loading the licenses.</string>
    <!-- About phone settings screen, Open source license dialog title until license is fully loaded -->
    <string name="settings_license_activity_loading">Loading\u2026</string>

    <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
    <string name="settings_safetylegal_title">Safety information</string>
    <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
    <string name="settings_safetylegal_activity_title">Safety information</string>
    <!-- About phone settings screen, Safety legal dialog message when data network is not connected -->
    <string name="settings_safetylegal_activity_unreachable">You don\'t have a data connection. To view this information now, go to %s from any computer connected to the Internet.</string>
    <!-- About phone settings screen, Safety Legal dialog title until the link is fully loaded -->
    <string name="settings_safetylegal_activity_loading">Loading\u2026</string>

    <!-- Lock Pattern settings -->
    <!-- Header on first screen of choose password/PIN flow [CHAR LIMIT=30] -->
    <string name="lockpassword_choose_your_password_header">Choose your password</string>
    <!-- Header on first screen of choose pattern flow [CHAR LIMIT=30] -->
    <string name="lockpassword_choose_your_pattern_header">Choose your pattern</string>
    <!-- Header on first screen of choose password/PIN flow [CHAR LIMIT=30] -->
    <string name="lockpassword_choose_your_pin_header">Choose your PIN</string>
    <!-- Header on password confirm screen [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_password_header">Confirm your password</string>
    <!-- Header on pattern confirm screen [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_pattern_header">Confirm your pattern</string>
    <!-- Header on password confirm screen [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_pin_header">Confirm your PIN</string>
    <!-- Header on password confirm screen if second password doesn't match the first. [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_passwords_dont_match">Passwords don\'t match</string>
    <!-- Header on pin confirm screen if second pin doesn't match the first. [CHAR LIMIT=30]-->
    <string name="lockpassword_confirm_pins_dont_match">PINs don\'t match</string>
    <!-- Header shown to ask the user to select an unlock method [CHAR LIMIT=30] -->
    <string name="lockpassword_choose_lock_generic_header">Unlock selection</string>
    <!-- Toast shown if setting password was successful -->
    <string name="lockpassword_password_set_toast">Password has been set</string>
    <!-- Toast shown if setting PIN was successful -->
    <string name="lockpassword_pin_set_toast">PIN has been set</string>
    <!-- Toast shown if setting pattern was successful -->
    <string name="lockpassword_pattern_set_toast">Pattern has been set</string>

    <!-- Lock Pattern settings -->
    <!-- Security & location settings screen, header -->
    <string name="lock_settings_title">Screen security</string>
    <!-- Security & location settings screen, setting option name -->
    <string name="lockpattern_change_lock_pattern_label">Change unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction when the user chooses "Change unlock pattern".  We first ask the user toe nter the current pattern, and this is the message seen -->
    <string name="lockpattern_change_lock_pin_label">Change unlock PIN</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction when the user chooses "Change unlock pattern".  We first ask the user toe nter the current pattern, and this is the message seen -->
    <string name="lockpattern_need_to_unlock">Confirm saved pattern</string>
    <!-- Do not translate. -->
    <string name="lockpattern_need_to_unlock_footer" />
    <!-- Security & location settings screen, change unlock pattern screen instruction if user draws incorrect pattern -->
    <string name="lockpattern_need_to_unlock_wrong">Try again:</string>
    <!-- Do not translate. -->
    <string name="lockpattern_need_to_unlock_wrong_footer" />
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen.  This si when they are supposed to draw a new unlock pattern (for example, if they are changing their unlock patterns)..-->
    <string name="lockpattern_recording_intro_header">Draw an unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen hint on bottom of screen.  We are telling them to press the menu button to see more options or help. -->
    <string name="lockpattern_recording_intro_footer">Press Menu for help.</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen while drawing pattern -->
    <string name="lockpattern_recording_inprogress">Release finger when done.</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen if user doesn't connect enough dots -->
    <string name="lockpattern_recording_incorrect_too_short">Connect at least <xliff:g id="number">%d</xliff:g> dots. Try again:</string>
    <!-- Security & location settings screen, change unlock pattern screen message on top of screen after drawing pattern -->
    <string name="lockpattern_pattern_entered_header">Pattern recorded.</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen to confirm pattern -->
    <string name="lockpattern_need_to_confirm">Draw pattern again to confirm:</string>
    <string name="lockpattern_pattern_confirmed_header">Your new unlock pattern:</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen.  After they draw a pattern and release their finger, we display the pattern so they remember.  When they are ready to draw it once again to confirm it, they press this button. -->
    <string name="lockpattern_confirm_button_text">Confirm</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen.  After they draw a pattern and release their finger, we display the pattern so they remember.  If they are nto satisfied with this pattern, they click this button to redraw the pattern. -->
    <string name="lockpattern_restart_button_text">Redraw</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen. If they are supposed to enter their current pattern before being able to draw another one, and they screw up, they hit this button to try again -->
    <string name="lockpattern_retry_button_text">Retry</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen. Once they draw a new pattern and confirm it by drawing it again, they press this button to exit -->
    <string name="lockpattern_continue_button_text">Continue</string>
    <!-- Security & location settings screen, unlock screen activity title -->
    <string name="lockpattern_settings_title">Unlock pattern</string>
    <!-- Security & location settings screen, setting check box title if the unlock pattern MUST be drawn everytime they turn on the screen -->
    <string name="lockpattern_settings_enable_title">Require pattern</string>
    <!-- Security & location settings screen, setting summary for the checkbox "Require pattern" -->
    <string name="lockpattern_settings_enable_summary">Must draw pattern to unlock screen</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether a visible green line is drawn as the user moves his finger around while drawing the unlock pattern.  If checked, this line is drawn.  If unchecked, there is nothing drawn so the user does not reveal his pattern while he unlocks the phone.-->
    <string name="lockpattern_settings_enable_visible_pattern_title">Make pattern visible</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether tactile feedback will be produced when the user draws the pattern.-->
    <string name="lockpattern_settings_enable_tactile_feedback_title">Vibrate on touch</string>
    <!-- Security & location settings screen, setting check box title. This controls whether the device locks immediately when the power button is pressed. [CHAR LIMIT=28]-->
    <string name="lockpattern_settings_enable_power_button_instantly_locks">Power button instantly locks</string>
    <!-- Security & location settings screen, setting option name when user has never set an unlock pattern -->
    <string name="lockpattern_settings_choose_lock_pattern">Set unlock pattern</string>
    <!-- Security & location settings screen, setting option name when user has previously set an unlock pattern and wants to change to a new pattern -->
    <string name="lockpattern_settings_change_lock_pattern">Change unlock pattern</string>
    <!-- Security & location settings screen, the help instructions (an animation) caption -->
    <string name="lockpattern_settings_help_how_to_record">How to draw an unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen after too many incorrect attempts -->
    <string name="lockpattern_too_many_failed_confirmation_attempts_header">Too many incorrect attempts!</string>
    <!-- Security & location settings screen, change unlock pattern screen countdown hint on bottom of screen after too many incorrect attempts -->
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer">Try again in <xliff:g id="number">%d</xliff:g> seconds.</string>

    <!-- ChooseLockPatternTutorial --> <skip />
    <!-- ChooseLockPatternTutorial, button labels: This is to cancel the tutorial -->
    <string name="skip_button_label">Cancel</string>
    <!-- ChooseLockPatternTutorial, button labels: Continue to the next page of the tutorial -->
    <string name="next_button_label">Next</string>
    <!-- ChooseLockPatternTutorial, tutorial screen title -->
    <string name="lock_title" product="tablet">Securing your tablet</string>
    <!-- ChooseLockPatternTutorial, tutorial screen title -->
    <string name="lock_title" product="default">Securing your phone</string>
    <!-- ChooseLockPatternTutorial, tutorial screen text -->
    <string name="lock_intro_message" product="tablet">Protect your tablet from unauthorized use by creating a personal screen unlock pattern. Slide your finger to connect the dots in any order on the next screen.  You need to connect at least four dots.
        \n\nReady to start? Touch Next.
    </string>
    <!-- ChooseLockPatternTutorial, tutorial screen text -->
    <string name="lock_intro_message" product="default">Protect your phone from unauthorized use by creating a personal screen unlock pattern. Slide your finger to connect at least four dots in any order on the next screen.
        \n\nReady to start? Touch Next.
    </string>

    <!-- Applications Settings --> <skip />
    <!-- Applications settings screen, setting option name for the user to go to the screen to manage installed applications  -->
    <string name="manageapplications_settings_title">Manage apps</string>
    <!-- Applications settings screen, setting option summary for the user to go to the screen to manage installed applications  -->
    <string name="manageapplications_settings_summary">Manage and remove installed apps</string>
    <!-- Applications settings title, on main settings screen. If clicked, the user is taken to a settings screen full of application settings-->
    <string name="applications_settings">Apps</string>
    <!-- Applications settings summary, on main settings screen. The summary for the "Applications" item on the main settings screen. Describes what settings are accessible from the "Applications" screen. -->
    <string name="applications_settings_summary">Manage apps, set up quick launch shortcuts</string>
    <!-- Applications settings screen heading. The header for the Application settings screen. -->
    <string name="applications_settings_header">App settings</string>
    <!-- Applications settings screen, setting check box title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  -->
    <string name="install_applications">Unknown sources</string>
    <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  -->
    <string name="install_unknown_applications">Allow installation of apps from unknown sources</string>
    <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
    <string name="install_all_warning" product="tablet">Your tablet and personal data are more vulnerable to attack by apps
 from unknown sources. You agree that you are solely responsible for any
 damage to your tablet or loss of data that may result from using
 these apps.</string>
    <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
    <string name="install_all_warning" product="default">Your phone and personal data are more vulnerable to attack by apps
 from unknown sources. You agree that you are solely responsible for any
 damage to your phone or loss of data that may result from using
 these apps.</string>
    <!-- Applications settings screen, setting check box title. If checked, applications show more settings options. -->
    <string name="advanced_settings">Advanced settings</string>
    <!-- Applications settings screen, setting check box summary.  This is the summary for "Advanced settings" checkbox  -->
    <string name="advanced_settings_summary">Enable more settings options</string>
    <!-- Manage applications, individual application info screen title. For example, if they click on "Browser" in "Manage applications", the title of the next screen will be this -->
    <string name="application_info_label">App info</string>
    <!-- Manage applications, individual application info screen, section heading for stuff relating to an app's storage settings. -->
    <string name="storage_label">Storage</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling whether this app is the default for some actions -->
    <string name="auto_launch_label">Launch by default</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling whether this app is the default for some actions *and* whether the app was given permission by the user to create widgets -->
    <string name="auto_launch_label_generic">Defaults</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling application screen compatibility -->
    <string name="screen_compatibility_label">Screen compatibility</string>
    <!-- Manage applications, individual application info screen, heading for settings related to the app's permissions. for example, it may list all the permissions the app has. -->
    <string name="permissions_label">Permissions</string>
    <!-- Manage applications, Header name used for cache information -->
    <string name="cache_header_label">Cache</string>
    <!-- Manage applications, text label for button -->
    <string name="clear_cache_btn_text">Clear cache</string>
    <!-- Manage applications, label that appears next to the cache size -->
    <string name="cache_size_label">Cache</string>
    <!-- Manage applications, Header name used for other controls -->
    <string name="controls_label">Controls</string>
    <!-- Manage applications, text label for button to kill / force stop an application -->
    <string name="force_stop">Force stop</string>
    <!-- Manage applications, individual application info screen,label under Storage heading.  The total storage space taken up by this app. -->
    <string name="total_size_label">Total</string>
    <!-- Manage applications, individual application info screen, label under Storage heading. The amount of space taken up by the application itself (for example, the java compield files and things like that) -->
    <string name="application_size_label">App</string>
    <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's code on USB storage [CHARSIZE=40] -->
    <string name="external_code_size_label">USB storage app</string>
    <!-- Manage applications, individual application info screen, label under Storage heading.  The amount of sapce taken up by the app's data (for example, downloaded emails or something like that) -->
    <string name="data_size_label">Data</string>
    <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's data on USB storage [CHARSIZE=40] -->
    <string name="external_data_size_label" product="nosdcard">USB storage data</string>
    <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's data on the SD card [CHARSIZE=40] -->
    <string name="external_data_size_label" product="default">SD card</string>
    <!-- Manage applications, individual application info screen, button label under Storage heading. Button to remove the application from the system. -->
    <string name="uninstall_text">Uninstall</string>
    <!-- [CHAR LIMIT=25] Manage applications, individual application info screen, button label under Storage heading. Button to disable an existing application. -->
    <string name="disable_text">Disable</string>
    <!-- [CHAR LIMIT=25] Manage applications, individual application info screen, button label under Storage heading. Button to re-enable an existing application. -->
    <string name="enable_text">Enable</string>
    <!-- Manage applications, individual application info screen, button label under Storage heading. Button to clear all data associated with tis app (for exampel, remove all cached emails for an Email app) -->
    <string name="clear_user_data_text">Clear data</string>
    <!-- Manage applications, restore updated system application to factory version -->
    <string name="app_factory_reset">Uninstall updates</string>
    <!-- Manage applications, individual application info screen, screen, message text under Launch by default heading. This is present if the app is set as a default for some actions. -->
    <string name="auto_launch_enable_text">You\'ve chosen to launch this app by default for some actions.</string>
    <!-- Manage applications, individual application info screen, screen, message text under Launch by default heading. This is present if the app was given user permission to create widgets. -->
    <string name="always_allow_bind_appwidgets_text">You\'ve chosen to allow this app to create widgets and access their data.</string>
    <!-- Manage applications, individual application screen, text under Launch by default heading if the app is NOT a default for actions -->
    <string name="auto_launch_disable_text">No defaults set.</string>
    <!-- Manage applications, individual application screen, button label under Launch by default heading.  This is used to clear any default actions that may be assigned to this app.  -->
    <string name="clear_activities">Clear defaults</string>
    <!-- Manage applications, individual application info screen, screen, message text under screen compatibility heading -->
    <string name="screen_compatibility_text">This app may not be designed for your screen. You can control how it
            adjusts to your screen here.</string>
    <!-- Manage applications, individual application screen, checkbox to control asking for compatibility mode.  -->
    <string name="ask_compatibility">Ask when launched</string>
    <!-- Manage applications, individual application screen, checkbox to control compatibility mode.  -->
    <string name="enable_compatibility">Scale app</string>
    <!-- Manage apps, individual app screen, substituted for the application's label when the app's label CAN NOT be determined.-->
    <string name="unknown">Unknown</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Sorts all of the apps in the list alphabetically. -->
    <string name="sort_order_alpha">Sort by name</string>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on their file size.  This is used to uninstall when space is getting low. -->
    <string name="sort_order_size">Sort by size</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Show running services. -->
    <string name="show_running_services">Show running services</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Show background cached processes. -->
    <string name="show_background_processes">Show cached processes</string>
    <!-- [CHAR LIMIT=NONE] Manage applications screen, menu item.  Reset all of user's app preferences. -->
    <string name="reset_app_preferences">Reset app preferences</string>
    <!-- [CHAR LIMIT=NONE] Manage applications screen, menu item.  Title of dialog to confirm resetting user's app preferences. -->
    <string name="reset_app_preferences_title">Reset app preferences?</string>
    <!-- [CHAR LIMIT=NONE] Manage applications screen, menu item.  Body of dialog to confirm resetting user's app preferences. -->
    <string name="reset_app_preferences_desc">This will reset all preferences for:\n\n
        <li>Disabled apps</li>\n
        <li>Disabled app notifications</li>\n
        <li>Default applications for actions</li>\n
        <li>Background data restrictions for apps</li>\n\n
        You will not lose any app data.</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Confirmation button of dialog to confirm resetting user's app preferences. -->
    <string name="reset_app_preferences_button">Reset apps</string>
    <!-- Manage applications screen, individual app screen, button label when the user wants to manage the space taken up by an app. -->
    <string name="manage_space_text">Manage space</string>
    <!-- Text for menu option in ManageApps screen to present various menu options -->
    <string name="filter">Filter</string>
    <!-- Title of dialog for presenting filter options -->
    <string name="filter_dlg_title">Choose filter options</string>
    <!-- Text for filter option in ManageApps screen to display all installed
    applications -->
    <string name="filter_apps_all">All</string>
    <!-- Text for filter option in ManageApps screen to display third party
    applications only -->
    <string name="filter_apps_third_party">Downloaded</string>
    <!-- Text for filter option in ManageApps screen to display list of running
    packages only. -->
    <string name="filter_apps_running">Running</string>
    <!-- Text for filter option in ManageApps screen to display list of
    packages installed on sdcard. [CHAR LIMIT=30] -->
    <string name="filter_apps_onsdcard" product="nosdcard">USB storage</string>
    <!-- Text for filter option in ManageApps screen to display list of
    packages installed on sdcard. -->
    <string name="filter_apps_onsdcard" product="default">On SD card</string>
    <!-- [CHAR LIMIT=25] Manage applications, text telling using an application is disabled. -->
    <string name="disabled">Disabled</string>
    <!-- [CHAR LIMIT=25] Text shown when there are no applications to display. -->
    <string name="no_applications">No apps.</string>
    <!-- [CHAR LIMIT=15] Manage applications, label for chart showing internal storage use. -->
    <string name="internal_storage">Internal storage</string>
    <!-- [CHAR LIMIT=15] Manage applications, label for chart showing SD card storage use. -->
    <string name="sd_card_storage" product="nosdcard">USB storage</string>
    <!-- [CHAR LIMIT=15] Manage applications, label for chart showing SD card storage use. -->
    <string name="sd_card_storage" product="default">SD card storage</string>
    <!-- Manage app screen, shown when the activity is busy recomputing the size of each app -->
    <string name="recompute_size">Recomputing size\u2026</string>
    <!-- Manage applications, individual application screen, confirmation dialog title. Displays when user selects to "Clear data". -->
    <string name="clear_data_dlg_title">Delete app data?</string>
    <!-- Manage applications, individual application screen, confirmation dialog message. Displays when user selects to "Clear data". It warns the user of the consequences of clearing the data for an app. -->
    <string name="clear_data_dlg_text">All this app\'s data will be deleted permanently. This includes all files, settings, accounts, databases, etc.</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". Goes through with the clearing of the data. -->
    <string name="dlg_ok">OK</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". -->
    <string name="dlg_cancel">Cancel</string>
    <!-- Manage applications, individual application dialog box title. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
    <string name="app_not_found_dlg_title"></string>
    <!-- Manage applications, individual application dialog box message. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
    <string name="app_not_found_dlg_text"> The app wasn\'t found in the list of installed apps.</string>
    <!-- Manage applications, individual application dialog box message. Shown when there was an error trying to clear the data. -->
    <string name="clear_data_failed">Couldn\'t clear app data.</string>
    <!-- Manage applications, factory reset dialog title for system applications. -->
    <string name="app_factory_reset_dlg_title">Uninstall updates?</string>
    <!-- Manage applications, factory reset option dialog text for system applications. -->
    <string name="app_factory_reset_dlg_text">All updates to this Android system app will be uninstalled.</string>
    <!-- Manage applications, title for dialog if clear data fails-->
    <string name="clear_failed_dlg_title">Clear data</string>
    <!-- Manage applications, text for dialog if clear data fails-->
    <string name="clear_failed_dlg_text">Couldn\'t clear data for app.</string>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
    <string name="security_settings_desc" product="tablet">This app can access the following on your tablet:</string>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
    <string name="security_settings_desc" product="default">This app can access the following on your phone:</string>
    <!-- [CHAR_LIMIT=NONE] Manage applications, individual application info screen, text that appears under the "Permissions" heading.
         This describes the permissions that the application has.  It is used when multiple packages are contributing
         to the permissions and need to be listed here. -->
    <string name="security_settings_desc_multi" product="tablet">This app can access the following on your tablet.
         In order to improve performance and reduce memory usage, some of these permissions
         are available to <xliff:g id="base_app_name">%1$s</xliff:g>
         because it runs in the same process as <xliff:g id="additional_apps_list">%2$s</xliff:g>:</string>
    <!-- [CHAR_LIMIT=NONE] Manage applications, individual application info screen, text that appears under the "Permissions" heading.
         This describes the permissions that the application has.  It is used when multiple packages are contributing
         to the permissions and need to be listed here. -->
    <string name="security_settings_desc_multi" product="default">This app can access the following on your phone.
         In order to improve performance and reduce memory usage, some of these permissions
         are available to <xliff:g id="base_app_name">%1$s</xliff:g>
         because it runs in the same process as <xliff:g id="additional_apps_list">%2$s</xliff:g>:</string>
    <!-- [CHAR_LIMIT=NONE] Format to put together two items in a list. -->
    <string name="join_two_items"><xliff:g id="first_item">%1$s</xliff:g> and <xliff:g id="second_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put the last item at the end of a series of 3 or more items in a list -->
    <string name="join_many_items_last"><xliff:g id="all_but_last_item">%1$s</xliff:g> and <xliff:g id="last_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put the first item at the start of a series of 3 or more items in a list -->
    <string name="join_many_items_first"><xliff:g id="first_item">%1$s</xliff:g>, <xliff:g id="all_but_first_and_last_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put the middle items together in a series of 4 or more items in a list -->
    <string name="join_many_items_middle"><xliff:g id="added_item">%1$s</xliff:g>, <xliff:g id="rest_of_items">%2$s</xliff:g></string>
    <string name="computing_size">Computing\u2026</string>
    <string name="invalid_size_value">Couldn\'t compute package size.</string>
    <!-- String displayed when list is empty -->
    <string name="empty_list_msg">You don\'t have any third-party apps installed.</string>
    <!-- Manage applications, version string displayed in app snippet -->
    <string name="version_text">version <xliff:g id="version_num">%1$s</xliff:g></string>
    <!-- Manage applications, text for Move button -->
    <string name="move_app">Move</string>
    <!-- Manage applications, text for Move button to move app to internal storage -->
    <string name="move_app_to_internal" product="tablet">Move to tablet</string>
    <!-- Manage applications, text for Move button to move app to internal storage -->
    <string name="move_app_to_internal" product="default">Move to phone</string>
    <!-- Manage applications, text for Move button  to move app to sdcard [CHAR LIMIT=25] -->
    <string name="move_app_to_sdcard" product="nosdcard">Move to USB storage</string>
    <!-- Manage applications, text for Move button  to move app to sdcard -->
    <string name="move_app_to_sdcard" product="default">Move to SD card</string>
    <!-- Manage applications, title for dialog when killing persistent apps-->
    <!-- Manage applications, text for Move button when move is in progress -->
    <string name="moving">Moving</string>

    <!-- Manage applications, text for move error messages -->
    <string name="insufficient_storage">Not enough storage space.</string>
    <string name="does_not_exist">App doesn\'t exist.</string>
    <string name="app_forward_locked">App is copy-protected.</string>
    <string name="invalid_location">Install location isn\'t valid.</string>
    <string name="system_package">System updates can\'t be installed on external media.</string>

    <string name="force_stop_dlg_title">Force stop?</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when killing persistent apps-->
    <string name="force_stop_dlg_text">If you force stop an app, it may misbehave.</string>
    <!-- Manage applications, text for dialog when moving an app -->
    <string name="move_app_failed_dlg_title"></string>
    <!-- Manage applications, text for dialog moving an app -->
    <string name="move_app_failed_dlg_text">Couldn\'t move app. <xliff:g id="reason">%1$s</xliff:g></string>
    <!-- Manage applications, application installation location title -->
    <string name="app_install_location_title">Preferred install location</string>
    <!-- Manage applications. application installation location summary -->
    <string name="app_install_location_summary">Change the preferred installation location for new apps</string>
    <!-- [CHAR LIMIT=30] Manage applications, title for dialog when disabling apps -->
    <string name="app_disable_dlg_title">Disable built-in app?</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when disabling apps -->
    <string name="app_disable_dlg_text">If you disable a built-in app, other apps
        may misbehave.</string>
    <!-- [CHAR LIMIT=30] Manage applications, title for dialog when disabling notifications for an app -->
    <string name="app_disable_notifications_dlg_title">Turn off notifications?</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when disabling notifications for an app -->
    <string name="app_disable_notifications_dlg_text">
        If you turn off notifications for this app, you may miss important alerts and updates.
    </string>

    <!-- [CHAR LIMIT=25] Services settings screen, setting option name for the user to go to the screen to view app storage use -->
    <string name="storageuse_settings_title">Storage use</string>
    <!-- Services settings screen, setting option summary for the user to go to the screen to app storage use -->
    <string name="storageuse_settings_summary">View storage used by apps</string>

    <!-- Services settings screen, setting option name for the user to go to the screen to view running services -->
    <string name="runningservices_settings_title">Running services</string>
    <!-- Services settings screen, setting option summary for the user to go to the screen to view running services  -->
    <string name="runningservices_settings_summary">View and control currently running services</string>
    <!-- Label for a service item when it is restarting -->
    <string name="service_restarting">Restarting</string>
    <!-- Label for a process item representing a background process -->
    <string name="cached">Cached background process</string>
    <!-- [CHAR LIMIT=25] Text shown when there are no services running -->
    <string name="no_running_services">Nothing running.</string>
    <!-- Running services, description for a service in the started state -->
    <string name="service_started_by_app">Started by app.</string>
    <!-- Running services, description for a service in the started state -->
    <string name="service_client_name"><xliff:g id="client_name">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=10] Running services, summary of background processes -->
    <string name="service_background_processes"><xliff:g id="memory">%1$s</xliff:g> free</string>
    <!-- [CHAR LIMIT=10] Running services, summary of foreground processes -->
    <string name="service_foreground_processes"><xliff:g id="memory">%1$s</xliff:g> used</string>
    <!-- [CHAR LIMIT=10] Running services, label for chart showing memory use. -->
    <string name="memory">RAM</string>
    <!-- Text to label a process entry with the process name. -->
    <string name="service_process_name"><xliff:g id="process">%1$s</xliff:g></string>
    <!-- Descriptive text of a running process: singular process, singular service. -->
    <string name="running_processes_item_description_s_s"><xliff:g id="numprocess">%1$d</xliff:g>
        process and <xliff:g id="numservices">%2$d</xliff:g> service</string>
    <!-- Descriptive text of a running process: singular process, plural service. -->
    <string name="running_processes_item_description_s_p"><xliff:g id="numprocess">%1$d</xliff:g>
        process and <xliff:g id="numservices">%2$d</xliff:g> services</string>
     <!-- Descriptive text of a running process: plural process, singular service. -->
    <string name="running_processes_item_description_p_s"><xliff:g id="numprocess">%1$d</xliff:g>
        processes and <xliff:g id="numservices">%2$d</xliff:g> service</string>
    <!-- Descriptive text of a running process: plural process, plural service. -->
    <string name="running_processes_item_description_p_p"><xliff:g id="numprocess">%1$d</xliff:g>
        processes and <xliff:g id="numservices">%2$d</xliff:g> services</string>

    <!-- Details about an application's running services. -->
    <string name="runningservicedetails_settings_title">Running app</string>
    <!-- Message displayed when there are no active services in a process. -->
    <string name="no_services">Not active</string>
    <!-- Title for list of services. -->
    <string name="runningservicedetails_services_title">Services</string>
    <!-- Title for list of services. -->
    <string name="runningservicedetails_processes_title">Processes</string>
    <!-- Running service details, stop a service that has started itself. -->
    <string name="service_stop">Stop</string>
    <!-- Running service details, manage a service that is running for some other reason. -->
    <string name="service_manage">Settings</string>
    <!-- Running service details, default description for services that are started. -->
    <string name="service_stop_description">This service was started by its
        app. Stopping it may cause the app to fail.</string>
    <!-- Running service details, description for running heavy-weight process. -->
    <string name="heavy_weight_stop_description">This app can\'t safely
        be stopped. If you stop it, you may lose some of your current work.</string>
    <!-- Running service details, description for background process. -->
    <string name="background_process_stop_description">This is an old app
        process that is still running in case it\'s needed again.
        There is usually no reason to stop it.</string>
    <!-- Running service details, default description for services that are managed. -->
    <string name="service_manage_description"><xliff:g id="client_name">%1$s</xliff:g>:
        currently in use. Touch Settings to control it.</string>
    <!-- Description of the main process in the details. -->
    <string name="main_running_process_description">Main process in use.</string>
    <!-- Message that a process's service is in use. -->
    <string name="process_service_in_use_description">Service <xliff:g id="comp_name">%1$s</xliff:g>
        is in use.</string>
    <!-- Message that a process's provider is in use. -->
    <string name="process_provider_in_use_description">Provider <xliff:g id="comp_name">%1$s</xliff:g>
        is in use.</string>
    <!-- Running service details, stop confirmation dialog title. Displays when user selects selects to stop a system service. -->
    <string name="runningservicedetails_stop_dlg_title">Stop system service?</string>
    <!-- Running service details, stop confirmation descriptive text. Displays when user selects selects to stop a system service. -->
    <string name="runningservicedetails_stop_dlg_text" product="tablet">If you stop this service, some
        features of your tablet may stop working correctly until you power it off
        and then on again.</string>
    <!-- Running service details, stop confirmation descriptive text. Displays when user selects selects to stop a system service. -->
    <string name="runningservicedetails_stop_dlg_text" product="default">If you stop this service, some
        features of your phone may stop working correctly until you power it off
        and then on again.</string>

    <!-- Language Settings --> <skip />
    <!-- Title of setting on main settings screen.  This item will take the user to the screen to tweak settings realted to locale and text -->
    <string name="language_settings">Language &amp; input</string>
    <!-- Title of Language and keyboard settings screen -->
    <string name="language_keyboard_settings_title">Language &amp; input</string>
    <!-- On Language & keyboard settings screen, heading. Inside the "Language & keyboard settings" screen, this is the header for settings that relate to language (select the system language, user dictionary for the language). -->
    <string name="language_settings_category">Language settings</string>
    <!-- On Language & keyboard settings screen, heading. Inside the "Language & keyboard settings" screen, this is the header for settings that relate to keyboard (enable/disable each keyboard, settings for each keyboard). -->
    <string name="keyboard_settings_category">Keyboard &amp; input methods</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to take the user to a screen to select the locale. -->
    <string name="phone_language">Language</string>
    <!-- On Text & language settings screen, setting option name. summary of the setting to take the user to a screen to select the locale. -->
    <string name="phone_language_summary">""</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to enable autoreplace of entered text. auto replace is a feature that will automatically correct mistyped words. -->
    <string name="auto_replace">Auto-replace</string>
    <!-- On Text & language settings screen, setting summary.  This is the summary for the "Auto-replace" setting. -->
    <string name="auto_replace_summary">Correct mistyped words</string>
    <!-- On Text & language settings screen, setting option name.  title of the setting to enable autocapitalization of entered text.  for example, after the user finishes a sentence, the next letter he types will automatically be capitalizated. [CHAR LIMIT=25] -->
    <string name="auto_caps">Auto-capitalization</string>
    <!-- On Text & language settings screen, setting summary. Summary for the Auto-cap setting. [CHAR LIMIT=100]-->
    <string name="auto_caps_summary">Capitalize first letter in sentences</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to enable automatic punctuation of entered text.  for example, it will change an entered "youre" to "you're". -->
    <string name="auto_punctuate">Auto-punctuate</string>
    <!-- On Text & language settings screen, category for physical keyboard text entry options. -->
    <string name="hardkeyboard_category">Physical keyboard settings</string>
    <!-- On Text & language settings screen, setting summary for the Auto-punctuate setting. -->
    <string name="auto_punctuate_summary">Press Space key twice to insert \u0022.\u0022</string>
    <!-- On Security & location settings screen, setting check box name. Title of the checkbox to set whether password edit fields will show the most recent character typed and then hide it, or just hide it right away.  By hide, I mean mask it out. -->
    <string name="show_password">Make passwords visible</string>
    <!-- On Security & location settings screen, setting check box summary. Summary for the visible passwords setting. -->
    <string name="show_password_summary"></string>
    <!-- Warning message about security implications of enabling an input method, displayed as a dialog
         message when the user selects to enable an IME. -->
    <string name="ime_security_warning">This input method may be able to collect
    all the text you type, including personal data like passwords and credit
    card numbers.  It comes from the app
    <xliff:g id="ime_application_name">%1$s</xliff:g>.
    Use this input method?</string>
    <!-- Warning message about security implications of enabling a spell checker, displayed as a dialog
         message when the user selects to enable a spell checker. -->
    <string name="spellchecker_security_warning">This spell checker may be able to collect
    all the text you type, including personal data like passwords and credit
    card numbers.  It comes from the app
    <xliff:g id="spellchecker_application_name">%1$s</xliff:g>.
    Use this spell checker?</string>
    <!-- Image button description for spell checker quick settings. -->
    <string name="spellchecker_quick_settings">Settings</string>
    <!-- Image button description for spell checker language. -->
    <string name="spellchecker_language">Language</string>
    <!-- Toast that settings for an application is failed to open. -->
    <string name="failed_to_open_app_settings_toast">Failed to open settings for <xliff:g id="spell_application_name">%1$s</xliff:g></string>

    <!-- On Language & input settings screen, heading. Inside the "Language & input settings" screen, this is the header for settings that relate to mouse and trackpad devices. [CHAR LIMIT=40] -->
    <string name="pointer_settings_category">Mouse/trackpad</string>
    <!-- On Language & input settings screen, setting summary.  Setting for mouse pointer speed. [CHAR LIMIT=35] -->
    <string name="pointer_speed">Pointer speed</string>

    <!-- On Language & input settings screen, heading. Inside the "Language & input settings" screen, this is the header for settings that relate to game controller devices. [CHAR LIMIT=40] -->
    <string name="game_controller_settings_category">Game Controller</string>
    <!-- On Language & input settings screen, setting title.  Setting to redirect vibration to input devices. [CHAR LIMIT=35] -->
    <string name="vibrate_input_devices">Use vibrator</string>
    <!-- On Language & input settings screen, setting summary.  Setting to redirect vibration to input devices. [CHAR LIMIT=100] -->
    <string name="vibrate_input_devices_summary">Redirect vibrator to game controller when connected.</string>

    <!-- Keyboard Layout Preference Dialog --> <skip />
    <!-- Title for the keyboard layout preference dialog. [CHAR LIMIT=35] -->
    <string name="keyboard_layout_dialog_title">Choose keyboard layout</string>
    <!-- Button to configure keyboard layouts.  [CHAR LIMIT=35] -->
    <string name="keyboard_layout_dialog_setup_button">Set up keyboard layouts</string>
    <!-- Hint describing how to switch keyboard layouts using the keyboard.  [CHAR LIMIT=48] -->
    <string name="keyboard_layout_dialog_switch_hint">To switch, press Control-Spacebar</string>
    <!-- Label of the default keyboard layout.  [CHAR LIMIT=35] -->
    <string name="keyboard_layout_default_label">Default</string>

    <!-- Keyboard Layout Picker --> <skip />
    <!-- Title for the keyboard layout picker activity. [CHAR LIMIT=35] -->
    <string name="keyboard_layout_picker_title">Keyboard layouts</string>

    <!-- User dictionary settings --><skip />
    <!-- User dictionary settings, The titlebar text of the User dictionary settings screen. -->
    <string name="user_dict_settings_titlebar">User dictionary</string>
    <!-- User dictionary settings, The title of the list item to go into the User dictionary settings screen when there is only one user dictionary. [CHAR LIMIT=35] -->
    <string name="user_dict_single_settings_title">Personal dictionary</string>
    <!-- User dictionary settings, The title of the list item to go into the User dictionary list when there are several user dictionaries. [CHAR LIMIT=35] -->
    <string name="user_dict_multiple_settings_title">Personal dictionaries</string>
    <!-- User dictionary settings.  The summary of the listem item to go into the User dictionary settings screen. -->
    <string name="user_dict_settings_summary">""</string>
    <!-- User dictionary settings. The title of the menu item to add a new word to the user dictionary. -->
    <string name="user_dict_settings_add_menu_title">Add</string>
    <!-- User dictionary settings. The title of the dialog to add a new word to the user dictionary. [CHAR LIMIT=25] -->
    <string name="user_dict_settings_add_dialog_title">Add to dictionary</string>
    <!-- User dictionary settings. The title of the screen to add/edit a new word to the user dictionary; it describes the phrase that will be added to the user dictionary. [CHAR LIMIT=25] -->
    <string name="user_dict_settings_add_screen_title">Phrase</string>
    <!-- User dictionary settings. Text on the dialog button to pop more options for adding a word. [CHAR LIMIT=16] -->
    <string name="user_dict_settings_add_dialog_more_options">More options</string>
    <!-- User dictionary settings. Text on the dialog button mask advanced options. [CHAR LIMIT=15] -->
    <string name="user_dict_settings_add_dialog_less_options">Less options</string>
    <!-- User dictionary settings. Text on the dialog button to confirm adding a word. [CHAR LIMIT=15] -->
    <string name="user_dict_settings_add_dialog_confirm">OK</string>
    <!-- User dictionary settings. Label to put before the word field (that's the word that will actually be added to the user dictionary when OK is pressed). [CHAR LIMIT=20] -->
    <string name="user_dict_settings_add_word_option_name">Word:</string>
    <!-- User dictionary settings. Label to put before the shortcut field (once a shortcut is registered, the user can type the shortcut and get the word it points to in the suggestions). [CHAR LIMIT=20] -->
    <string name="user_dict_settings_add_shortcut_option_name">Shortcut:</string>
    <!-- User dictionary settings. Label to put before the language field. [CHAR LIMIT=20] -->
    <string name="user_dict_settings_add_locale_option_name">Language:</string>
    <!-- User dictionary settings. The title of the dialog to edit an existing word in the user dictionary. -->
    <string name="user_dict_settings_edit_dialog_title">Edit word</string>
    <!-- User dictionary settings. The title of the context menu item to edit the current word -->
    <string name="user_dict_settings_context_menu_edit_title">Edit</string>
    <!-- User dictionary settings. The title of the context menu item to delete the current word -->
    <string name="user_dict_settings_context_menu_delete_title">Delete</string>
    <!-- User dictionary settings. The text to show when there are no user-defined words in the dictionary  [CHAR LIMIT=200] -->
    <string name="user_dict_settings_empty_text">You don\'t have any words in the user dictionary. Add a word by touching the Add (+) button.</string>
    <!-- User dictionary settings. The list item to choose to insert a word into the user dictionary for all languages -->
    <string name="user_dict_settings_all_languages">For all languages</string>
    <!-- User dictionary settings. The text to show for the option that shows the entire list of supported locales to choose one [CHAR LIMIT=30] -->
    <string name="user_dict_settings_more_languages">More languages…</string>

    <!-- This is for diagnostics screen. The title of a screen with various items realted to launching screens that will giev the user info. For example, it contains "Phone information" and "Battery information" -->
    <string name="testing">Testing</string>
    <!-- In the Testing screen.  The item title of the activity that shows a bunch of phone-related information.  -->
    <string name="testing_phone_info" product="tablet">Tablet information</string>
    <!-- In the Testing screen.  The item title of the activity that shows a bunch of phone-related information.  -->
    <string name="testing_phone_info" product="default">Phone information</string>
    <!-- In the Testing screen. The item title of the activity that shows a bunch of battery-related information.  -->
    <string name="testing_battery_info">Battery information</string>
    <!-- Do not translate. In the Testing screen. The item title of the activity that shows a bunch of SIM-related operations.  -->
    <string name="testing_sim_toolkit">SIM toolkit</string>

    <!-- The title of the item to go into the Quick launch settings. -->
    <string name="quick_launch_title">Quick launch</string>
    <!-- The summary of the item to go into the Quick launch settings. This is a description of what Quick launch offers. -->
    <string name="quick_launch_summary">Set keyboard shortcuts to launch apps</string>
    <!-- On the Quick launch settings screen, title of the item for shortcut letters that are not assigned to an application yet. Quick launch is assigning a global shortcut to launch a specific app. -->
    <string name="quick_launch_assign_application">Assign app</string>
    <!-- On the Quick launch settings screen, summary text for the item of letters that are not assigned. See the quick launch "Assign application" for a description of quick launch -->
    <string name="quick_launch_no_shortcut">No shortcut</string>
    <!-- On the Quick launch settings screen, summary text under the item for each assigned letter.  -->
    <string name="quick_launch_shortcut">Search + <xliff:g id="shortcut_letter">%1$s</xliff:g></string>
    <!-- On the Quick launch settings screen, title of "Clear shortcut" confirmation dialog. This is reached by longpressing an item for a shortcut letter.  This allows the user to clear the assigned application for that shortcut letter. -->
    <string name="quick_launch_clear_dialog_title">Clear</string>
    <!-- On the Quick launch settings screen, message in the "Clear shortcut" confirmation dialog.  See the title for this dialog for more info. -->
    <string name="quick_launch_clear_dialog_message">Your shortcut for <xliff:g id="shortcut_letter">%1$s</xliff:g> (<xliff:g id="application_name">%2$s</xliff:g>) will be cleared.</string>
    <!-- Clear dialog for quick launch setting box button labels: -->
    <string name="quick_launch_clear_ok_button">OK</string>
    <!-- Clear dialog for quick launch setting box button labels: -->
    <string name="quick_launch_clear_cancel_button">Cancel</string>
    <!-- Quick launch screen, when assigning an app to a shortcut, this menu item to show a list of all applications.  -->
    <string name="quick_launch_display_mode_applications">Apps</string>
    <!-- Quick launch screen, when assigning an app to a shortcut, this menu item to show a list of all shortcutable applications -->
    <string name="quick_launch_display_mode_shortcuts">Shortcuts</string>

    <!-- Input methods Settings -->
    <string name="input_methods_settings_title">Text input</string>
    <!-- Setting name for Input Method chooser -->
    <string name="input_method">Input method</string>
    <!-- Title for the option to press to choose the current input method [CHAR LIMIT=35] -->
    <string name="current_input_method">Default</string>
    <!-- Title for setting the visibility of input method selector [CHAR LIMIT=35] -->
    <string name="input_method_selector">Input method selector</string>
    <!-- An option to always show input method selector automatically when needed [CHAR LIMIT=25] -->
    <string name="input_method_selector_show_automatically_title">Automatic</string>
    <!-- An option to always show input method selector [CHAR LIMIT=25] -->
    <string name="input_method_selector_always_show_title">Always show</string>
    <!-- An option to always hide input method selector [CHAR LIMIT=25] -->
    <string name="input_method_selector_always_hide_title">Always hide</string>
    <!-- Title for configuring input method settings [CHAR LIMIT=35] -->
    <string name="configure_input_method">Set up input methods</string>
    <!-- Title for settings of each IME [CHAR LIMIT=25] -->
    <string name="input_method_settings">Settings</string>
    <!-- Spoken description for IME settings image button [CHAR LIMIT=NONE] -->
    <string name="input_method_settings_button">Settings</string>
    <!-- Title for settings of active input methods in each IME [CHAR LIMIT=35] -->
    <string name="active_input_method_subtypes">Active input methods</string>
    <!-- Title for settings whether or not the framework will select input methods in an IME based on the current system locale. [CHAR LIMIT=35] -->
    <string name="use_system_language_to_select_input_method_subtypes">Use system language</string>
    <!-- Input Methods Settings localized format string for generating the appropriate "Foo settings" menu label for the Input Method named "Foo" [CHAR LIMIT=35] -->
    <string name="input_methods_settings_label_format"><xliff:g id="ime_name">%1$s</xliff:g> settings</string>
    <!-- Title for the settings of selecting active input methods of an IME [CHAR LIMIT=35] -->
    <string name="input_methods_and_subtype_enabler_title">Choose active input methods</string>
    <!-- Summary for on-screen keyboard settings -->
    <string name="onscreen_keyboard_settings_summary">Onscreen keyboard settings</string>
    <!-- Title for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_title">Physical keyboard</string>
    <!-- Summary for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_summary">Physical keyboard settings</string>

    <!-- Development Settings.  the title for the item to take the user to Development settings.  Development settings are settings meant for application developers.  -->
    <string name="development_settings_title">Developer options</string>
    <!-- Development Settings summary.  The summary of the item to take the user to Development settings.  Development settings are settings meant for application developers. -->
    <string name="development_settings_summary">Set options for app development</string>
    <!-- Setting checkbox title for Whether to enable USB debugging support on the phone. -->
    <string name="enable_adb">USB debugging</string>
    <!-- Setting checkbox summary for Whether to enable USB debugging support on the phone -->
    <string name="enable_adb_summary">Debug mode when USB is connected</string>
    <!-- Setting Checkbox title whether to keep the screen on when plugged in to a power source -->
    <string name="keep_screen_on">Stay awake</string>
    <!-- setting Checkbox summary whether to keep the screen on when plugged in  -->
    <string name="keep_screen_on_summary">Screen will never sleep while charging</string>
    <!-- Setting Checkbox title whether to allow mock locations -->
    <string name="allow_mock_location">Allow mock locations</string>
    <!-- setting Checkbox summary whether to allow mock locations  -->
    <string name="allow_mock_location_summary">Allow mock locations</string>
    <!-- Title of warning dialog about the implications of enabling USB debugging -->
    <string name="adb_warning_title">Allow USB debugging?</string>
    <!-- Warning text to user about the implications of enabling USB debugging -->
    <string name="adb_warning_message">USB debugging is intended for development purposes only. Use it to copy data between your computer and your device, install apps on your device without notification, and read log data.</string>
    <!-- Title of warning dialog about the implications of enabling developer settings -->
    <string name="dev_settings_warning_title">Allow development settings?</string>
    <!-- Warning text to user about the implications of enabling USB debugging -->
    <string name="dev_settings_warning_message">These settings are intended for development use only.  They can cause your device and the applications on it to break or misbehave.</string>

    <!-- Title of checkbox setting that protects external storage. [CHAR LIMIT=32] -->
    <string name="enforce_read_external_title" product="nosdcard">Protect USB storage</string>
    <!-- Summary of checkbox setting that protects external storage. [CHAR LIMIT=64] -->
    <string name="enforce_read_external_summary" product="nosdcard">Apps must request permission to read USB storage</string>
    <!-- Title of dialog confirming that user wants to protect external storage. [CHAR LIMIT=32] -->
    <string name="enforce_read_external_confirm_title" product="nosdcard">Protect USB storage?</string>
    <!-- Message of dialog confirming that user wants to protect external storage. [CHAR LIMIT=NONE] -->
    <string name="enforce_read_external_confirm_message" product="nosdcard">When USB storage is protected, apps must request permission to read data from external storage.\n\nSome apps may not work until updated by their developers.</string>

    <!-- Title of checkbox setting that protects external storage. [CHAR LIMIT=32] -->
    <string name="enforce_read_external_title" product="default">Protect SD card</string>
    <!-- Summary of checkbox setting that protects external storage. [CHAR LIMIT=64] -->
    <string name="enforce_read_external_summary" product="default">Apps must request permission to read SD card</string>
    <!-- Title of dialog confirming that user wants to protect external storage. [CHAR LIMIT=32] -->
    <string name="enforce_read_external_confirm_title" product="default">Protect SD card?</string>
    <!-- Message of dialog confirming that user wants to protect external storage. [CHAR LIMIT=NONE] -->
    <string name="enforce_read_external_confirm_message" product="default">When SD card is protected, apps must request permission to read data from external storage.\n\nSome apps may not work until updated by their developers.</string>

    <!-- Title for the screen that lets the user choose a gadget to add to the home screen
         (or other screens that can host gadgets).  Note to translators: we're still determining
         the final name for Gadgets/Widgets, so please translate both for now. -->
    <string name="gadget_picker_title">Choose gadget</string>

    <!-- Title for the screen that lets the user choose a widget to add to the home screen
         (or other screens that can host widgets).  Note to translators: we're still determining
         the final name for Gadgets/Widgets, so please translate both for now. -->
    <string name="widget_picker_title">Choose widget</string>

    <!-- Title in dialog that pops up when an app requests permission to bind a widget [CHAR LIMIT=NONE] -->
    <string name="allow_bind_app_widget_activity_allow_bind_title">Create widget and allow access?</string>

    <!-- Message in dialog that pops up when an app requests permission to bind a widget [CHAR LIMIT=NONE] -->
    <string name="allow_bind_app_widget_activity_allow_bind">After you create the widget, <xliff:g id="widget_host_name">%1$s</xliff:g> can access all data it displays.</string>

    <!-- Text for checkbox that pops up when an app requests permission to bind a widget [CHAR LIMIT=NONE] -->
    <string name="allow_bind_app_widget_activity_always_allow_bind">Always allow <xliff:g id="widget_host_name">%1$s</xliff:g> to create widgets and access their data</string>

    <!-- Used to show an amount of time in the form "d days, h hours, m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_days"><xliff:g id="days">%1$d</xliff:g>d <xliff:g id="hours">%2$d</xliff:g>h <xliff:g id="minutes">%3$d</xliff:g>m <xliff:g id="seconds">%4$d</xliff:g>s</string>

    <!-- Used to show an amount of time in the form "h hours, m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_hours"><xliff:g id="hours">%1$d</xliff:g>h <xliff:g id="minutes">%2$d</xliff:g>m <xliff:g id="seconds">%3$d</xliff:g>s</string>

    <!-- Used to show an amount of time in the form "m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_minutes"><xliff:g id="minutes">%1$d</xliff:g>m <xliff:g id="seconds">%2$d</xliff:g>s</string>

    <!-- Used to show an amount of time in the form "s seconds" in BatteryHistory -->
    <string name="battery_history_seconds"><xliff:g id="seconds">%1$d</xliff:g>s</string>

    <!-- XXX remove? Strings used for displaying usage statistics -->
    <string name="usage_stats_label">Usage statistics</string>

    <!-- In the Testing screen. The item title of the activity that shows usage statistics.  -->
    <string name="testing_usage_stats">Usage statistics</string>
    <!-- label for text to indicate sort options -->
    <string name="display_order_text">Sort by:</string>
    <!-- label for application name -->
    <string name="app_name_label">App</string>
    <!-- label for launch count -->
    <string name="launch_count_label">Count</string>
    <!-- label for usage time -->
    <string name="usage_time_label">Usage time</string>

    <!-- Accessibility settings -->
    <skip />

    <!-- Settings title in main settings screen for accessibility settings -->
    <string name="accessibility_settings">Accessibility</string>
    <!-- Settings title for accessibility settings screen -->
    <string name="accessibility_settings_title">Accessibility settings</string>

    <!--  Title for the accessibility preference category of accessibility services. [CHAR LIMIT=25] -->
    <string name="accessibility_services_title">Services</string>

    <!-- Title for the accessibility preference category of system related preferences. [CHAR LIMIT=25] -->
    <string name="accessibility_system_title">System</string>
    <!-- Title for the accessibility preference to enable large text. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_large_text_title">Large text</string>
    <!-- Title for the accessibility preference to power button to end a call. [CHAR LIMIT=35] -->
    <string name="accessibility_power_button_ends_call_title">Power button ends call</string>
    <!-- Title for the accessibility preference to speak passwords. [CHAR LIMIT=35] -->
    <string name="accessibility_speak_password_title">Speak passwords</string>
    <!-- Title for accessibility preference to choose long-press delay i.e. timeout before it is detected. [CHAR LIMIT=35] -->
    <string name="accessibility_long_press_timeout_title">Touch &amp; hold delay</string>
    <!-- Title for accessibility preference to install accessibility scripts from Google. [CHAR LIMIT=35] -->
    <string name="accessibility_script_injection_title">Enhance web accessibility</string>

    <!-- Title for accessibility menu item to lauch a settings activity. [CHAR LIMIT=15] -->
    <string name="accessibility_menu_item_settings">Settings</string>

    <!-- Summary for the enabled state of an accessiblity serivce. [CHAR LIMIT=10] -->
    <string name="accessibility_service_state_on">On</string>
    <!-- Summary for the disabled state of an accessiblity serivce. [CHAR LIMIT=10] -->
    <string name="accessibility_service_state_off">Off</string>

    <!-- Summary for the allowed state of script injection. [CHAR LIMIT=15] -->
    <string name="accessibility_script_injection_allowed">Allowed</string>
    <!-- Summary for the disallowed state of script injection. [CHAR LIMIT=15] -->
    <string name="accessibility_script_injection_disallowed">Not allowed</string>

    <!-- Title for the dialog button to allow script injection. [CHAR LIMIT=15] -->
    <string name="accessibility_script_injection_button_allow">Allow</string>
    <!-- Title for the dialog button to disallow script injection. [CHAR LIMIT=15] -->
    <string name="accessibility_script_injection_button_disallow">Don\'t allow</string>

     <!-- Title for a warning message about security implications of enabling an accessibility service,
         displayed as a dialog message when the user selects to enable an accessibility service (tablet). [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_security_warning_title">Use
         <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Summary for a warning message about security implications of enabling an accessibility service,
         displayed as a dialog message when the user selects to enable an accessibility service (tablet). [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_security_warning_summary" product="tablet">
            <xliff:g id="accessibility_service_name">%1$s</xliff:g> can
            collect all of the text you type, except passwords. This includes personal data such as credit card
            numbers. It can also collect data about your interactions with the tablet.</string>
    <!-- Summary for a warning message about security implications of enabling an accessibility service,
         displayed as a dialog message when the user selects to enable an accessibility service (phone). [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_security_warning_summary" product="default">
            <xliff:g id="accessibility_service_name">%1$s</xliff:g> can
            collect all of the text you type, except passwords. This includes personal data such as credit card
            numbers. It can also collect data about your interactions with the phone.</string>

    <!-- Title for a warning about disabling an accessibility service displayed as a dialog message when the user
         selects to disable that service. This avoids accidental disabling. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_disable_warning_title">Stop
         <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Summary for a warning about disabling accessibility service displayed as a dialog message when the user
         selects to disable that service. This avoids accidental disabling. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_disable_warning_summary">Touching OK will
        stop <xliff:g id="service" example="TalkBack">%1$s</xliff:g>.</string>

    <!-- Title for the prompt shown as a placeholder if no accessibility serivices are installed. [CHAR LIMIT=50] -->
    <string name="accessibility_no_services_installed">No services installed</string>

    <!-- Title for the prompt that lets users know that they have no accessibility related apps
         installed and that they can install TalkBack from Market. [CHAR LIMIT=50] -->
    <string name="accessibility_service_no_apps_title">Need a screen reader?</string>
    <!-- Message for the prompt that lets users know that they have no accessibility related apps
         installed and that they can install TalkBack from Market. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_no_apps_message">TalkBack provides spoken feedback to
         help blind and low-vision users. Do you want to install it for free from Android
         Market?</string>

    <!-- Warning message about security implications of downloading accessibility scripts,
         displayed as a dialog message when the user selects to enable script downloading. [CHAR LIMIT=NONE] -->
    <string name="accessibility_script_injection_security_warning_summary">Do you want apps to
        install scripts from Google that make their web content more accessible?</string>

    <!-- Default description for an accessibility serivice if the latter doesn't provide one. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_default_description">No description provided.</string>

    <!-- Accessibility settings: button for lauching settings for an accessibility service -->
    <string name="settings_button">Settings</string>

    <!-- App Fuel Gauge strings -->
    <skip />

    <!-- Activity title for App Fuel Gauge summary -->
    <string name="power_usage_summary_title">Battery</string>
    <!-- Activity title summary for App Fuel Gauge summary -->
    <string name="power_usage_summary">What has been using the battery</string>
    <!-- Message to show when battery usage data is not available [CHAR LIMIT=30] -->
    <string name="power_usage_not_available">Battery usage data isn\'t available.</string>
    <!-- Display the battery level and status [CHAR_LIMIT=30] -->
    <string name="power_usage_level_and_status"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="status">%2$s</xliff:g></string>
    <!-- Battery usage since unplugged -->
    <string name="battery_since_unplugged">Battery use since unplugged</string>
    <!-- Battery usage since user reset the stats -->
    <string name="battery_since_reset">Battery use since reset</string>
    <!-- Battery usage on battery duration -->
    <string name="battery_stats_on_battery"><xliff:g id="time">%1$s</xliff:g> on battery</string>
    <!-- Battery usage duration -->
    <string name="battery_stats_duration"><xliff:g id="time">%1$s</xliff:g> since unplugged</string>
    <!-- [CHAR LIMIT=25] Label for battery stats charging state graph -->
    <string name="battery_stats_charging_label">Charging</string>
    <!-- [CHAR LIMIT=25] Label for battery stats screen on state graph -->
    <string name="battery_stats_screen_on_label">Screen on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats gps on state graph -->
    <string name="battery_stats_gps_on_label">GPS on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats wifi running state graph -->
    <string name="battery_stats_wifi_running_label">Wi-Fi</string>
    <!-- [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>
    <!-- Battery usage during last unplugged period -->
    <string name="battery_stats_last_duration">@string/menu_stats_last_unplugged</string>
    <!-- CPU awake time title -->
    <string name="awake">Device awake time</string>
    <!-- Wifi on time -->
    <string name="wifi_on_time">Wi-Fi on time</string>
    <!-- Bluetooth on time -->
    <string name="bluetooth_on_time">Wi-Fi on time</string>
    <!-- Application name and battery usage percentage -->
    <string name="usage_name_percent"><xliff:g id="name">%1$s</xliff:g>" - "
            <xliff:g id="number" example="30">%2$s</xliff:g><xliff:g id="percent" example="%">%%</xliff:g></string>

    <!-- Activity title for battery usage history details -->
    <string name="history_details_title">History details</string>

    <!-- Activity title for battery usage details for an app. or power consumer -->
    <string name="details_title">Use details</string>
    <!-- Subtitle for application/subsystem details -->
    <string name="details_subtitle">Use details</string>
    <!-- Subtitle for possible options -->
    <string name="controls_subtitle">Adjust power use</string>
    <!-- Subtitle for list of packages -->
    <string name="packages_subtitle">Included packages</string>

    <!-- Label for power consumed by the screen -->
    <string name="power_screen">Screen</string>
    <!-- Label for power consumed by Wi-Fi -->
    <string name="power_wifi">Wi-Fi</string>
    <!-- Label for power consumed by Bluetooth -->
    <string name="power_bluetooth">Bluetooth</string>
    <!-- Label for power consumed by Cell idle -->
    <string name="power_cell">Cell standby</string>
    <!-- Label for power consumed by Calling -->
    <string name="power_phone">Voice calls</string>
    <!-- Label for power consumed when Idle -->
    <string name="power_idle" product="tablet">Tablet idle</string>
    <!-- Label for power consumed when Idle -->
    <string name="power_idle" product="default">Phone idle</string>

    <!-- Label for CPU usage time -->
    <string name="usage_type_cpu">CPU total</string>
    <!-- Label for CPU usage in foreground -->
    <string name="usage_type_cpu_foreground">CPU foreground</string>
    <!-- [CHAR LIMIT=25] Label for keeping device from sleeping -->
    <string name="usage_type_wake_lock">Keep awake</string>
    <!-- Label for GPS usage time -->
    <string name="usage_type_gps">GPS</string>
    <!-- [CHAR LIMIT=25] Label for WIFI usage time -->
    <string name="usage_type_wifi_running">Wi-Fi running</string>
    <!-- Label for Phone usage time -->
    <string name="usage_type_phone" product="tablet">Tablet</string>
    <!-- Label for Phone usage time -->
    <string name="usage_type_phone" product="default">Phone</string>
    <!-- Label for Data sent -->
    <string name="usage_type_data_send">Data sent</string>
    <!-- Label for Data received -->
    <string name="usage_type_data_recv">Data received</string>
    <!-- Label for Audio usage time -->
    <string name="usage_type_audio">Audio</string>
    <!-- Label for Video usage time -->
    <string name="usage_type_video">Video</string>
    <!-- Label for time that a feature has been on -->
    <string name="usage_type_on_time">Time on</string>
    <!-- Label for time that there was no cell coverage -->
    <string name="usage_type_no_coverage">Time without a signal</string>
    <!-- Label for force stop action -->
    <string name="battery_action_stop">Force stop</string>
    <!-- Label for app details action -->
    <string name="battery_action_app_details">App info</string>
    <!-- Label for app settings action -->
    <string name="battery_action_app_settings">App settings</string>
    <!-- Label for display settings -->
    <string name="battery_action_display">Screen settings</string>
    <!-- Label for wifi settings -->
    <string name="battery_action_wifi">Wi-Fi settings</string>
    <!-- Label for bluetooth settings -->
    <string name="battery_action_bluetooth">Bluetooth settings</string>

    <!-- Description for voice call detail -->
    <string name="battery_desc_voice">Battery used by voice calls</string>

    <!-- Description for standby detail -->
    <string name="battery_desc_standby" product="tablet">Battery used when tablet is idle</string>
    <!-- Description for standby detail -->
    <string name="battery_desc_standby" product="default">Battery used when phone is idle</string>

    <!-- Description for cell radio detail -->
    <string name="battery_desc_radio">Battery used by cell radio</string>
    <!-- Suggestion to switch to airplane mode to save power -->
    <string name="battery_sugg_radio">Switch to airplane mode to save power in areas with no cell coverage</string>

    <!-- Description for power consumed by display -->
    <string name="battery_desc_display">Battery used by the display and backlight</string>
    <!-- Suggestion for reducing display power -->
    <string name="battery_sugg_display">Reduce the screen brightness and/or screen timeout</string>

    <!-- Description for wifi connectivity -->
    <string name="battery_desc_wifi">Battery used by Wi-Fi</string>
    <!-- Suggestion for wifi connectivity power drain -->
    <string name="battery_sugg_wifi">Turn off Wi-Fi when not using it or when it isn\'t available</string>

    <!-- Description for bluetooth power consumption detail -->
    <string name="battery_desc_bluetooth">Battery used by Bluetooth</string>
    <!-- Suggestion for bluetooth -->
    <string name="battery_sugg_bluetooth_basic">Turn off Bluetooth when you aren\'t using it</string>
    <!-- Suggestion for bluetooth headset -->
    <string name="battery_sugg_bluetooth_headset">Try connecting to a different Bluetooth device</string>

    <!-- [CHAR LIMIT=50] Description for power consumed by applications -->
    <string name="battery_desc_apps">Battery used by app</string>
    <!-- Suggestion for exploring application info to stop or uninstall -->
    <string name="battery_sugg_apps_info">Stop or uninstall the app</string>
    <!-- [CHAR LIMIT=100] Suggestion for getting apps to consume less power due to GPS-->
    <string name="battery_sugg_apps_gps">"Manually control GPS to prevent app from using it"</string>
    <!-- Suggestion for getting apps to consume less power -->
    <string name="battery_sugg_apps_settings">The app may offer settings to reduce battery use</string>

    <!-- Menu label for viewing battery usage since unplugged -->
    <string name="menu_stats_unplugged"><xliff:g id="unplugged">%1$s</xliff:g> since unplugged</string>
    <!-- Menu label for viewing battery usage since unplugged -->
    <string name="menu_stats_last_unplugged">While last unplugged for <xliff:g id="unplugged">%1$s</xliff:g></string>
    <!-- Menu label for viewing battery usage total -->
    <string name="menu_stats_total">Usage totals</string>
    <!-- Menu label for refreshing with latest usage numbers -->
    <string name="menu_stats_refresh">Refresh</string>

    <!-- Label for kernel threads -->
    <string name="process_kernel_label">Android OS</string>
    <!-- Label for mediaserver process -->
    <string name="process_mediaserver_label">Mediaserver</string>

    <!-- Voice input/output settings --><skip />
    <!-- Title of setting on main settings screen. This item will take the user to the screen to tweak settings related to speech functionality -->
    <string name="voice_input_output_settings">Voice input &amp; output</string>
    <!-- Main voice input/output settings screen title -->
    <string name="voice_input_output_settings_title">Voice input &amp; output settings</string>
    <!-- Title of voice search settings list item within voice input/output settings -->
    <string name="voice_search_settings_title">Voice search</string>
    <!-- Title of keyboard settings list item within voice input/output settings -->
    <string name="keyboard_settings_title">Android keyboard</string>
    <!-- Title for the 'voice input' category of voice input/output settings -->
    <string name="voice_category">Speech</string>
    <!-- Title for the voice recognizer setting in voice input/output settings -->
    <string name="recognizer_title">Voice recognizer</string>
    <!-- Title for the link to settings for the chosen voice recognizer in voice input/output settings -->
    <string name="recognizer_settings_title">Voice Search</string>
    <!-- Summary for the link to settings for the chosen voice recognizer in voice input/output settings.
         Would say something like, e.g., "Settings for 'Google'". -->
    <string name="recognizer_settings_summary">Settings for \'<xliff:g id="recognizer_name">%s</xliff:g>\'</string>

    <!-- Text-To-Speech (TTS) settings --><skip />
    <!-- Name of the TTS package as listed by the package manager. -->
    <string name="tts_settings">Text-to-speech settings</string>
    <!-- TTS option item name in the main settings screen -->
    <string name="tts_settings_title">Text-to-speech output</string>
    <!-- On main TTS Settings screen, title for toggle used to force use of default TTS settings -->
    <string name="use_default_tts_settings_title">Always use my settings</string>
    <!-- On main TTS Settings screen, summary for toggle used to force use of default TTS settings -->
    <string name="use_default_tts_settings_summary">Default settings below override app settings</string>
    <!-- On main TTS Settings screen, section header for default TTS settings -->
    <string name="tts_default_settings_section">Default settings</string>
    <!-- On main TTS Settings screen, in default settings section, setting default synthesis engine for synthesized voice -->
    <string name="tts_default_synth_title">Default engine</string>
    <!-- On main TTS Settings screen, summary for default synthesis engine for synthesized voice -->
    <string name="tts_default_synth_summary">Sets the speech synthesis engine to be used for spoken text</string>
    <!-- On main TTS Settings screen, in default settings section, setting default speech rate for synthesized voice -->
    <string name="tts_default_rate_title">Speech rate</string>
    <!-- On main TTS Settings screen, summary for default speech rate for synthesized voice -->
    <string name="tts_default_rate_summary">Speed at which the text is spoken</string>
    <!-- On main TTS Settings screen, in default settings section, setting default pitch for synthesized voice -->
    <string name="tts_default_pitch_title">Pitch</string>
    <!-- On main TTS Settings screen, summary for default pitch for synthesized voice -->
    <string name="tts_default_pitch_summary">Affects the tone of the spoken text</string>
    <!-- On main TTS Settings screen, in default settings section, setting default language for synthesized voice -->
    <string name="tts_default_lang_title">Language</string>
    <!-- On main TTS Settings screen, summary for default language for synthesized voice -->
    <string name="tts_default_lang_summary">Sets the language-specific voice for the spoken text</string>
    <!-- On main TTS Settings screen, triggers playback of an example of speech synthesis -->
    <string name="tts_play_example_title">Listen to an example</string>
    <!-- On main TTS Settings screen, summary for triggering playback of an example of speech synthesis -->
    <string name="tts_play_example_summary">Play a short demonstration of speech synthesis</string>
    <!-- On main TTS Settings screen, click to install required speech synthesis data -->
    <string name="tts_install_data_title">Install voice data</string>
    <!-- On main TTS Settings screen, summary for click to install required speech synthesis data -->
    <string name="tts_install_data_summary">Install the voice data required for speech synthesis</string>
    <!-- On main TTS Settings screen, summary for when required speech synthesis data alrady installed on SD card -->
    <string name="tts_data_installed_summary">Voices required for speech synthesis already properly installed</string>
    <!-- Text spoken by the TTS engine when TTS settings (other than language) have been changed -->
    <string name="tts_settings_changed_demo">Your settings have changed. This is an example of how they sound.</string>
    <!-- Error screen when a selected TTS engine can't run because it's missing components -->
    <string name="tts_engine_error">The engine you chose can\'t run.</string>
    <!-- Button text for error screen when a selected TTS engine can't run because it's missing components -->
    <string name="tts_engine_error_config">Configure</string>
    <!-- Button text for error screen when a selected TTS engine can't run because it's missing components -->
    <string name="tts_engine_error_reselect">Choose another engine</string>
    <!-- Warning message about security implications of enabling a TTS engine, displayed as a dialog
         message when the user selects to enable an engine. -->
    <string name="tts_engine_security_warning">This speech synthesis engine may be able to collect
    all the text that will be spoken, including personal data like passwords and credit
    card numbers. It comes from the <xliff:g id="tts_plugin_engine_name">%s</xliff:g> engine.
    Enable the use of this speech synthesis engine?</string>
    <!-- On main TTS Settings screen, text for divider under which all TTS engines are listed -->
    <string name="tts_engines_section">Engines</string>
    <!-- On main TTS Settings screen, text preceded by the TTS engine name, clicking this button will launch the engine settings -->
    <string name="tts_engine_name_settings"><xliff:g id="tts_plugin_engine_name">%s</xliff:g> settings</string>
    <!-- On main TTS Settings screen, text preceded by the TTS engine name to indicate the engine can be used by the user -->
    <string name="tts_engine_name_is_enabled_summary"><xliff:g id="tts_plugin_engine_name">%s</xliff:g> is enabled</string>
    <!-- On main TTS Settings screen, text preceded by the TTS engine name to indicate the engine cannot be used by the user -->
    <string name="tts_engine_name_is_disabled_summary"><xliff:g id="tts_plugin_engine_name">%s</xliff:g> is disabled</string>
    <!-- On the main TTS settings screen, text for a divider under which
         the engine specific settings and the "engine install data" option
         are listed [CHAR LIMIT=30]-->
    <string name="tts_engine_settings_section">Engine settings</string>
    <!-- Title for a preference in the main TTS settings screen, which
         launches the settings screen for a given TTS engine when clicked
         [CHAR LIMIT=30]-->
    <string name="tts_engine_settings_title">Settings for <xliff:g id="tts_engine_name">%s</xliff:g></string>
    <!-- On Pico TTS Settings screen, text to mark the section for the various languages and voices that are available -->
    <string name="pico_languages_and_voices">Languages and voices</string>
    <!-- On Pico TTS Settings screen, text to mark a voice as installed -->
    <string name="pico_installed">Installed</string>
    <!-- On Pico TTS Settings screen, text to mark a voice as not installed -->
    <string name="pico_not_installed">Not installed</string>
    <!-- On Pico TTS Settings screen, summary text to indicate that a voice is female -->
    <string name="pico_voice_summary_female">Female</string>
    <!-- On Pico TTS Settings screen, summary text to indicate that a voice is male -->
    <string name="pico_voice_summary_male">Male</string>
    <!-- [CHAR LIMIT=33] Notification title that appears when the installation of a new TTS engine completed -->
    <string name="tts_notif_engine_install_title">Speech synthesis engine installed</string>
    <!-- [CHAR LIMIT=30] Notification message that appears after the user has installed a new TTS engine,
         to warn the user that this engine cannot be used before the checkbox for that engine
         in TTS settings is checked. -->
    <string name="tts_notif_engine_install_message">Enable new engine before use.</string>
    <!-- [CHAR LIMIT=150] Text for screen readers / accessibility programs for
         the image that launches the TTS engine settings when clicked. -->
    <string name="tts_engine_settings_button">Launch engine settings</string>
    <!-- [CHAR LIMIT=50] The text for the settings section that users to set a
         preferred text to speech engine -->
    <string name="tts_engine_preference_section_title">Preferred engine</string>
    <!-- [CHAR LIMIT=50] Title of the settings section that displays general preferences
         that are applicable to all engines, such as the speech rate -->
    <string name="tts_general_section_title">General</string>

    <!-- Power Control Widget -->
    <string name="gadget_title">Power control</string>
    <string name="gadget_toggle_wifi">Updating Wi-Fi setting</string>
    <string name="gadget_toggle_bluetooth">Updating Bluetooth setting</string>

    <!-- Title of preference to enter the VPN settings activity -->
    <string name="vpn_settings_title">VPN</string>

    <!-- Title of preference group for credential storage settings [CHAR LIMIT=30] -->
    <string name="credentials_title">Credential storage</string>
    <!-- Title of preference to install certificates from SD card [CHAR LIMIT=30] -->
    <string name="credentials_install" product="nosdcard">Install from storage</string>
    <!-- Title of preference to install certificates from SD card [CHAR LIMIT=30] -->
    <string name="credentials_install" product="default">Install from SD card</string>
    <!-- Summary of preference to install certificates from SD card [CHAR LIMIT=NONE] -->
    <string name="credentials_install_summary" product="nosdcard">Install certificates from storage</string>
    <!-- Summary of preference to install certificates from SD card [CHAR LIMIT=NONE] -->
    <string name="credentials_install_summary" product="default">Install certificates from SD card</string>
    <!-- Title of preference to reset credential storage [CHAR LIMIT=30] -->
    <string name="credentials_reset">Clear credentials</string>
    <!-- Summary of preference to reset credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_summary">Remove all certificates</string>
    <!-- Title of preference to display trusted credentials (aka CA certificates) [CHAR LIMIT=30] -->
    <string name="trusted_credentials">Trusted credentials</string>
    <!-- Summary of preference to display trusted credentials (aka CA certificates) [CHAR LIMIT=NONE] -->
    <string name="trusted_credentials_summary">Display trusted CA certificates</string>

    <!-- Message to draw an unlock pattern when installing credentials -->
    <string name="credentials_install_gesture_prompt">Draw your unlock pattern</string>
    <!-- Explanation of drawing unlock pattern to install credentials -->
    <string name="credentials_install_gesture_explanation">You need to draw your unlock pattern to confirm credential installation.</string>

    <!-- Title of dialog to enable credential storage [CHAR LIMIT=30] -->
    <string name="credentials_unlock"></string>
    <!-- Description of dialog to enable credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_unlock_hint">Type the password for credential storage.</string>
    <!-- Description of the input box for the old password [CHAR LIMIT=30] -->
    <string name="credentials_old_password">Current password:</string>
    <!-- Description of dialog to reset credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_hint">Remove all the contents?</string>
    <string name="credentials_password_too_short">The password must have at least 8 characters.</string>
    <!-- Error message [CHAR LIMIT=NONE] -->
    <string name="credentials_wrong_password">Incorrect password.</string>
    <!-- Error message [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_warning">Incorrect password. You have one more chance before credential storage is erased.</string>
    <!-- Error message [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_warning_plural">Incorrect password. You have <xliff:g id="number" example="5">%1$d</xliff:g> more chances before credential storage is erased.</string>
    <!-- Toast message [CHAR LIMIT=30] -->
    <string name="credentials_erased">Credential storage is erased.</string>
    <!-- Toast message [CHAR LIMIT=30] when credential storage containing private keys and certificates could not be erased (opposite of string credentials_erased) -->
    <string name="credentials_not_erased">Credential storage couldn\'t be erased.</string>
    <!-- Toast message [CHAR LIMIT=30] -->
    <string name="credentials_enabled">Credential storage is enabled.</string>
    <!-- Description of dialog to explain that a lock screen password is required to use credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_configure_lock_screen_hint">You need to set a lock screen PIN or password before you can use credential storage.</string>

    <!-- Sound settings screen, setting check box label -->
    <string name="emergency_tone_title">Emergency tone</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="emergency_tone_summary">Set behavior when an emergency call is placed</string>

    <!-- Backup and reset Settings screen --><skip />
    <!-- Backup and reset settings menu title -->
    <string name="privacy_settings">Backup &amp; reset</string>
    <!-- Privacy settings activity title -->
    <string name="privacy_settings_title">Backup &amp; reset</string>
    <!-- Backup section title -->
    <string name="backup_section_title">Backup &amp; restore</string>
    <!-- Personal data section title -->
    <string name="personal_data_section_title">Personal data</string>
    <!-- Backup data menu title -->
    <string name="backup_data_title">Back up my data</string>
    <!-- Summary text of the "back up data" setting -->
    <string name="backup_data_summary">Back up app data, Wi-Fi passwords, and other settings to Google servers</string>
    <!-- Configure backup account options menu title [CHAR LIMIT=25]-->
    <string name="backup_configure_account_title">Backup account</string>
    <!-- Default summary text of the "Configure backup account" setting [CHAR LIMIT=80]-->
    <string name="backup_configure_account_default_summary">No account is currently storing backed up data</string>
    <!-- Auto-restore menu title -->
    <string name="auto_restore_title">Automatic restore</string>
    <!-- Summary text of the "automatic restore" setting -->
    <string name="auto_restore_summary">When reinstalling an app, restore backed up settings and data</string>

    <!-- Local (desktop) backup password menu title [CHAR LIMIT=25] -->
    <string name="local_backup_password_title">Desktop backup password</string>
    <!-- Summary text of the "local backup password" setting when the user has not supplied a password -->
    <string name="local_backup_password_summary_none">Desktop full backups aren\'t currently protected</string>
    <!-- Summary text of the "local backup password" setting when the user has already supplied a password -->
    <string name="local_backup_password_summary_change">Touch to change or remove the password for desktop full backups</string>

    <!-- Toast message shown when the user successfully sets a new local backup password [CHAR LIMIT=80] -->
    <string name="local_backup_password_toast_success">New backup password set</string>
    <!-- Toast message shown when setting a new local backup password fails due to the user not correctly typing the password again for confirmation [CHAR LIMIT=80] -->
    <string name="local_backup_password_toast_confirmation_mismatch">New password and confirmation don\'t match</string>
    <!-- Toast message shown when setting a new local backup password fails due to the user not supplying the correct existing password. The phrasing here is deliberately quite general. [CHAR LIMIT=80] -->
    <string name="local_backup_password_toast_validation_failure">Failure setting backup password</string>

    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_title"></string>
    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_message">Stop backing up your Wi-Fi passwords, bookmarks, other settings, and app data, plus erase all copies on Google servers?</string>

    <!-- Device admin settings screen --><skip />
    <!-- Device admin settings activity title -->
    <string name="device_admin_settings_title">Device administration settings</string>
    <!-- Label for screen showing the active device policy -->
    <string name="active_device_admin_msg">Device administrator</string>
    <!-- Label for button to remove the active device admin -->
    <string name="remove_device_admin">Deactivate</string>
    <!-- Label for screen showing to select device policy -->
    <string name="select_device_admin_msg">Device administrators</string>
    <!-- Message when there are no available device admins to display -->
    <string name="no_device_admins">No available device administrators</string>

    <!-- Label for screen showing to add device policy -->
    <string name="add_device_admin_msg">Activate device administrator?</string>
    <!-- Label for button to set the active device admin -->
    <string name="add_device_admin">Activate</string>
    <!-- Device admin add activity title -->
    <string name="device_admin_add_title">Device administrator</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_warning">Activating this administrator will allow
        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_status">This administrator is active and allows
        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>

    <!-- Name to assign to a Network Access Point that was saved without a name -->
    <string name="untitled_apn">Untitled</string>

    <string name="sound_category_sound_title">General</string>
    <string name="sound_category_notification_title">Notifications</string>

    <!-- Category title for phone call's ringtone and vibration settings in the Sound Setting.
         [CHAR LIMIT=40] -->
    <string name="sound_category_call_ringtone_vibrate_title">Call ringtone &amp; vibrate</string>

    <!-- Category title for system-wide notification and feedback settings in the Sound Setting.
         [CHAR LIMIT=40] -->
    <string name="sound_category_system_title">System</string>

    <!-- Wifi Setup For Setup Wizard with XL screen -->
    <!-- Title shown in Wifi Setup Wizard with XL screen -->
    <string name="wifi_setup_title">Wi-Fi setup</string>
    <!-- Title shown in Wifi Setup Wizard with XL screen when
         a user is configuring password for a network.
         The argument should be the name of the network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_editing_network">Connect to Wi-Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
    <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
         the device is connecting a network the user specified.
         The argument should be the name of the network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_connecting_network">Connecting to Wi-Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g>\u2026</string>
    <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
         the device successfully connected to a network the user specified.
         The argument should be the name of the network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_connected_network">Connected to Wi-Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
    <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
         a user is adding a network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_add_network">Add a network</string>
    <!-- Text message shown when Wifi is not connected.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_not_connected">Not connected</string>
    <!-- Button message shown on the button adding manual setting.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_add_network">Add network</string>
    <!-- Button message shown on the button refreshing a list of network.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_refresh_list">Refresh list</string>
    <!-- Button message shown on the button enabling users skip Wifi Setup.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_skip">Skip</string>
    <!-- Button message shown on the button enabling users go the next step.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_next">Next</string>
    <!-- Button label to go back to previous screen. Used in SetupWizard for
      XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_back">Back</string>
    <!-- Button label to show detailed dialog for a selected Wi-Fi settings.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=20] -->
    <string name="wifi_setup_detail">Network details</string>
    <!-- Button label to connect to a Wi-Fi network.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_connect">Connect</string>
    <!-- Button label to delete a Wi-Fi network.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_forget">Forget</string>
    <!-- Button label to save a Wi-Fi network configuration.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_save">Save</string>
    <!-- Button label to dismiss the dialog.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_cancel">Cancel</string>

    <!-- The message shown above available networks when the device is scanning
         available networks [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_scanning">Scanning networks\u2026</string>
    <!-- Message shown above available network when there's no connected network.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_status_select_network">Touch a network to connect to it</string>
    <!-- Message shown above available networks when a user clicked one of available
         networks and the UI is showing one possible existing network.
         Used in Wifi Setup. -->
    <string name="wifi_setup_status_existing_network">Connect to existing network</string>
    <!-- Message shown above available networks when a user clicked one of available
         networks and the network doesn't require configuration (e.g. password)
         Used in Wifi Setup with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_unsecured_network">Connect to unsecured network</string>
    <!-- Message shown above available networks when a user clicked one of available
         networks and the UI is prompting the user to edit the network configuration
         if needed. Used in Wifi Setup with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_edit_network">Type network configuration</string>
    <!-- The message shown above available networks when a user clicked "Add network"
         button. Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_new_network">Connect to new network</string>
    <!-- The message shown above available networks when a user clicked one of available
         networks or created another profile and he/she is waiting for the connection
         is established.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_connecting">Connecting\u2026</string>
    <!-- The message shown above available networks when connection is established,
         letting a user to proceed to the next step of the SetupWizard.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_proceed_to_next">Go to the next step</string>
    <!-- The message shown above available networks when a user clicked a network secured by
         EAP. We don't allow the user to connect it.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_eap_not_supported">EAP isn\'t supported.</string>
    <!-- Message shown when users select EAP in Wi-Fi settings for SetupWizard,
         saying EAP can't be configured in SetupWizard flow.
         [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_eap_not_supported">You can\'t configure an EAP Wi-Fi connection during setup. After setup, you can do that in Settings &gt; Wireless &amp; networks.</string>
    <!-- Message shown when the device is connecting a network [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_description_connecting">Connecting can take a few minutes\u2026</string>
    <!-- Message shown when the device is connected to a network [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_description_connected">Touch <b>Next</b> to continue with setup.\n\nTouch <b>Back</b> to connect to a different Wi-Fi network.</string>

    <!-- Do not translate. This is a stub which will be removed soon. -->
    <string name="time_zone_auto_stub" translatable="false">Select Time Zone</string>

    <!-- Content description of the enabled sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_enabled">Sync enabled</string>
    <!-- Content description of the disabled sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_disabled">Sync disabled</string>
    <!-- Content description of the disabled sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_error">Sync error.</string>
    <!-- Image description for the sync failed icon. -->
    <string name="sync_failed">Sync failed</string>
    <!-- Animation description for the sync active icon. -->
    <string name="sync_active">Sync active</string>

    <!-- Account specific sync settings title [CHAR LIMIT=35] -->
    <string name="account_sync_settings_title">Sync</string>
    <!-- Message when sync is currently failing [CHAR LIMIT=100] -->
    <string name="sync_is_failing">Sync is currently experiencing problems. It will be back shortly.</string>
    <!-- Button label to add an account [CHAR LIMIT=20] -->
    <string name="add_account_label">Add account</string>
    <!-- Data synchronization settings screen, title of setting that controls whether background data should be used [CHAR LIMIT=30] -->
    <string name="background_data">Background data</string>
    <!-- Data synchronization settings screen, summary of setting that controls whether background data should be used [CHAR LIMIT=60] -->
    <string name="background_data_summary">Apps can sync, send, and receive data at any time</string>
    <!-- Data synchronization settings screen, title of dialog that confirms the user's unchecking of background data [CHAR LIMIT=20] -->
    <string name="background_data_dialog_title">Disable background data?</string>
    <!-- Data synchronization settings screen, message of dialog that confirms the user's unchecking of background data [CHAR LIMIT=200] -->
    <string name="background_data_dialog_message">Disabling background data extends battery life and lowers data use. Some apps may still use the background data connection.</string>
    <!-- Title for a checkbox that enables data synchronization in the account and sync screen [CHAR LIMIT=35] -->
    <string name="sync_automatically">Auto-sync app data</string>

    <!-- Sync status messages on Accounts & Synchronization settings --><skip />
    <!-- Sync status shown when sync is enabled [CHAR LIMIT=25] -->
    <string name="sync_enabled">Sync is ON</string>
    <!-- Sync status shown when sync is disabled [CHAR LIMIT=25] -->
    <string name="sync_disabled">Sync is OFF</string>
    <!-- Sync status shown when last sync resulted in an error [CHAR LIMIT=25] -->
    <string name="sync_error">Sync error</string>
    <!-- Last synced date/time for accounts that synced [CHAR LIMIT=none] -->
    <string name="last_synced">Last synced <xliff:g id="last_sync_time">%1$s</xliff:g></string>
    <!-- Sync status shown when sync is disabled [CHAR LIMIT=30] -->
    <string name="sync_in_progress">Syncing now\u2026</string>

    <!-- Data synchronization settings screen, setting option name -->
    <string name="settings_backup">Back up settings</string>
    <!-- Data synchronization settings screen, setting option summary text when check box is selected -->
    <string name="settings_backup_summary">Back up my settings</string>
    <!-- Data synchronization settings screen, menu option -->
    <string name="sync_menu_sync_now">Sync now</string>
    <!-- Data synchronization settings screen, menu option -->
    <string name="sync_menu_sync_cancel">Cancel sync</string>
    <!-- Data synchronization settings screen, summary of a sync provider (for example, Gmail) when autosync is off and the user wants to do a one-time sync. -->
    <string name="sync_one_time_sync">Touch to sync now<xliff:g id="last_sync_time">\n%1$s</xliff:g></string>
    <!-- Data synchronization settings screen, checkbox setting option name. Controls whether Gmail should be synced.  Should use "Gmail" to refer to this app.-->
    <string name="sync_gmail">Gmail</string>
    <!-- Data synchronization settings screen, checkbox setting option name. Controls whether Calendar shoudl be synced. -->
    <string name="sync_calendar">Calendar</string>
    <!-- Data synchronization settings screen, checkbox setting option name -->
    <string name="sync_contacts">Contacts</string>
    <!-- Message introducing the user to Google Sync. -->
    <string name="sync_plug"><font fgcolor="#ffffffff">Welcome to Google sync!</font>
    \nA Google approach to syncing data to allow access to your contacts, appointments, and more from wherever you are.
    </string>

    <!-- Header title for those settings relating to application syncing. -->
    <string name="header_application_sync_settings">App sync settings</string>

    <!-- Header for data and synchronization -->
    <string name="header_data_and_synchronization">Data &amp; synchronization</string>
    <!-- Preference item that lets the user change password -->
    <string name="preference_change_password_title">Change password</string>
    <!-- Header that appears at the top of Account Settings screen -->
    <string name="header_account_settings">Account settings</string>
    <!-- Button label to remove current account -->
    <string name="remove_account_label">Remove account</string>
    <!-- Title shown in AddAccount -->
    <string name="header_add_an_account">Add an account</string>
    <!-- Button shown when this activity is run from SetupWizard -->
    <string name="finish_button_label">Finish</string>
    <!-- Title of remove message for remove account dialog -->
    <string name="really_remove_account_title">Remove account?</string>
    <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
    <string name="really_remove_account_message" product="tablet">Removing this account will delete all of its messages, contacts, and other data from the tablet!</string>
    <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
    <string name="really_remove_account_message" product="default">Removing this account will delete all of its messages, contacts, and other data from the phone!</string>
    <!-- This is shown if the autheticator for a given account fails to remove it. -->
    <string name="remove_account_failed" product="tablet">This account is required by some apps. You can only remove it by resetting the tablet to factory defaults (which deletes all your personal data) in Settings &gt; Backup &amp; reset.</string>
    <!-- This is shown if the autheticator for a given account fails to remove it. -->
    <string name="remove_account_failed" product="default">This account is required by some apps. You can only remove it by resetting the phone to factory defaults (which deletes all your personal data) in Settings &gt; Backup &amp; reset.</string>
    <!-- What to show in messaging that refers to this provider, e.g. AccountSyncSettings -->
    <string name="provider_label">Push subscriptions</string>
    <!-- Formatter in AccountSyncSettings for each application we wish to synchronize, e.g. "Sync Calendar" -->
    <string name="sync_item_title"><xliff:g id="authority" example="Calendar">%s</xliff:g></string>
    <!-- Title of dialog shown when you can't manually sync an item because it's disabled -->
    <string name="cant_sync_dialog_title">Can\'t manually sync</string>
    <!-- Messaage shown in dialog when you can't manually sync -->
    <string name="cant_sync_dialog_message">Sync for this item is currently disabled. To change this setting, temporarily turn on background data and automatic sync.</string>

    <string name="wimax_settings">4G settings</string>
    <string name="wimax_settings_summary">Set up &amp; manage 4G network and modem</string>
    <string name="status_wimax_mac_address">4G MAC address</string>
    <!-- This is displayed to the user when the device needs to be decrypted -->
    <string name="enter_password">Type password to decrypt storage</string>
    <!-- This is displayed when the password is entered incorrectly -->
    <string name="try_again">Try again.</string>

    <!-- the following are for Settings Storage screen -->
    <!-- Menu item/button 'delete' -->
    <string name="delete">Delete</string>
    <!-- Misc files [CHAR LIMIT=25] -->
    <string name="misc_files">Misc files</string>
    <!-- number of misc files selected [CHAR LIMIT=40] -->
    <string name="misc_files_selected_count">selected <xliff:g id="number" example="3">%1$d</xliff:g> out of <xliff:g id="total" example="15">%2$d</xliff:g></string>
    <!-- number of bytes represented by the selected misc files [CHAR LIMIT=40] -->
    <string name="misc_files_selected_count_bytes"><xliff:g id="number" example="3.25MB">%1$s</xliff:g> out of <xliff:g id="total" example="15.25MB">%2$s</xliff:g></string>
    <!--  action to select all [CHAR LIMIT=30] -->
    <string name="select_all">Select all</string>

    <!-- HDCP checking title, used for debug purposes only. [CHAR LIMIT=25] -->
    <string name="hdcp_checking_title">HDCP checking</string>
    <!-- HDCP checking dialog title, used for debug purposes only. [CHAR LIMIT=25] -->
    <string name="hdcp_checking_dialog_title">Set HDCP checking behavior</string>

    <!-- Preference category for app debugging development settings. [CHAR LIMIT=50] -->
    <string name="debug_debugging_category">Debugging</string>

    <!-- UI debug setting: select current app to debug [CHAR LIMIT=50] -->
    <string name="debug_app">Select debug app</string>
    <!-- UI debug setting: no debug app has been set [CHAR LIMIT=50] -->
    <string name="debug_app_not_set">No debug application set</string>
    <!-- UI debug setting: debug app has been set [CHAR LIMIT=50] -->
    <string name="debug_app_set">Debugging application: <xliff:g id="app_name">%1$s</xliff:g></string>

    <!-- UI debug setting: title for app picker dialog [CHAR LIMIT=50] -->
    <string name="select_application">Select application</string>
    <!-- UI debug setting: label for app picker to select no applicatiojn [CHAR LIMIT=50] -->
    <string name="no_application">Nothing</string>

    <!-- UI debug setting: wait for debugger to attach to debugging process? [CHAR LIMIT=50] -->
    <string name="wait_for_debugger">Wait for debugger</string>
    <!-- UI debug setting: wait for debugger to attach to debugging process summary [CHAR LIMIT=500] -->
    <string name="wait_for_debugger_summary">Debugged application waits for debugger to
            attach before executing</string>

    <!-- Preference category for input debugging development settings. [CHAR LIMIT=25] -->
    <string name="debug_input_category">Input</string>

    <!-- Preference category for drawing debugging development settings. [CHAR LIMIT=25] -->
    <string name="debug_drawing_category">Drawing</string>

    <!-- Preference category for monitoring debugging development settings. [CHAR LIMIT=25] -->
    <string name="debug_monitoring_category">Monitoring</string>

    <!-- UI debug setting: always enable strict mode? [CHAR LIMIT=25] -->
    <string name="strict_mode">Strict mode enabled</string>
    <!-- UI debug setting: show strict mode summary [CHAR LIMIT=50] -->
    <string name="strict_mode_summary">Flash screen when apps do long operations
            on main thread</string>

    <!-- UI debug setting: show pointer location? [CHAR LIMIT=25] -->
    <string name="pointer_location">Pointer location</string>
    <!-- UI debug setting: show pointer location summary [CHAR LIMIT=50] -->
    <string name="pointer_location_summary">Screen overlay showing current touch data</string>

    <!-- UI debug setting: show touches? [CHAR LIMIT=25] -->
    <string name="show_touches">Show touches</string>
    <!-- UI debug setting: show touches location summary [CHAR LIMIT=50] -->
    <string name="show_touches_summary">Show visual feedback for touches</string>

    <!-- UI debug setting: show where surface updates happen? [CHAR LIMIT=25] -->
    <string name="show_screen_updates">Show surface updates</string>
    <!-- UI debug setting: show surface updates summary [CHAR LIMIT=50] -->
    <string name="show_screen_updates_summary">Flash entire window surfaces when they update</string>

    <!-- UI debug setting: show where window updates happen with GPU rendering? [CHAR LIMIT=25] -->
    <string name="show_hw_screen_updates">Show GPU view updates</string>
    <!-- UI debug setting: show GPU rendering screen updates summary [CHAR LIMIT=50] -->
    <string name="show_hw_screen_updates_summary">Flash views inside windows when drawn with the GPU</string>

    <!-- UI debug setting: disable use of overlays? [CHAR LIMIT=25] -->
    <string name="disable_overlays">Disable HW overlays</string>
    <!-- UI debug setting: disable use of overlays summary [CHAR LIMIT=50] -->
    <string name="disable_overlays_summary">Always use GPU for screen compositing</string>

    <!-- UI debug setting: enable low-level traces? [CHAR LIMIT=25] -->
    <string name="enable_traces_title">Enable traces</string>
    <!-- UI debug setting: title for dialog to enable low-level traces [CHAR LIMIT=25] -->
    <string name="enable_traces_dialog_title">Select enabled traces</string>

    <!-- UI debug setting: enable low-level traces, none enabled summary [CHAR LIMIT=NONE] -->
    <string name="enable_traces_summary_none">No traces currently enabled</string>
    <!-- UI debug setting: enable low-level traces, some number enabled summary [CHAR LIMIT=NONE] -->
    <string name="enable_traces_summary_num"><xliff:g id="num">%1$d</xliff:g> traces currently enabled</string>
    <!-- UI debug setting: enable low-level traces, all enabled summary [CHAR LIMIT=NONE] -->
    <string name="enable_traces_summary_all">All traces currently enabled</string>

    <!-- UI debug setting: show layout bounds information [CHAR LIMIT=25] -->
    <string name="debug_layout">Show layout bounds</string>
    <!-- UI debug setting: show layout bounds information summary [CHAR LIMIT=50] -->
    <string name="debug_layout_summary">Show clip bounds, margins, etc.</string>

    <!-- UI debug setting: show how CPU is being used? [CHAR LIMIT=25] -->
    <string name="show_cpu_usage">Show CPU usage</string>
    <!-- UI debug setting: show cpu usage summary [CHAR LIMIT=50] -->
    <string name="show_cpu_usage_summary">Screen overlay showing current CPU usage</string>

    <!-- UI debug setting: force hardware acceleration to render apps [CHAR LIMIT=25] -->
    <string name="force_hw_ui">Force GPU rendering</string>
    <!-- UI debug setting: force hardware acceleration summary [CHAR LIMIT=50] -->
    <string name="force_hw_ui_summary">Force use of GPU for 2d drawing</string>

    <!-- UI debug setting: profile time taken by hardware acceleration to render apps [CHAR LIMIT=25] -->
    <string name="track_frame_time">Profile GPU rendering</string>
    <!-- UI debug setting: profile hardware acceleration summary [CHAR LIMIT=50] -->
    <string name="track_frame_time_summary">Measure rendering time in adb shell dumpsys gfxinfo</string>

    <!-- UI debug setting: scaling factor for window animations [CHAR LIMIT=25] -->
    <string name="window_animation_scale_title">Window animation scale</string>

    <!-- UI debug setting: scaling factor for transition animations [CHAR LIMIT=25] -->
    <string name="transition_animation_scale_title">Transition animation scale</string>

    <!-- UI debug setting: scaling factor for all Animator-based animations [CHAR LIMIT=25] -->
    <string name="animator_duration_scale_title">Animator duration scale</string>

    <!-- Preference category for application debugging development settings. [CHAR LIMIT=25] -->
    <string name="debug_applications_category">Apps</string>

    <!-- UI debug setting: immediately destroy activities? [CHAR LIMIT=25] -->
    <string name="immediately_destroy_activities">Don\'t keep activities</string>
    <!-- UI debug setting: immediately destroy activities summary [CHAR LIMIT=50] -->
    <string name="immediately_destroy_activities_summary">Destroy every activity as soon as
            the user leaves it</string>

    <!-- UI debug setting: limit number of running background processes [CHAR LIMIT=25] -->
    <string name="app_process_limit_title">Background process limit</string>

    <!-- UI debug setting: show all ANRs? [CHAR LIMIT=25] -->
    <string name="show_all_anrs">Show all ANRs</string>
    <!-- UI debug setting: show all ANRs summary [CHAR LIMIT=50] -->
    <string name="show_all_anrs_summary">Show App Not Responding dialog
        for background apps</string>

    <!-- Activity title for network data usage summary. [CHAR LIMIT=25] -->
    <string name="data_usage_summary_title">Data usage</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] -->
    <string name="data_usage_menu_roaming">Data roaming</string>
    <!-- Title for checkbox menu option to restrict background data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_restrict_background">Restrict background data</string>
    <!-- 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-Fi usage</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] -->
    <string name="data_usage_menu_metered">Mobile hotspots</string>
    <!--  Title for menu option to enable global auto-sync of account data -->
    <string name="data_usage_menu_auto_sync">Auto-sync data</string>

    <!-- Title for option to change data usage cycle day. [CHAR LIMIT=32] -->
    <string name="data_usage_change_cycle">Change cycle\u2026</string>
    <!-- Body of dialog prompting user to change numerical day of month that data usage cycle should reset. [CHAR LIMIT=64] -->
    <string name="data_usage_pick_cycle_day">Day of month to reset data usage cycle:</string>
    <!-- Label shown when no applications used data during selected time period. [CHAR LIMIT=48] -->
    <string name="data_usage_empty">No apps used data during this period.</string>
    <!-- Label for data usage occuring while application in foreground. [CHAR LIMIT=48] -->
    <string name="data_usage_label_foreground">Foreground</string>
    <!-- Label for data usage occuring while application in background. [CHAR LIMIT=48] -->
    <string name="data_usage_label_background">Background</string>

    <!-- Label for application which has its data usage restricted. [CHAR LIMIT=16] -->
    <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>
    <!-- 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>
    <!-- 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] -->
    <string name="data_usage_disable_3g_limit">Set 2G-3G data limit</string>
    <!-- Checkbox label that will disable Wi-Fi network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_wifi_limit">Set Wi-Fi data limit</string>

    <!-- Tab title for showing Wi-Fi data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_wifi">Wi-Fi</string>
    <!-- Tab title for showing Ethernet data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_ethernet">Ethernet</string>
    <!-- Tab title for showing combined mobile data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_mobile">Mobile</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>
    <!-- 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>
    <!-- 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>

    <!-- 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>
    <!-- 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>
    <!-- Summary message for checkbox that restricts background data usage of a specific application when no networks have been limited. [CHAR LIMIT=64] -->
    <string name="data_usage_app_restrict_background_summary_disabled">To restrict background data for this app, first set a mobile data limit.</string>
    <!-- Title of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=48] -->
    <string name="data_usage_app_restrict_dialog_title">Restrict background data?</string>
    <!-- Body of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_app_restrict_dialog">This feature may cause an app that depends on background data to stop working when only mobile 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>
    <!--  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] -->
    <string name="data_usage_auto_sync_on_dialog" product="tablet">Any changes you make to your accounts on the web will be automatically copied to your tablet.\n\nSome accounts may also automatically copy any changes you make on the tablet to the web. A Google Account works this way.\n\nTo choose which kinds of information to sync within each account, go to Settings &gt; Accounts.</string>
    <!--  Body of dialog shown when user enables global auto sync [CHAR LIMIT=none] -->
    <string name="data_usage_auto_sync_on_dialog" product="default">Any changes you make to your accounts on the web will be automatically copied to your phone.\n\nSome accounts may also automatically copy any changes you make on the phone to the web. A Google Account works this way.\n\nTo choose which kinds of information to sync within each account, go to Settings &gt; Accounts.</string>
    <!--  Title of dialog shown when user disables global auto sync [CHAR LIMIT=32] -->
    <string name="data_usage_auto_sync_off_dialog_title">Turn auto-sync data off?</string>
    <!--  Body of dialog shown when user disables global auto sync [CHAR LIMIT=none] -->
    <string name="data_usage_auto_sync_off_dialog">This will conserve data and battery usage, but you\'ll need to sync each account manually to collect recent information. And you won\'t receive notifications when updates occur.</string>

    <!-- Title of dialog for editing data usage cycle reset date. [CHAR LIMIT=48] -->
    <string name="data_usage_cycle_editor_title">Usage cycle reset date</string>
    <!-- Subtitle of dialog for editing data usage cycle reset date. [CHAR LIMIT=32] -->
    <string name="data_usage_cycle_editor_subtitle">Date of each month:</string>
    <!-- Positive button title for data usage cycle editor, confirming that changes should be saved. [CHAR LIMIT=32] -->
    <string name="data_usage_cycle_editor_positive">Set</string>

    <!-- Title of dialog for editing data usage warning in bytes. [CHAR LIMIT=48] -->
    <string name="data_usage_warning_editor_title">Set data usage warning</string>
    <!-- Title of dialog for editing data usage limit in bytes. [CHAR LIMIT=48] -->
    <string name="data_usage_limit_editor_title">Set data usage limit</string>

    <!-- 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>
    <!-- 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>

    <!-- 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-Fi network.</string>

    <!-- Label displaying current network data usage warning threshold. [CHAR LIMIT=18] -->
    <string name="data_usage_sweep_warning"><font size="21"><xliff:g id="number" example="128">^1</xliff:g></font> <font size="9"><xliff:g id="unit" example="KB">^2</xliff:g></font>\n<font size="12">warning</font></string>
    <!-- Label displaying current network data usage limit threshold. [CHAR LIMIT=18] -->
    <string name="data_usage_sweep_limit"><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">limit</font></string>

    <!-- Title of data usage item that represents all uninstalled applications. [CHAR LIMIT=48] -->
    <string name="data_usage_uninstalled_apps">Removed apps</string>
    <!-- Combination of total network bytes sent and received by an application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_received_sent"><xliff:g id="received" example="128KB">%1$s</xliff:g> received, <xliff:g id="sent" example="1.3GB">%2$s</xliff:g> sent</string>
    <!-- Label displaying total network data transferred during a specific time period. [CHAR LIMIT=64] -->
    <string name="data_usage_total_during_range"><xliff:g id="range" example="Jul 1 - Jul 31">%2$s</xliff:g>: about <xliff:g id="total" example="128KB">%1$s</xliff:g> used.</string>

    <!-- Label displaying total network data transferred during a specific time period, including a disclaimer that contrasts device versus carrier reporting. [CHAR LIMIT=80] -->
    <string name="data_usage_total_during_range_mobile" product="tablet"><xliff:g id="range" example="Jul 1 - Jul 31">%2$s</xliff:g>: about <xliff:g id="total" example="128KB">%1$s</xliff:g> used, as measured by your tablet. Your carrier\'s data usage accounting may differ.</string>
    <!-- Label displaying total network data transferred during a specific time period, including a disclaimer that contrasts device versus carrier reporting. [CHAR LIMIT=80] -->
    <string name="data_usage_total_during_range_mobile" product="default"><xliff:g id="range" example="Jul 1 - Jul 31">%2$s</xliff:g>: about <xliff:g id="total" example="128KB">%1$s</xliff:g> used, as measured by your phone. Your carrier\'s data usage accounting may differ.</string>

    <!-- Dialog title for selecting metered networks. [CHAR LIMIT=25] -->
    <string name="data_usage_metered_title">Mobile hotspots</string>
    <!-- Dialog body for selecting paid networks. [CHAR LIMIT=NONE] -->
    <string name="data_usage_metered_body">Select the Wi-Fi 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>
    <!-- Header for list of Wi-Fi networks. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_wifi">Wi-Fi networks</string>
    <!-- Body text prompting user to enable Wi-Fi to configure metered networks. [CHAR LIMIT=64] -->
    <string name="data_usage_metered_wifi_disabled">To select mobile hotspots, turn Wi-Fi on.</string>

    <!-- Button at the bottom of the CryptKeeper screen to make an emergency call. -->
    <string name="cryptkeeper_emergency_call">Emergency call</string>
    <!-- Button at the bottom of the CryptKeeper screen that lets the user return to a call -->
    <string name="cryptkeeper_return_to_call">Return to call</string>

    <!-- Input label for the name of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_name">Name</string>
    <!-- Input label for the type of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_type">Type</string>
    <!-- Input label for the server address of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_server">Server address</string>
    <!-- Checkbox label to enable PPP encryption for a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_mppe">PPP encryption (MPPE)</string>
    <!-- Input label for the L2TP secret of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_l2tp_secret">L2TP secret</string>
    <!-- Input label for the IPSec identifier of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_identifier">IPSec identifier</string>
    <!-- Input label for the IPSec pre-shared key of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_secret">IPSec pre-shared key</string>
    <!-- Selection label for the IPSec user certificate of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_user_cert">IPSec user certificate</string>
    <!-- Selection label for the IPSec CA certificate of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_ca_cert">IPSec CA certificate</string>
    <!-- Selection label for the IPSec server certificate of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_server_cert">IPSec server certificate</string>
    <!-- Checkbox label to show advanced options of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_show_options">Show advanced options</string>
    <!-- Input label for the DNS search domains of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_search_domains">DNS search domains</string>
    <!-- Input label for the DNS servers of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_dns_servers">DNS servers (e.g. 8.8.8.8)</string>
    <!-- Input label for the forwarding routes of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_routes">Forwarding routes (e.g. 10.0.0.0/8)</string>
    <!-- Input label for the username of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_username">Username</string>
    <!-- Input label for the password of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_password">Password</string>
    <!-- Checkbox label to save the username and the password in a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_save_login">Save account information</string>
    <!-- Hint for not using an optional feature in a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_not_used">(not used)</string>
    <!-- Option to not use a CA certificate to verify the VPN server. [CHAR LIMIT=40] -->
    <string name="vpn_no_ca_cert">(don\'t verify server)</string>
    <!-- Option to use the server certificate received from the VPN server. [CHAR LIMIT=40] -->
    <string name="vpn_no_server_cert">(received from server)</string>

    <!-- Button label to cancel changing a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_cancel">Cancel</string>
    <!-- Button label to save a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_save">Save</string>
    <!-- Button label to connect to a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_connect">Connect</string>
    <!-- Dialog title to edit a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_edit">Edit VPN profile</string>
    <!-- Dialog title to connect to a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_connect_to">Connect to <xliff:g id="profile" example="School">%s</xliff:g></string>

    <!-- Preference title for VPN settings. [CHAR LIMIT=40] -->
    <string name="vpn_title">VPN</string>
    <!-- Preference title to create a new VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_create">Add VPN profile</string>
    <!-- Menu item to edit a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_menu_edit">Edit profile</string>
    <!-- Menu item to delete a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_menu_delete">Delete profile</string>

    <!-- Toast message when there is no network connection to start VPN. [CHAR LIMIT=100] -->
    <string name="vpn_no_network">There is no network connection. Please try again later.</string>
    <!-- Toast message when a certificate is missing. [CHAR LIMIT=100] -->
    <string name="vpn_missing_cert">A certificate is missing. Please edit the profile.</string>

    <!-- Tab label for built-in system CA certificates. -->
    <string name="trusted_credentials_system_tab">System</string>
    <!-- Tab label for user added CA certificates. -->
    <string name="trusted_credentials_user_tab">User</string>
    <!-- Button label for disabling a system CA certificate. -->
    <string name="trusted_credentials_disable_label">Disable</string>
    <!-- Button label for enabling a system CA certificate. -->
    <string name="trusted_credentials_enable_label">Enable</string>
    <!-- Button label for removing a user CA certificate. -->
    <string name="trusted_credentials_remove_label">Remove</string>
    <!-- Alert dialog confirmation when enabling a system CA certificate. -->
    <string name="trusted_credentials_enable_confirmation">Enable the system CA certificate?</string>
    <!-- Alert dialog confirmation when disabling a system CA certificate. -->
    <string name="trusted_credentials_disable_confirmation">Disable the system CA certificate?</string>
    <!-- Alert dialog confirmation when removing a user CA certificate. -->
    <string name="trusted_credentials_remove_confirmation">Permanently remove the user CA certificate?</string>

    <!--  Title for spell checker settings -->
    <string name="spellcheckers_settings_title">Spell checker</string>

    <!-- Prompt for the user to enter their current full-backup password -->
    <string name="current_backup_pw_prompt">Type your current full backup password here</string>
    <!-- Prompt for the user to enter a new full-backup password -->
    <string name="new_backup_pw_prompt">Type a new password for full backups here</string>
    <!-- Prompt for the user to confirm the new full-backup password by re-entering it -->
    <string name="confirm_new_backup_pw_prompt">Retype your new full backup password here</string>

    <!-- Button label for setting the user's new full-backup password -->
    <string name="backup_pw_set_button_text">Set backup password</string>
    <!-- Button label for cancelling the new-password operation and retaining the user's previous full-backup password -->
    <string name="backup_pw_cancel_button_text">Cancel</string>

    <!-- Representation of a numerical percentage. [CHAR LIMIT=8] -->
    <string name="percentage"><xliff:g id="number" example="30">%d</xliff:g>%%</string>

    <!-- A menu item in "About phone" that allows the user to update the phone with settings
    from their cell phone carrier. The use of the string is similar to the string
    "system_update_settings_list_item_title" in this project. [CHAR LIMIT=25] -->
    <string name="additional_system_update_settings_list_item_title">Additional system updates</string>

    <!-- User settings -->
    <skip/>

    <!-- User settings screen title [CHAR LIMIT=25] -->
    <string name="user_settings_title">Users &amp; restrictions</string>
    <!-- User settings user list section header [CHAR LIMIT=30] -->
    <string name="user_list_title">Users</string>
    <!-- User settings add user menu [CHAR LIMIT=20] -->
    <string name="user_add_user_menu">Add user</string>

    <!-- User details -->
    <skip/>

    <!-- User details screen title [CHAR LIMIT=25] -->
    <string name="user_details_title">Edit details</string>
    <!-- User information section title [CHAR LIMIT=30] -->
    <string name="user_information_heading">User information</string>
    <!-- User name title [CHAR LIMIT=25] -->
    <string name="user_name_title">Name</string>
    <!-- User restrictions section title [CHAR LIMIT=30] -->
    <string name="user_restrictions_heading">Content restrictions</string>
    <!-- User restrictions, does market require PIN protection [CHAR LIMIT=30] -->
    <string name="user_market_requires_pin">Require PIN</string>
    <!-- User restrictions, maximum content rating for apps [CHAR LIMIT=25] -->
    <string name="user_max_content_rating">Content rating</string>
    <!-- Section title for list of system apps [CHAR LIMIT=30] -->
    <string name="user_system_apps_heading">System apps</string>
    <!-- Section title for list of downloaded apps [CHAR LIMIT=30] -->
    <string name="user_market_apps_heading">Installed apps</string>
    <!-- User details discard user menu [CHAR LIMIT=20] -->
    <string name="user_discard_user_menu">Discard</string>
    <!-- User details remove user menu [CHAR LIMIT=20] -->
    <string name="user_remove_user_menu">Remove user</string>
    <!-- User details new user name [CHAR LIMIT=30] -->
    <string name="user_new_user_name">Pesky kid</string>
    <!-- User removal confirmation title [CHAR LIMIT=25] -->
    <string name="user_confirm_remove_title">Remove user?</string>
    <!-- User removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_message">Are you sure you want to remove the user and all associated data from the device?</string>

    <!-- Label for are-notifications-enabled checkbox in app details [CHAR LIMIT=20] -->
    <string name="app_notifications_switch_label">Show notifications</string>

    <!--  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>
    <!-- Help URL, WiFi [DO NOT TRANSLATE] -->
    <string name="help_url_wifi" translatable="false"></string>
    <!-- Help URL, Bluetooth [DO NOT TRANSLATE] -->
    <string name="help_url_bluetooth" translatable="false"></string>
    <!-- Help URL, Data usage [DO NOT TRANSLATE] -->
    <string name="help_url_data_usage" translatable="false"></string>
    <!-- Help URL, More [DO NOT TRANSLATE] -->
    <string name="help_url_more_networks" translatable="false"></string>
    <!-- Help URL, Vpn [DO NOT TRANSLATE] -->
    <string name="help_url_vpn" translatable="false"></string>
    <!-- Help URL, Sound [DO NOT TRANSLATE] -->
    <string name="help_url_sound" translatable="false"></string>
    <!-- Help URL, Battery [DO NOT TRANSLATE] -->
    <string name="help_url_battery" translatable="false"></string>
    <!-- Help URL, Accounts [DO NOT TRANSLATE] -->
    <string name="help_url_accounts" translatable="false"></string>
    <!-- Help URL, Choose lockscreen [DO NOT TRANSLATE] -->
    <string name="help_url_choose_lockscreen" translatable="false"></string>
    <!-- Help URL, Backup & reset [DO NOT TRANSLATE] -->
    <string name="help_url_backup_reset" translatable="false"></string>
    <!-- Help URL, Tethering [DO NOT TRANSLATE] -->
    <string name="help_url_tether" translatable="false"></string>

    <!-- Cell Broadcast settings title [CHAR LIMIT=50] -->
    <string name="cell_broadcast_settings">Cell broadcasts</string>
    <!-- Cell Broadcast settings description [CHAR LIMIT=100] -->
    <string name="cell_broadcast_settings_summary">Select the types of emergency alerts to display.</string>
</resources>
