<?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>
    <!-- Strings for Dialog allow button -->
    <string name="allow">Allow</string>
    <!-- Strings for Dialog deny button -->
    <string name="deny">Deny</string>

    <!-- Strings for Dialog close button [CHAR LIMIT=20] -->
    <string name="dlg_close">Close</string>
    <!-- Strings for Dialog switch button [CHAR LIMIT=20] -->
    <string name="dlg_switch">Switch</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>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Countdown for user taps to enable development settings -->
    <plurals name="show_dev_countdown">
        <item quantity="one">You are now <xliff:g id="step_count">%1$d</xliff:g> step away from being a developer.</item>
        <item quantity="other">You are now <xliff:g id="step_count">%1$d</xliff:g> steps away from being a developer.</item>
    </plurals>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Confirmation that developer settings are enabled -->
    <string name="show_dev_on">You are now a developer!</string>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Okay we get it, stop pressing, you already have it on -->
    <string name="show_dev_already">No need, you are already a developer.</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. Wireless and networks (Wi-Fi, Bluetooth, data usage...). [CHAR LIMIT=40] -->
    <string name="header_category_connections">Connections</string>
    <!-- Settings main menu category heading. Device (Sound, display, battery, applications...). [CHAR LIMIT=40] -->
    <string name="header_category_device">Device</string>
    <!-- Settings main menu category heading. Personal (Accounts, security, language, backup...). [CHAR LIMIT=40] -->
    <string name="header_category_personal">Personal</string>
    <!-- Settings main menu category heading. Personal (Accounts, security, language, backup...). [CHAR LIMIT=40] -->
    <string name="header_category_access">Access</string>
    <!-- Settings main menu category heading. System (Updates, data, accessibility, about phone). [CHAR LIMIT=40] -->
    <string name="header_category_system">System</string>

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

    <!-- VoLTE provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="volte_provisioned_flag_on">Turn on VoLTE provisioned flag</string>
    <!-- VoLTE provisioning flag off. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="volte_provisioned_flag_off">Turn off VoLTE provisioned flag</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. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_unknown">Unknown</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging from an unknown source.  -->
    <string name="battery_info_status_charging">Charging</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging on AC.  -->
    <string name="battery_info_status_charging_ac">Charging on AC</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging over USB.  -->
    <string name="battery_info_status_charging_usb">Charging over USB</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging over a wireless connection.  -->
    <string name="battery_info_status_charging_wireless">Charging wirelessly</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">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_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>

    <!-- Used as setting title (for checkbox) on second screen after selecting Bluetooth settings -->
    <string name="bluetooth">Bluetooth</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, option name to pick discoverability timeout duration (a list dialog comes up) -->
    <string name="bluetooth_visibility_timeout">Visibility timeout</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">Rename this device</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. text displayed when user has restriction DISALLOW_CONFIG_BLUETOOTH [CHAR LIMIT=NONE]-->
    <string name="bluetooth_empty_list_user_restricted">You don\u2019t have permission to change Bluetooth settings.</string>

    <!-- Bluetooth Visibility message.  This message informs the user that their device is now visible to other bluetooth devices.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_is_visible_message"><xliff:g id="device_name">%1$s</xliff:g> is visible to nearby devices while Bluetooth settings is open.</string>
    <!-- Bluetooth Visibility discoonect question.  Asks the user if they wish to disconnect a paired bluetooth device.  [CHAR LIMIT=50] -->
    <string name="bluetooth_is_disconnect_question">Disconnect <xliff:g id="device_name">%1$s</xliff:g>?</string>
    <!-- Bluetooth broadcasting settings, option to enable/disable broadcasting -->
    <string name="bluetooth_broadcasting">Broadcasting</string>
    <!-- Bluetooth settings.  Dialog title to disable a single profile of a device. [CHAR LIMIT=40] -->
    <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 the device state is unknown -->
    <string name="bluetooth_unknown" />
    <!--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 [CHAR LIMIT=40]-->
    <string name="device_picker">Choose Bluetooth device</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>

    <!-- This string asks the user whether or not to allow an app to enable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_enablement">An app wants to turn Bluetooth ON for this device.</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 wants to make your tablet visible to other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</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 wants to make your phone visible to other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</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 wants to make your tablet visible to other Bluetooth devices. You can change this later in Bluetooth settings.</string>
    <string name="bluetooth_ask_lasting_discovery" product="default">An app wants to make your phone visible to other Bluetooth devices. You can change this later in Bluetooth settings.</string>

    <!-- Strings for asking to the user whether to allow an app to start broadcasting -->
    <string name="bluetooth_ask_start_broadcast" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth broadcasting to communicate with other devices nearby. You can change this later in Bluetooth settings.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and start broadcasting -->
    <string name="bluetooth_ask_enablement_and_start_broadcast" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and Bluetooth broadcasting to communicate with other devices nearby. You can change this later in Bluetooth settings.</string>
    <!-- Strings for bluetooth broadcasting explanation -->
    <string name="bluetooth_broadcasting_explaination" product="default">When this feature is turned on, your phone can communicate with other devices nearby.\n\nBroadcasting uses low-power Bluetooth signals.</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 wants to turn on Bluetooth and make your tablet visible to other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</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 wants to turn on Bluetooth and make your phone visible to other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</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 wants to turn on Bluetooth and make your tablet visible to other devices. You can change this later in Bluetooth settings.</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default">An app wants to turn on Bluetooth and make your phone visible to other devices. You can change this later in Bluetooth settings.</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 access 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_remember_choice">Don\u2019t ask again</string>
    <!--FIXME SHOULD BE REMOVED AND ALL LANG VERSIONS FIXED TO ABOVE NAME -->
    <string name="bluetooth_pb_remember_choice">Don\u2019t ask again</string>

    <!-- Activity label of BluetoothMessagePermissionActivity, also used as Strings in the permission dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_map_request">"Message access request"</string>

    <!-- Bluetooth message permission Alert Activity text [CHAR LIMIT=none] -->
    <string name="bluetooth_map_acceptance_dialog_text">%1$s wants to access your messages. Give access to %2$s?</string>

    <!-- Activity label of BluetoothMessagePermissionActivity for SIM access profile. Also used as Strings in the permission dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_sap_request">"SIM access request"</string>

    <!-- Bluetooth SIM access permission Alert Activity text [CHAR LIMIT=none] -->
    <string name="bluetooth_sap_acceptance_dialog_text"><xliff:g id="device_name">%1$s</xliff:g> wants to access your SIM card. Granting access to the SIM card will disable data connectivity on your device for the duration of the connection. Give access to <xliff:g id="device_name">%2$s?</xliff:g></string>

    <!-- Date & time settings screen title -->
    <string name="date_and_time">Date &amp; time</string>
    <!-- The title of the activity to pick a time zone. -->
    <string name="choose_timezone">Choose time zone</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</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\u2019t 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\u2019t 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\u2019t 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>

    <!-- HTTP proxy settings. Title for Proxy-Auto Config URL.  [CHAR LIMIT=25] -->
    <string name="proxy_url_title">"PAC URL: "</string>
    <!-- HTTP proxy settings. Hint for Proxy-Auto Config URL. -->
    <string name="proxy_url_hint" translatable="false">https://www.example.com/proxy.pac</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_cellinfo_label">CellInfo:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_dcrtinfo_label">DcRtInfo:</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\u2019s 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\u2019s 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>
    <!-- Used in setup wizard Wi-Fi screen.  The button label for going to the next screen without submitting. [CHAR LIMIT=20] -->
    <string name="skip_label">Skip</string>
    <!-- Used in setup wizard Wi-Fi screen. The button label for going to the next screen and submitting. [CHAR LIMIT=20] -->
    <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 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 [CHAR LIMIT=20] -->
    <string name="cancel">Cancel</string>
    <!-- Button label for generic OK action [CHAR LIMIT=20] -->
    <string name="okay">OK</string>
    <!-- Button label for generic forget action [CHAR LIMIT=20] -->
    <string name="forget">Forget</string>
    <!-- Button label for generic save action [CHAR LIMIT=20] -->
    <string name="save">Save</string>
    <!-- Button label for generic done action [CHAR LIMIT=20] -->
    <string name="done">Done</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.  [CHAR LIMIT=30] -->
    <string name="radio_controls_title">More</string>
    <!-- Wireless Settings screen title for things like Wi-Fi, bluetooth, airplane mode. -->
    <string name="wireless_networks_settings_title">Wireless &amp; networks</string>
    <!-- Main Settings screen settings summary text for the "Wireless controls" setting -->
    <string name="radio_controls_summary">Manage Wi\u2011Fi, Bluetooth, airplane mode, cellular networks, &amp; VPNs</string>

    <!-- check box cellular data title [CHAR LIMIT=30] -->
    <string name="cellular_data_title">Cellular data</string>
    <!-- check box Calls title [CHAR LIMIT=30] -->
    <string name="calls_title">Calls</string>
    <!-- check box SMS Messges title [CHAR LIMIT=30] -->
    <string name="sms_messages_title">SMS messages</string>
    <!-- check box cellular data summary [CHAR LIMIT=41] -->
    <string name="cellular_data_summary">Allow data usage over cellular network</string>
    <!-- check box to allow data usage when roaming [CHAR LIMIT=41] -->
    <string name="allow_data_usage_title">Allow data usage when roaming</string>
    <!-- mobile network settings screen, setting check box title -->
    <string name="roaming">Data roaming</string>
    <!-- mobile network settings screen, setting option summary text when check box is selected -->
    <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, message in dialog box that appears when you select the "Data roaming" check box. This is for multiuser tablets [CHAR LIMIT=none] -->
    <string name="roaming_warning_multiuser" product="tablet">When you allow data roaming, you may incur significant roaming charges!\n\nThis setting affects all users on this tablet.</string>
    <!-- mobile network settings screen, message in dialog box that appears when you select the "Data roaming" check box. This is for multiuser phones [CHAR LIMIT=none] -->
    <string name="roaming_warning_multiuser" product="default">When you allow data roaming, you may incur significant roaming charges!\n\nThis setting affects all users on this phone.</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=30] -->
    <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=30] -->
    <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 [CHAR LIMIT=30] -->
    <string name="date_time_24hour_title">24\u2011hour format</string>
    <!-- Date & time setting screen setting check box title -->
    <string name="date_time_24hour">Use 24-hour format</string>
    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
    <string name="date_time_set_time_title">Time</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_time">Set time</string>
    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
    <string name="date_time_set_timezone_title">Time zone</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_timezone">Select time zone</string>
    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
    <string name="date_time_set_date_title">Date</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_date">Set date</string>
    <!-- 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, 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>
    <!-- Security settings screen, setting option summary to change screen timeout, with additional explanation-->
    <string name="lock_immediately_summary_with_exception">Immediately after sleep, except when kept unlocked by <xliff:g id="trust_agent_name">%1$s</xliff:g></string>
    <!-- Security settings screen, setting option summary to change screen timeout, with additional explanation-->
    <string name="lock_after_timeout_summary_with_exception"><xliff:g id="timeout_string">%1$s</xliff:g> after sleep, except when kept unlocked by <xliff:g id="trust_agent_name">%2$s</xliff:g></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">Lock screen message</string>
    <!-- Text shown for title of settings checkbox to enable widgets [CHAR LIMIT=20]-->
    <string name="security_enable_widgets_title">Enable widgets</string>
    <!-- Summary for settings checkbox to disable widgets when the setting has been disabled by an installed device admin [CHAR LIMIT=50] -->
    <string name="security_enable_widgets_disabled_summary">Disabled by administrator</string>
    <!-- Text shown for summary of owner info setting (if none set) [CHAR LIMIT=40]-->
    <string name="owner_info_settings_summary">None</string>
    <!-- Description of how many characters are used in owner info [CHAR LIMIT=40]-->
    <string name="owner_info_settings_status"><xliff:g id="count" example="90">%1$d</xliff:g> / <xliff:g id="count" example="100">%2$d</xliff:g></string>
    <!-- Hint text shown in owner info edit text [CHAR LIMIT=50] -->
    <string name="owner_info_settings_edit_text_hint">E.g., Joe\u2019s Android.</string>
    <!-- Text shown for title of user info setting [CHAR LIMIT=20]-->
    <string name="user_info_settings_title">User info</string>
    <!-- Text shown next to checkbox for showing profile info on LockScreen [CHAR LIMIT=50]-->
    <string name="show_profile_info_on_lockscreen_label">Show profile info on lock screen</string>
    <!-- Text shown for title of profile info setting [CHAR LIMIT=20]-->
    <string name="profile_info_settings_title">Profile info</string>
    <!-- Main Settings screen setting option title for the item to take you to the Accounts screen [CHAR LIMIT=22] -->
    <string name="Accounts_settings_title">Accounts</string>
    <!-- Main Settings screen setting option title for the item to take you to the location screen -->
    <string name="location_settings_title">Location</string>
    <!-- Main Settings screen setting option title for the item to take you to the accounts screen [CHAR LIMIT=22] -->
    <string name="account_settings_title">Accounts</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>

    <!-- Fingerprint enrollment and settings --><skip />
    <!-- Title shown for menu item that launches fingerprint settings or enrollment [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_preference_title">Fingerprint</string>
    <!-- Fingerprint managment category title - configuration options for managing enrolled fingerprints [CHAR LIMIT=22] -->
    <string name="fingerprint_manage_category_title">Manage fingerprints</string>
    <!-- Fingerprint category title - configuration options for managing fingerprint enrollment [CHAR LIMIT=22] -->
    <string name="fingerprint_usage_category_title">Use fingerprint for</string>
    <!-- Preference to add another fingerprint -->
    <string name="fingerprint_add_title">Add fingerprint</string>
    <!-- switch for allowing fingerprint to be used for keyguard -->
    <string name="fingerprint_enable_keyguard_toggle_title">screen lock</string>
    <!-- message shown for menu item that launches fingerprint settings or enrollment -->
    <plurals name="security_settings_fingerprint_preference_summary">
        <item quantity="one"><xliff:g id="count">%1$d</xliff:g> fingerprint set up</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> fingerprints set up</item>
    </plurals>
    <!-- message shown in summary field when no fingerprints are registered -->
    <string name="security_settings_fingerprint_preference_summary_none"></string>
    <!-- Introduction title shown in fingerprint enrollment dialog [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_onboard_title">Fingerprint setup</string>
    <!-- Introduction message shown in fingerprint enrollment dialog when the user needs to choose an
         alternate screen unlock (pin, pattern or password) as a backup to fingerprint. -->
    <string name="security_settings_fingerprint_enroll_onboard_message">To use your fingerprint to unlock your screen or confirm purchases, you\u2019ll need to:</string>
    <!-- Introduction message shown in fingerprint enrollment dialog, first item to describe what
         the user needs to do. -->
    <string name="security_settings_fingerprint_enroll_onboard_message_1">Set up your backup screen lock method</string>
    <!-- Introduction message shown in fingerprint enrollment dialog, second item to describe what
         the user needs to do. -->
    <string name="security_settings_fingerprint_enroll_onboard_message_2">Add your fingerprint</string>
    <!-- Introduction title shown in fingerprint enrollment to introduce the fingerprint feature[CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_introduction_title">Unlock with fingerprint</string>
    <!-- Introduction detail message shown in fingerprint enrollment dialog [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message">Just touch the fingerprint sensor to unlock your phone, authorize purchases, or sign in to apps. Be careful whose fingerprints you add - any fingerprints added will be able to do these things.</string>
    <!-- Introduction detail message shown in fingerprint enrollment dialog to warn the user [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message_warning">Note: Your fingerprint may be less secure than a strong pattern or PIN.</string>
    <!-- Link text shown bellow the warning to learn morn about fingerprint risk [CHAR LIMIT=22]-->
    <string name="security_settings_fingerprint_enroll_introduction_risk_link_text">Learn more</string>
    <!-- Button text to cancel enrollment from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_cancel">Cancel</string>
    <!-- Button text to continue to the next screen from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_continue">Continue</string>
    <!-- Introduction title shown in fingerprint enrollment dialog to locate the sensor [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_find_sensor_title">Find the sensor</string>
    <!-- Message shown in fingerprint enrollment dialog to locate the sensor -->
    <string name="security_settings_fingerprint_enroll_find_sensor_message">
        Locate the fingerprint sensor on the back of your phone.</string>
    <!-- Content description of graphic that shows where the fingerprint of the device is [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description">Illustration with device and fingerprint sensor location</string>
    <!-- Label text shown in fingerprint dialog for renaming a fingerprint template [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_name_label">Name</string>
    <!-- Button text shown in fingerprint dialog that allows the user to rename a fingerprint template [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_ok">OK</string>
    <!-- Button text shown in fingerprint dialog that allows the user to delete the fingerprint template [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_delete">Delete</string>
    <!-- Title shown in fingerprint enrollment dialog to begin enrollment [CHAR LIMIT=29]-->
    <string name="security_settings_fingerprint_enroll_start_title">Let\u2019s start!</string>
    <!-- Message shown in fingerprint enrollment dialog to begin enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_start_message">Put your finger on the sensor and lift after you feel a vibration</string>
    <!-- Title shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_repeat_title">Great! Now repeat</string>
    <!-- Message shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_repeat_message">Move your finger slightly to add all the different parts of your fingerprint</string>
    <!-- Title shown in fingerprint enrollment dialog once enrollment is completed [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_finish_title">Fingerprint added!</string>
    <!-- Message shown in fingerprint enrollment dialog once enrollment is completed -->
    <string name="security_settings_fingerprint_enroll_finish_message">Whenever you see this icon, you can use your fingerprint for identification or to authorize a purchase.</string>
    <!-- Message shown when fingerprint enrollment is completed during setup wizard [CHAR LIMIT=NONE] -->
    <string name="setup_fingerprint_enroll_finish_message">Just touch the fingerprint sensor to wake and unlock your device.</string>
    <!-- Message shown when fingerprint enrollment is completed, telling user about the fingerprint icon that will be shown whenever they can use their fingerprint [CHAR LIMIT=NONE] -->
    <string name="setup_fingerprint_enroll_finish_message_secondary">When you see this icon, you can use your fingerprint.</string>
    <!-- Title of the dialog shown when the user tries to skip fingerprint setup, asking them to confirm the action [CHAR LIMIT=40] -->
    <string name="setup_fingerprint_enroll_enrolling_skip_title">Skip fingerprint setup?</string>
    <!-- Content of the dialog shown when the user tries to skip fingerprint setup, asking them to confirm the action [CHAR LIMIT=NONE] -->
    <string name="setup_fingerprint_enroll_enrolling_skip_message">You\u2019ve chosen to use your fingerprint as one way to unlock your phone. If you skip now, you\u2019ll need to set this up later. Setup takes only a minute or so.</string>

    <!-- Button text to setup screen lock in onboard dialog [CHAR LIMIT=34] -->
    <string name="security_settings_fingerprint_enroll_setup_screen_lock">Set up screen lock</string>
    <!-- Button text to exit fingerprint wizard after everything is done [CHAR LIMIT=15] -->
    <string name="security_settings_fingerprint_enroll_done">Done</string>
    <!-- Dialog title for dialog which shows when user touches the icon on the screen, instead of the sensor at the back [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_touch_dialog_title">Whoops, that\u2019s not the sensor</string>
    <!-- Dialog message for dialog which shows when user touches the icon on the screen, instead of the sensor at the back [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_touch_dialog_message">Use the fingerprint sensor on your device.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled. [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_error_dialog_title">Enrollment was not completed</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled due to being idle too long. -->
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message">Fingerprint enrollment time limit reached. Try again.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled due to an internal error or fingerprint can't be read. -->
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message">Fingerprint enrollment didn\'t work. Try again or use a different finger.</string>
    <!-- Button text shown at the end of enrollment that allows the user to add another fingerprint -->
    <string name="fingerprint_enroll_button_add">Add another</string>
    <!-- Button text shown at the end of enrollment that allows the user to move to the next step -->
    <string name="fingerprint_enroll_button_next">Next</string>
    <!-- Text shown in fingerprint settings explaining what the fingerprint can be used for. [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_disclaimer">In addition to unlocking your phone, you can also use your fingerprint to authorize purchases and app access. <annotation id="url">Learn more</annotation></string>
    <!-- Text shown in fingerprint settings explaining what the fingerprint can be used for in the case unlocking is disabled [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled">Screen lock option disabled. You can still use your fingerprint to authorize purchases and app access. <annotation id="url">Learn more</annotation></string>
    <!-- Text shown in fingerprint enroll when we didn't observe progress for a few seconds. [CHAR LIMIT=100] -->
    <string name="security_settings_fingerprint_enroll_lift_touch_again">Lift finger, then touch sensor again</string>

    <!-- Text shown when "Add fingerprint" button is disabled -->
    <string name="fingerprint_add_max">You can add up to <xliff:g id="count" example="5">%d</xliff:g> fingerprints</string>

    <!-- Title shown in a dialog which asks the user to confirm when the last fingerprint gets deleted by him. [CHAR LIMIT=35]-->
    <string name="fingerprint_last_delete_title">Remove all fingerprints?</string>

    <!-- Message shown in a dialog which asks the user to confirm when the last fingerprint gets deleted by him. [CHAR LIMIT=NONE]-->
    <string name="fingerprint_last_delete_message">You won\'t be able to use your fingerprints to unlock your phone, authorize purchases, or sign in to apps with them.</string>

    <!-- Button to confirm the last removing the last fingerprint. [CHAR LIMIT=20]-->
    <string name="fingerprint_last_delete_confirm">Yes, remove</string>

    <!-- Content description for the fingerprint icon when the user is prompted to enter his credentials. Not shown on the screen. [CHAR LIMIT=NONE] -->
    <string name="confirm_fingerprint_icon_content_description">Use your fingerprint to continue.</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 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. After you encrypt your tablet, assuming you\u2019ve set up a screen lock
    (that is, a pattern or numeric PIN or password), you\u2019ll need to unlock the screen to decrypt
    the tablet every time you power it on. The only other way to decrypt is to perform 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 throughout the process. If you interrupt it,
    you\u2019ll 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. After you encrypt your phone, assuming you\u2019ve set up a screen lock
    (that is, a pattern or numeric PIN or password), you\u2019ll need to unlock the screen to decrypt
    the phone every time you power it on. The only other way to decrypt is to perform 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 throughout the process. If you interrupt it,
    you\u2019ll 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\u2019ll 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\u2019ll 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>
    <string name="crypt_keeper_setup_time_remaining" product="tablet">Wait while your tablet
    is being encrypted. Time remaining: <xliff:g id="duration" example="1:23">^1</xliff:g></string>
    <string name="crypt_keeper_setup_time_remaining" product="default">Wait while your phone
    is being encrypted. Time remaining: <xliff:g id="duration" example="1:23">^1</xliff:g></string>

    <string name="crypt_keeper_force_power_cycle" product="tablet">To unlock your tablet, turn it off and then on.</string>
    <string name="crypt_keeper_force_power_cycle" product="default">To unlock your phone, turn it off and then on.</string>


    <!-- Warn user their device will be wiped if they make x more failed attempts -->
    <string name="crypt_keeper_warn_wipe">Warning: Your device will be wiped after
    <xliff:g id="count" example="7">^1</xliff:g> more failed attempts to be unlocked!
    </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\u2019t 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\u2019ll 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\u2019t 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\u2019ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Title of the encryption screen when decrypting the device failed -->
    <string name="crypt_keeper_data_corrupt_title">Decryption unsuccessful</string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_data_corrupt_summary" product="tablet">
      The password you entered is correct, but unfortunately your data is
      corrupt.
      \n\nTo resume using your tablet, you need to perform a factory reset.
      When you set up your tablet after the reset, you\u2019ll 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_data_corrupt_summary" product="default">
      The password you entered is correct, but unfortunately your data is
      corrupt.
      \n\nTo resume using your phone, you need to perform a factory reset.
      When you set up your phone after the reset, you\u2019ll 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>

    <!-- Message shown in screen lock picker while setting up the backup/fallback screen lock method for fingerprint. Users can choose to use this method to unlock the screen instead of fingerprint, or when fingerprint is not accepted. [CHAR LIMIT=80] [BACKUP_MESSAGE_ID=2799884038398627882] -->
    <string name="lock_settings_picker_fingerprint_message">Choose your backup screen lock method</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>

    <!-- 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">Swipe</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 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 specifying that this is the current screen lock setting [CHAR LIMIT=45] -->
    <string name="current_screen_lock">Current screen lock</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">Swipe</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>

    <!-- Footer text in when choosing screen lock type during setup wizard, telling the user that
         they can add fingerprint after they complete setup wizard. The text "Settings > Security"
         should match settings_label and security_settings_title [CHAR LIMIT=NONE] -->
    <string name="unlock_setup_wizard_fingerprint_details">Once you\u2019ve set up a screen lock, you can also set up your fingerprint in Settings &gt; Security.</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>

    <!-- Title of the dialog shown when the user removes the device lock [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_title">Remove device protection?</string>

    <!-- Content of the dialog shown when the user removes the device lock pattern [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern">"Device protection features will not work without your pattern."</string>
    <!-- Content of the dialog shown when the user removes the device lock pattern and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint">"Device protection features will not work without your pattern.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won't be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin">"Device protection features will not work without your PIN."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_fingerprint">"Device protection features will not work without your PIN.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won't be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the device lock password [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password">"Device protection features will not work without your password."</string>
    <!-- Content of the dialog shown when the user removes the device lock password and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_fingerprint">"Device protection features will not work without your password.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won't be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the device lock of unknown type [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown">"Device protection features will not work without your screen lock."</string>
    <!-- Content of the dialog shown when the user removes the device lock of unknown type and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint">"Device protection features will not work without your screen lock.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won't be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>

    <!-- Affirmative action of the dialog shown when the user removes the device lock [CHAR LIMIT=25] -->
    <string name="unlock_disable_frp_warning_ok">Yes, remove</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 digits</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\u2019t 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\u2019t allow using a recent password.</string>

    <!-- [CHAR_LIMIT=NONE] Error shown when the user tries to set an ascending or descending sequence of digits -->
    <string name="lockpassword_pin_no_sequential_digits">An ascending, descending or repeated sequence of digits is forbidden</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>

    <!-- Title of preference to manage trust agents -->
    <string name="manage_trust_agents">Trust agents</string>

    <!-- Summary shown when trust agent settings is disabled because the user hasn't set up primary security -->
    <string name="disabled_because_no_backup_security">To use, first set a screen lock</string>

    <!-- Summary of preference to manage device policies -->
    <string name="manage_trust_agents_summary">View or deactivate trust agents</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">Pair with <xliff:g id="device_name">%1$s</xliff:g>?</string>

    <!-- Message when bluetooth is informing the user of the pairing key. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_key_msg">Bluetooth pairing code</string>

    <!-- Message when bluetooth dialog for passkey entry is showing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_passkey_msg">Type the pairing code then press Return or Enter</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>

    <!-- Bluetooth PIN hint text (below the text entry box). [CHAR LIMIT=30] -->
    <string name="bluetooth_pin_values_hint_16_digits">Must be 16 digits</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>

    <!-- Checkbox message in pairing dialogs.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_shares_phonebook">Allow <xliff:g id="device_name">%1$s</xliff:g> to access your contacts and call history</string>

    <!-- Title for BT error dialogs. -->
    <string name="bluetooth_error_title"></string>

    <!-- Message for the error dialog when BT connecting operation fails generically. -->
    <string name="bluetooth_connecting_error_message">Couldn\u2019t 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">Refresh</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: Paired dialog title [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_title">Paired device</string>
    <!-- Bluetooth settings: Name label [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_name_label">Name</string>
    <!-- Bluetooth settings: Checkbox label for enable/disable internet connection.  [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_internet_option">Internet connection</string>
    <!-- Bluetooth settings: Checkbox label for enable/disable keyboard connection.  [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_keyboard_option">Keyboard</string>
    <!-- Bluetooth settings: Checkbox label for enable/disable contacts connection.  [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_contacts_option">Contacts and call history</string>
    <!-- Bluetooth settings: pairing dialog title.  [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_dialog_title">Pair with this device?</string>
    <!-- Bluetooth settings: share phone book title.  [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title">Share phone book?</string>
    <!-- Bluetooth settings: Message informing user that a bluetooth wants to access contant and call history.  [CHAR LIMIT=100] -->
    <string name="bluetooth_pairing_dialog_contants_request"><xliff:g id="device_name">%1$s</xliff:g> wants to access your contacts and call history.</string>
    <!-- Bluetooth settings: paring permission message.  [CHAR LIMIT=100] -->
    <string name="bluetooth_pairing_dialog_paring_request"><xliff:g id="device_name">%1$s</xliff:g> wants to pair with Bluetooth. When connected, it will have access to your contacts and call history.</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: The message displayed if no Bluetooth devices were found. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_no_found_devices">No devices available</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will connect to all profiles on the device. -->
    <string name="bluetooth_device_context_connect">Connect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect from all profiles on the device. -->
    <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">When Bluetooth is turned on, your device can communicate with other nearby Bluetooth devices.</string>
    <!-- Message to describe "BLE scan always available feature" when Bluetooth is off. The
      place-holders "LINK_BEGIN" and "LINK_END" must NOT be translated. They mark a link to bring
      the user to "scanning settings" screen. -->
    <string name="ble_scan_notify_text">To improve location accuracy, system apps and services can
      still detect Bluetooth devices. You can change this in
      <xliff:g id="link_begin">LINK_BEGIN</xliff:g>scanning
      settings<xliff:g id="link_end">LINK_END</xliff:g>.</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.  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\u2019s 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\u2019s 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.
         When a user decides what Bluetooth capabilities to use with the device.  -->
    <string name="bluetooth_device_advanced_profile_header_title">Use for</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 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.  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>

    <!-- Wifi Assistant title.  [CHAR LIMIT=40] -->
    <string name="wifi_assistant_title">Wi\u2011Fi Assistant</string>

    <!-- Wifi Display settings. The title of the screen. [CHAR LIMIT=40] -->
    <string name="wifi_display_settings_title">Cast</string>
    <!-- Wifi Display settings. The title of a menu item to enable wireless display [CHAR LIMIT=40] -->
    <string name="wifi_display_enable_menu_item">Enable wireless display</string>
    <!-- Wifi Display settings. Text that appears when scanning for devices is finished and no nearby device was found [CHAR LIMIT=40]-->
    <string name="wifi_display_no_devices_found">No nearby devices were found.</string>
    <!-- Wifi Display settings. The status summary for connecting devices. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_connecting">Connecting</string>
    <!-- Wifi Display settings. The status summary for connected devices. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_connected">Connected</string>
    <!-- Wifi Display settings. The status summary for devices that's already in use. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_in_use">In use</string>
    <!-- Wifi Display settings. The status summary for devices that's not available. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_not_available">Unavailable</string>
    <!-- Wifi Display settings. Image description for device details button. This opens the screen to rename, unpair, etc. a single device. -->
    <string name="wifi_display_details">Display settings</string>

    <!-- Wifi Display settings. Options dialog.  The title of the dialog. [CHAR LIMIT=40] -->
    <string name="wifi_display_options_title">Wireless display options</string>
    <!-- Wifi Display settings. Options dialog.  The forget button text. [CHAR LIMIT=20] -->
    <string name="wifi_display_options_forget">Forget</string>
    <!-- Wifi Display settings. Options dialog.  The done button text. [CHAR LIMIT=20] -->
    <string name="wifi_display_options_done">Done</string>
    <!-- Wifi Display settings. Options dialog.  The name label used when prompting the user to rename the display. [CHAR LIMIT=20] -->
    <string name="wifi_display_options_name">Name</string>

    <!-- Wifi Display settings. The sub heading for wireless display certification options. [CHAR LIMIT=40] -->
    <string name="wifi_display_certification_heading" translatable="false">Certification</string>
    <!-- Wifi Display settings. The section title for wireless display session info. [CHAR LIMIT=40] -->
    <string name="wifi_display_session_info" translatable="false">Session info</string>
    <!-- Wifi Display settings. The checkbox title for enabling listen mode during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_listen_mode" translatable="false">Enable listen mode</string>
    <!-- Wifi Display settings. The checkbox title for enabling autonomous GO during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_autonomous_go" translatable="false">Enable autonomous GO</string>
    <!-- Wifi Display settings. The button text for sending pause trigger during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_pause" translatable="false">Pause</string>
    <!-- Wifi Display settings. The button text for sending play (resume) trigger during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_resume" translatable="false">Resume</string>
    <!-- Wifi Display settings. The dropdown menu title for choosing WPS configuration during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_wps_config" translatable="false">WPS configuration</string>
    <!-- Wifi Display settings. The dropdown menu title for choosing listen channel during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_listen_channel" translatable="false">Listen channel</string>
    <!-- Wifi Display settings. The dropdown menu title for choosing operating channel during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_operating_channel" translatable="false">Operating channel</string>
    <!-- Wifi 2.4GHz is used as an universal itendifier for 2.4GHz band -->
    <string name="wifi_band_24ghz">2.4 GHz</string>
    <!-- Wifi Internal 5GHz as an universal itendifier for 5GHz band -->
    <string name="wifi_band_5ghz">5 GHz</string>
    <!-- Link speed on Wifi Status screen -->
    <string name="link_speed">%1$d Mbps</string>

    <!-- Wifi Alert message when tapping on a preference for a config locked down by device owner. [CHAR LIMIT=200] -->
    <string name="wifi_alert_lockdown_by_device_owner"><xliff:g id="app_name">%1$s</xliff:g> manages your device and doesn\u2019t allow modifying or deleting this Wi-Fi network. For more information, contact your administrator.</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\u2011Fi</string>
    <!-- Used in the 1st-level settings screen as the turn-on summary -->
    <string name="wifi_quick_toggle_summary">Turn on Wi\u2011Fi</string>
    <!-- Used in the 1st-level settings screen to go to the 2nd-level settings screen  [CHAR LIMIT=20]-->
    <string name="wifi_settings">Wi\u2011Fi</string>
    <!-- Title of the Wi-fi settings screen -->
    <string name="wifi_settings_category">Wi\u2011Fi settings</string>
    <!-- Title of the Wi-fi settings entry in the left top level menu -->
    <string name="wifi_settings_title">Wi\u2011Fi</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\u2011Fi network</string>
    <!-- Used by Account creation for turning on Wi-Fi  [CHAR LIMIT=60] -->
    <string name="wifi_select_network">Select Wi\u2011Fi</string>
    <!-- Summary text when turning Wi-Fi or bluetooth on -->
    <string name="wifi_starting">Turning Wi\u2011Fi on\u2026</string>
    <!-- Summary text when turning Wi-Fi or bluetooth off -->
    <string name="wifi_stopping">Turning off Wi\u2011Fi\u2026</string>
    <!-- Summary text when Wi-Fi or bluetooth has error -->
    <string name="wifi_error">Error</string>
    <!-- Summary text when wifi SoftAP started failed due to no legal usable channel allowed in this region by regulatory -->
    <string name="wifi_sap_no_channel_error">5 GHz band not available in this country</string>
    <!-- Toast message when Wi-Fi or bluetooth is disallowed in airplane mode -->
    <string name="wifi_in_airplane_mode">In Airplane mode</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 [CHAR LIMIT=60]-->
    <string name="wifi_notify_open_networks_summary">Notify whenever a public network is available</string>
    <!-- Checkbox title for option to toggle poor network detection -->
    <string name="wifi_poor_network_detection">Avoid poor connections</string>
    <!-- Checkbox summary for option to toggle poor network detection -->
    <string name="wifi_poor_network_detection_summary">Don\u2019t use a Wi\u2011Fi network unless it has a good Internet connection</string>
    <!-- Checkbox summary for option to toggle poor network detection [CHAR LIMIT=60] -->
    <string name="wifi_avoid_poor_network_detection_summary">Only use networks that have a good Internet connection</string>
    <!-- Checkbox title for option to connect to open Wi-Fi automatically [CHAR LIMIT=40] -->
    <string name="wifi_automatically_connect_title">Use open Wi\u2011Fi automatically</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically  [CHAR LIMIT=100] -->
    <string name="wifi_automatically_connect_summary">Let a Wi\u2011Fi assistant automatically connect to open networks determined to be high quality</string>
    <!-- Dialog title for option to select an app which connects to open Wi-Fi automatically [CHAR LIMIT=40] -->
    <string name="wifi_select_assistant_dialog_title">Choose assistant</string>
    <!-- Preference title for option to install certificates -->
    <string name="wifi_install_credentials">Install certificates</string>
    <!-- Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off. The
      place-holders "LINK_BEGIN" and "LINK_END" must NOT be translated. They mark a link to bring
      the user to "scanning settings" screen. -->
    <string name="wifi_scan_notify_text">To improve location accuracy, system apps and services can
        still scan for Wi\u2011Fi networks. You can change this in
        <xliff:g id="link_begin">LINK_BEGIN</xliff:g>scanning
        settings<xliff:g id="link_end">LINK_END</xliff:g>.</string>
    <!-- Wifi scan always mode checkbox text -->
    <string name="wifi_scan_notify_remember_choice">Don\u2019t show again</string>
    <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? -->
    <string name="wifi_setting_sleep_policy_title">Keep Wi\u2011Fi on during sleep</string>
    <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? [CHAR LIMIT=30] -->
    <string name="wifi_setting_on_during_sleep_title">Wi\u2011Fi on during sleep</string>
    <!-- Generic error message when the sleep policy could not be set. -->
    <string name="wifi_setting_sleep_policy_error">There was a problem changing the setting</string>
    <!-- Checkbox title for option to toggle suspend power optimizations [CHAR LIMIT=30] -->
    <string name="wifi_suspend_efficiency_title">Improve efficiency</string>
    <!-- Checkbox title for option to toggle suspend power optimizations -->
    <string name="wifi_suspend_optimizations">Wi\u2011Fi optimization</string>
    <!-- Checkbox summary for option to toggle suspend power optimizations -->
    <string name="wifi_suspend_optimizations_summary">Minimize battery usage when Wi\u2011Fi is on</string>
    <!-- Checkbox summary for option to toggle suspend power optimizations [CHAR LIMIT=30] -->
    <string name="wifi_limit_optimizations_summary">Limit battery used by Wi\u2011Fi</string>
    <!-- Checkbox title. Should we switch to using cellular data if Wi-Fi is still connected but the Wi-Fi network we're connected to no longer has Internet access (e.g., due to an outage)? -->
    <string name="wifi_switch_away_when_unvalidated">Switch to cellular data if Wi\u2011Fi loses Internet access.</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\u2011Fi networks</string>
    <!-- Menu option to do WPS Push Button [CHAR LIMIT=25]-->
    <string name="wifi_menu_wps_pbc">WPS Push Button</string>
    <!-- Content description for menu button in Wifi setup. Not shown on the screen. [CHAR LIMIT=NONE] -->
    <string name="wifi_menu_more_options">More options</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\u2011Fi 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 remember a temporary Wi-Fi network -->
    <string name="wifi_menu_remember">Remember 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>
    <!-- Menu option to write a Wi-Fi configuration token to an NFC tag [CHAR_LIMIT=30]-->
    <string name="wifi_menu_write_to_nfc">Write to NFC tag</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\u2011Fi 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\u2011Fi networks\u2026</string>
    <!-- Wifi Settings. text displayed when user has restriction DISALLOW_CONFIG_WIFI [CHAR LIMIT=NONE]-->
    <string name="wifi_empty_list_user_restricted">You don\u2019t have permission to change the Wi\u2011Fi network.</string>
    <!-- Wi-Fi settings. title for setup other network button [CHAR LIMIT=35]-->
    <string name="wifi_other_network">Add another network</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 [CHAR LIMIT=40] -->
    <string name="wifi_show_advanced">Advanced options</string>
    <!-- Title for the WPS setup dialog [CHAR LIMIT=50] -->
    <string name="wifi_wps_setup_title">Wi\u2011Fi Protected Setup</string>
    <!-- Message in WPS dialog at start up [CHAR LIMIT=150] -->
    <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\u2011Fi Protected Setup button on your router. It may be called \u201cWPS\u201d or marked with 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\u2011Fi router. The setup can take up to 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\u2011Fi 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 up to 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 name</string>
    <!-- Hint for a text field to enter the SSID of a hidden wifi network. [CHAR LIMIT=35] -->
    <string name="wifi_ssid_hint">Enter the 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 frequency band of the connection -->
    <string name="wifi_frequency">Frequency</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 Passpoint network -->
    <string name="passpoint_label">Saved via</string>
    <!-- Content for Passpoint network -->
    <string name="passpoint_content"><xliff:g id="name">%1$s</xliff:g> credentials</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 RadioGroup to choose wifi ap band -->
    <string name="wifi_ap_band_config">Select AP Band</string>
    <!-- Label for the radio button to choose wifi ap 2.4 GHz band -->
    <string name="wifi_ap_choose_2G">2.4 GHz Band</string>
    <!-- Label for the radio button to choose wifi ap 5GHz band -->
    <string name="wifi_ap_choose_5G">5 GHz Band</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>
    <!-- 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>
    <!-- Message in WriteWifiConfigToNfcDialog when prompted to enter network password [CHAR_LIMIT=40] -->
    <string name="wifi_wps_nfc_enter_password">Enter your network password</string>

    <string name="wifi_scan_always_turnon_message">To improve location accuracy and for other purposes, <xliff:g id="app_name">%1$s</xliff:g> wants to turn on network scanning, even when Wi-Fi is off.\n\nAllow this for all apps that want to scan?</string>
    <!-- Message informing the user how to turn off  [CHAR LIMIT=200] -->
    <string name="wifi_scan_always_turnoff_message">To turn this off, go to Advanced in the overflow menu.</string>
    <string name="wifi_scan_always_confirm_allow">Allow</string>
    <string name="wifi_scan_always_confirm_deny">Deny</string>

    <!-- Dialog label to sign in to a Hotspot. [CHAR LIMIT=50]-->
    <string name="wifi_hotspot_title">Sign in to connect?</string>
    <!-- Dialog message to sign in to a Hotspot. [CHAR LIMIT=50]-->
    <string name="wifi_hotspot_message"><xliff:g id="app_name">%1$s</xliff:g> requires you to sign in online before you connect to the network.</string>
    <!-- Wifi settings button to connect in to a Hotspot. [CHAR LIMIT=50]-->
    <string name="wifi_hotspot_connect">CONNECT</string>

    <!-- Dialog text to tell the user that the selected network does not have Internet access. -->
    <string name="no_internet_access_text">This network has no Internet access. Stay connected?</string>
    <string name="no_internet_access_remember">Don\u2019t ask again for this network</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>
    <!-- Button for skipping a step after having been warned of a potential concern [CHAR LIMIT=30] -->
    <string name="wifi_skip_anyway">Skip anyway</string>
    <!-- Button for going to the previous screen or step [CHAR LIMIT=20] -->
    <string name="wifi_dont_skip">Don\u2019t skip</string>

    <!-- Text warning about skipping Wi-Fi with a mobile connect (tablet) [CHAR LIMIT=NONE]-->
    <string name="wifi_skipped_message" product="tablet">WARNING: if you skip Wi\u2011Fi, your tablet will only use cellular data for initial downloads and updates. To avoid possible data charges, connect to Wi\u2011Fi.</string>
    <!-- Text warning about skipping Wi-Fi with a mobile connect (device) [CHAR LIMIT=NONE]-->
    <string name="wifi_skipped_message" product="device">WARNING: if you skip Wi\u2011Fi, your device will only use cellular data for initial downloads and updates. To avoid possible data charges, connect to Wi\u2011Fi.</string>
    <!-- Text warning about skipping Wi-Fi with a mobile connect (phone) [CHAR LIMIT=NONE]-->
    <string name="wifi_skipped_message" product="default">WARNING: if you skip Wi\u2011Fi, your phone will only use cellular data for initial downloads and updates. To avoid possible data charges, connect to Wi\u2011Fi.</string>

    <!-- Text warning about skipping Wi-Fi without a mobile connect (tablet) [CHAR LIMIT=NONE] -->
    <string name="wifi_and_mobile_skipped_message" product="tablet">If you skip Wi\u2011Fi:\n\n<li>Your tablet won\u2019t have an Internet connection.</li>\n\n<li>You won\u2019t get software updates until you connect to the Internet.</li>\n\n<li>You can\u2019t activate device protection features at this time.</li></string>
    <!-- Text warning about skipping Wi-Fi without a mobile connect (device) [CHAR LIMIT=NONE] -->
    <string name="wifi_and_mobile_skipped_message" product="device">If you skip Wi\u2011Fi:\n\n<li>Your device won\u2019t have an Internet connection.</li>\n\n<li>You won\u2019t get software updates until you connect to the Internet.</li>\n\n<li>You can\u2019t activate device protection features at this time.</li></string>
    <!-- Text warning about skipping Wi-Fi without a mobile connect (phone) [CHAR LIMIT=NONE] -->
    <string name="wifi_and_mobile_skipped_message" product="default">If you skip Wi\u2011Fi:\n\n<li>Your phone won\u2019t have an Internet connection.</li>\n\n<li>You won\u2019t get software updates until you connect to the Internet.</li>\n\n<li>You can\u2019t activate device protection features at this time.</li></string>
    <!-- Text alerting that Wi-Fi couldn't connect (tablet) [CHAR LIMIT=NONE] -->
    <string name="wifi_connect_failed_message" product="tablet">The tablet was unable to connect to this Wi\u2011Fi network.</string>
    <!-- Text alerting that Wi-Fi couldn't connect (device) [CHAR LIMIT=NONE] -->
    <string name="wifi_connect_failed_message" product="device">The device was unable to connect to this Wi\u2011Fi network.</string>
    <!-- Text alerting that Wi-Fi couldn't connect (phone) [CHAR LIMIT=NONE] -->
    <string name="wifi_connect_failed_message" product="default">The phone was unable to connect to this Wi\u2011Fi network.</string>

    <!-- Wi-Fi Advanced Settings --> <skip />
    <!-- Wi-Fi settings screen, Saved networks, settings section.  This is a header shown above Saved networks wifi settings. [CHAR LIMIT=30] -->
    <string name="wifi_saved_access_points_titlebar">Saved networks</string>
    <!-- Wi-Fi settings screen, advanced, settings section.  This is a header shown above advanced wifi settings. [CHAR LIMIT=30] -->
    <string name="wifi_advanced_titlebar">Advanced Wi\u2011Fi</string>
    <!-- Wi-Fi settings screen, setting title for setting the band [CHAR LIMIT=50]-->
    <string name="wifi_setting_frequency_band_title">Wi\u2011Fi 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 saved access points.  Used as a label under the shortcut icon that goes to Wifi saved access points. [CHAR LIMIT=20] -->
    <string name="wifi_saved_access_points_label">Saved networks</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">8.8.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\u2011Fi 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>
    <!-- Title for remembered p2p groups -->
    <string name="wifi_p2p_remembered_groups">Remembered groups</string>
    <!-- Toast text for a failed connection initiation -->
    <string name="wifi_p2p_failed_connect_message">Couldn\u2019t 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>
    <!-- Message text for remembered group deletion-->
    <string name="wifi_p2p_delete_group_message">Forget this group?</string>

    <!-- Wifi AP settings-->
    <!-- Label for Wifi tether checkbox. Toggles Access Point on/off -->
    <string name="wifi_tether_checkbox_text">Portable Wi\u2011Fi hotspot</string>
    <!-- Label for Wifi tether checkbox. Toggles Access Point on/off  [CHAR LIMIT=30] -->
    <string name="wifi_hotspot_checkbox_text">Wi\u2011Fi hotspot</string>
    <!-- Label for Wifi tether checkbox summary. Toggles Access Point on/off  [CHAR LIMIT=60] -->
    <string name="wifi_hotspot_checkbox_text_summary">Use cellular connection to provide Wi\u2011Fi network</string>
    <!-- Summary text when turning hotspot on -->
    <string name="wifi_tether_starting">Turning hotspot on\u2026</string>
    <!-- Summary text when turning hotspot off -->
    <string name="wifi_tether_stopping">Turning off hotspot\u2026</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\u2011Fi hotspot error</string>
    <!-- Used to open the ssid and security dialog for Wifi Access Point -->
    <string name="wifi_tether_configure_ap_text">Set up Wi\u2011Fi hotspot</string>
    <!-- Used to open the ssid and security dialog for Wifi Access Point.  [CHAR LIMIT=30]-->
    <string name="wifi_hotspot_configure_ap_text">Wi\u2011Fi hotspot setup</string>
    <!-- Summary Used to open the ssid and security dialog for Wifi Access Point.  [CHAR LIMIT=60] -->
    <string name="wifi_hotspot_configure_ap_text_summary">AndroidAP WPA2 PSK portable Wi\u2011Fi hotspot</string>
    <!-- Subtext on configuration preference to indicate SSID and security chosen -->
    <string name="wifi_tether_configure_subtext"><xliff:g id="network_ssid">%1$s</xliff:g> <xliff:g id="network_security">%2$s</xliff:g> portable Wi\u2011Fi hotspot</string>
    <!-- Default access point SSID used for tethering -->
    <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>

    <!-- Wireless networks, item title to go into the WFC settings [CHAR LIMIT=30] -->
    <string name="wifi_calling_settings_title">Wi-Fi calling</string>
    <!-- WFC mode [CHAR LIMIT=30] -->
    <string name="wifi_calling_mode_title">Calling preference</string>
    <!-- WFC mode dialog [CHAR LIMIT=30] -->
    <string name="wifi_calling_mode_dialog_title">Wi-Fi calling mode</string>
    <string-array name="wifi_calling_mode_choices">
        <item>Wi-Fi preferred</item>
        <item>Cellular preferred</item>
    </string-array>
    <string-array name="wifi_calling_mode_values">
        <item>"2"</item>
        <item>"1"</item>
    </string-array>
    <!-- Wi-Fi Calling settings. Text displayed when Wi-Fi Calling is off -->
    <string name="wifi_calling_off_explanation">When Wi-Fi calling is on, your phone can route calls via Wi-Fi networks or your carrier\u2019s network, depending on your preference and which signal is stronger. Before turning on this feature, check with your carrier regarding fees and other details.</string>

    <!-- Sound and alerts settings -->
    <skip/>
    <!-- Main Settings screen setting option name to go into the display settings screen -->
    <string name="home_settings">Home</string>
    <string name="display_settings_title">Display</string>
    <!-- Sound settings screen heading -->
    <string name="sound_settings">Sound</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 sound</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>

    <!-- Home settings screen, text indicating that a launcer does not support work profiles [CHAR LIMIT=100] -->
    <string name="home_work_profile_not_supported">Doesn\u2019t support work profiles</string>

    <!-- Sound settings screen, setting option title-->
    <string name="notification_sound_dialog_title">Default notification sound</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>

    <!-- 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\u2019t 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\u2019t play sound when inserting or removing phone from dock</string>

    <!-- Account settings header. [CHAR LIMIT=30] -->
    <string name="account_settings">Accounts</string>
    <!-- Header for items under the personal user [CHAR LIMIT=30] -->
    <string name="category_personal">Personal</string>
    <!-- Header for items under the work user [CHAR LIMIT=30] -->
    <string name="category_work">Work</string>
    <!-- Content description for work profile accounts group [CHAR LIMIT=NONE] -->
    <string name="accessibility_category_work">Work profile accounts - <xliff:g id="managed_by" example="Managed by Corporate application">%s</xliff:g></string>
    <!-- Content description for personal profile accounts group [CHAR LIMIT=NONE] -->
    <string name="accessibility_category_personal">Personal profile accounts</string>
    <!-- Content description for work profile details page title [CHAR LIMIT=NONE] -->
    <string name="accessibility_work_account_title">Work account - <xliff:g id="managed_by" example="Email provider">%s</xliff:g></string>
    <!-- Content description for personal profile details page title [CHAR LIMIT=NONE] -->
    <string name="accessibility_personal_account_title">Personal account - <xliff:g id="managed_by" example="Email provider">%s</xliff:g></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 level -->
    <string name="brightness">Brightness level</string>
    <!-- Sound & display settings screen, setting option name to change brightness level [CHAR LIMIT=30] -->
    <string name="brightness_title">Brightness</string>
    <!-- Sound & display settings screen, setting option summary to change brightness level -->
    <string name="brightness_summary">Adjust the brightness of the screen</string>
    <!-- Sound & display settings screen, setting option name to enable adaptive brightness [CHAR LIMIT=30] -->
    <string name="auto_brightness_title">Adaptive brightness</string>
    <!-- Sound & display settings screen, setting option summary to enable adaptive brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary">Optimize brightness level for available light</string>
    <!-- Sound & display settings screen, setting option name to change the user interface theme [CHAR LIMIT=30] -->
    <string name="night_mode_title">Theme</string>
    <!-- Sound & display settings screen, setting option summary to change the user interface theme [CHAR LIMIT=100] -->
    <string name="night_mode_summary">%s</string>
    <!-- Sound & display settings screen, theme setting value to prefer a light-colored user interface [CHAR LIMIT=30] -->
    <string name="night_mode_no">Light</string>
    <!-- Sound & display settings screen, theme setting value to prefer a dark-colored user interface [CHAR LIMIT=30] -->
    <string name="night_mode_yes">Dark</string>
    <!-- Sound & display settings screen, theme setting value to automatically switch between a light- or dark-colored user interface [CHAR LIMIT=30] -->
    <string name="night_mode_auto">Automatic</string>
    <!-- Sound & display settings screen, setting option name to change screen timeout -->
    <string name="screen_timeout">Sleep</string>
    <!-- Sound & display settings screen, setting option name to change screen timeout [CHAR LIMIT=30] -->
    <string name="screen_timeout_title">Screen turns off</string>
    <!-- Sound & display settings screen, setting option summary to change screen timeout -->
    <string name="screen_timeout_summary">After <xliff:g id="timeout_description">%1$s</xliff:g> of inactivity</string>
    <!-- Wallpaper settings title [CHAR LIMIT=30] -->
    <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">Daydream</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when docked or asleep and charging -->
    <string name="screensaver_settings_summary_either_long">When docked or asleep and charging</string>
    <!-- Dream settings screen, dialog option, activated when docked or asleep and charging -->
    <string name="screensaver_settings_summary_either_short">Either</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when asleep and charging -->
    <string name="screensaver_settings_summary_sleep">While charging</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when docked  -->
    <string name="screensaver_settings_summary_dock">While docked</string>
    <!-- Display settings screen, summary for screen saver options, screen saver is turned off -->
    <string name="screensaver_settings_summary_off">Off</string>
    <!-- Dream settings screen, caption for when dreams are disabled -->
    <string name="screensaver_settings_disabled_prompt">To control what happens when the phone is docked and/or sleeping, turn Daydream on.</string>
    <!-- Dream settings screen, action label, when to dream -->
    <string name="screensaver_settings_when_to_dream">When to daydream</string>
    <!-- Dream settings screen, button label to start dreaming -->
    <string name="screensaver_settings_dream_start">Start now</string>
    <!-- Dream settings screen, button label for settings for a specific screensaver -->
    <string name="screensaver_settings_button">Settings</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=40] Display settings screen, setting option name to change whether the device wakes up when a lift gesture is detected. -->
    <string name="lift_to_wake_title">Lift to wake</string>
    <!-- [CHAR LIMIT=30] Display settings screen, setting option name to change whether the ambient display feature is enabled. -->
    <string name="doze_title">Ambient display</string>
    <!-- [CHAR LIMIT=NONE] Display settings screen, setting description for the ambient display feature. -->
    <string name="doze_summary">Wake screen when you pick up device or receive notifications</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  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings">SIM card lock settings</string>
    <!-- Security & location settings screen, setting option name  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings_category">Set up SIM card lock</string>
    <!-- Security & location settings screen, section heading for settings related to sim card locking  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings_title">SIM card lock</string>
    <!-- SIM card lock settings screen, setting check box label  [CHAR LIMIT=40] -->
    <string name="sim_pin_toggle">Lock SIM card</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected  [CHAR LIMIT=40] -->
    <string name="sim_lock_on" product="tablet">Require PIN to use tablet</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected  [CHAR LIMIT=40] -->
    <string name="sim_lock_on" product="default">Require PIN to use phone</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear  [CHAR LIMIT=40] -->
    <string name="sim_lock_off" product="tablet">Require PIN to use tablet</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear  [CHAR LIMIT=40] -->
    <string name="sim_lock_off" product="default">Require PIN to use phone</string>
    <!-- SIM card lock settings screen, setting option name to change the SIM PIN  [CHAR LIMIT=40] -->
    <string name="sim_pin_change">Change SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enter_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enable_sim_lock">Lock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_disable_sim_lock">Unlock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enter_old">Old SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enter_new">New SIM PIN</string>
    <!-- SIM card lock settings screen, Re-type new PIN.  [CHAR LIMIT=40] -->
    <string name="sim_reenter_new">Re\u2011type new PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_change_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered  [CHAR LIMIT=40] -->
    <string name="sim_bad_pin">Incorrect PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match  [CHAR LIMIT=40] -->
    <string name="sim_pins_dont_match">PINs don\u2019t match</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN  [CHAR LIMIT=40] -->
    <string name="sim_change_failed">Can\u2019t change PIN.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when the entered PIN is correct [CHAR LIMIT=40] -->
    <string name="sim_change_succeeded">SIM PIN changed successfully</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN [CHAR LIMIT=40] -->
    <string name="sim_lock_failed">Can\u2019t change SIM card lock state.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: [CHAR LIMIT=40] -->
    <string name="sim_enter_ok">OK</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: [CHAR LIMIT=40] -->
    <string name="sim_enter_cancel">Cancel</string>
    <!-- Multiple SIMs found title.  [CHAR LIMIT=40] -->
    <string name="sim_multi_sims_title">Multiple SIMs found</string>
    <!-- Multiple SIMs found summary.  [CHAR LIMIT=100] -->
    <string name="sim_multi_sims_summary">Choose the SIM you prefer for cellular data.</string>
    <!-- Title asking user if they wish to change the default sim for cellular data.  [CHAR LIMIT=30] -->
    <string name="sim_change_data_title">Change data SIM?</string>
    <!-- Message confirming the user wishes to change the default data SIM from one to another.  [CHAR LIMIT=NONE] -->
    <string name="sim_change_data_message">Use <xliff:g id="new_sim">%1$s</xliff:g> instead of <xliff:g id="old_sim">%2$s</xliff:g> for cellular data?</string>
    <!-- Title for the dialog asking to user to change the preferred SIM  [CHAR LIMIT=30] -->
    <string name="sim_preferred_title">Update preferred SIM card?</string>
    <!-- Message for the dialog asking to user to change the preferred SIM  [CHAR LIMIT=NONE] -->
    <string name="sim_preferred_message"><xliff:g id="new_sim">%1$s</xliff:g> is the only SIM in your device.  Do you want to use this SIM for cellular data, calls, and SMS messages?</string>

    <!-- Instructions telling the user that they entered the wrong SIM PIN for the last time.
         Displayed in a dialog box.  [CHAR LIMIT=100] -->
    <string name="wrong_pin_code_pukked">Incorrect SIM PIN code you must now contact your carrier to unlock your device.</string>
    <!-- Instructions telling the user that they entered the wrong SIM PIN while trying to unlock the keyguard.  Displayed in a dialog box.  [CHAR LIMIT=100] -->
    <plurals name="wrong_pin_code">
        <item quantity="one">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempt before you must contact your carrier to unlock your device.</item>
        <item quantity="other">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempts.</item>
    </plurals>
    <!-- Instructions telling the user that the operation to unlock the keyguard with SIM PIN failed. Displayed in one line in a large font.  [CHAR LIMIT=40] -->
    <string name="pin_failed">SIM PIN operation failed!</string>

    <!-- Advanced (used for diagnostics) device info activity title [CHAR LIMIT=40] -->
    <string name="device_info_settings" product="tablet">Tablet status</string>
    <!-- Advanced (used for diagnostics) device info activity title [CHAR LIMIT=40] -->
    <string name="device_info_settings" product="default">Phone status</string>

    <!-- About phone screen, list item title.  Takes the user to the screen for seeing and installing system updates. [CHAR LIMIT=40] -->
    <string name="system_update_settings_list_item_title">System updates</string>
    <!-- About phone screen, list item summary.  Takes the user to the screen for seeing and installing system updates. [CHAR LIMIT=40] -->
    <string name="system_update_settings_list_item_summary">""</string>

    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
    <string name="firmware_version">Android version</string>
    <!-- About phone screen, status item label  [CHAR LIMIT=60] -->
    <string name="security_patch">Android security patch level</string>
    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
    <string name="model_number">Model number</string>
    <!-- About phone screen, fcc equipment id label  [CHAR LIMIT=40] -->
    <string name="fcc_equipment_id">Equipment ID</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="baseband_version">Baseband version</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="kernel_version">Kernel version</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="build_number">Build number</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="selinux_status">SELinux status</string>

    <!-- About phone screen, show when a value of some status item is unavailable. -->
    <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>
    <!-- Main settings screen item's title to go into the storage & USB settings screen [CHAR LIMIT=25] -->
    <string name="storage_usb_settings" >Storage &amp; USB</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">Cellular network type</string>
    <!-- About phone, status item title for the latest area info cell broadcast received (Brazil only). -->
    <string name="status_latest_area_info">Operator info</string>
    <!-- About phone, status item title. The status of data access.  For example, the value may be "Connected" -->
    <string name="status_data_state">Cellular network state</string>
    <!-- About phone, status item title. The status of whether we have service.  for example, the value may be "In service" -->
    <string name="status_service_state">Service state</string>
    <!-- About phone, status item title. The  current cell tower signal strength -->
    <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\u2011Fi 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 title. The amount of free space for some storage partition when the volume is read-only. [CHAR LIMIT=64] -->
    <string name="memory_available_read_only">Available (read-only)</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 &amp; app data</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">Other files</string>
    <!-- Storage item representing all cached data on device. [CHAR LIMIT=48] -->
    <string name="memory_media_cache_usage">Cached data</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 -->

    <!-- Title of dialog asking user to confirm before clearing all caches. [CHAR LIMIT=48] -->
    <string name="memory_clear_cache_title">Clear cached data?</string>
    <!-- Message of dialog asking user to confirm before clearing all caches. [CHAR LIMIT=48] -->
    <string name="memory_clear_cache_message">This will clear cached data for all apps.</string>

    <!-- SD card & phone storage settings item summary that will result in the phone connected to PC and MTP/PTP enabled.   [CHAR LIMIT=80] -->
    <string name="mtp_ptp_mode_summary">MTP or PTP function is active</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\u2019t unmount USB storage. Try again later.</string>
    <!-- SD card eject error dialog text   -->
    <string name="dlg_error_unmount_text" product="default">Couldn\u2019t 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 renaming a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_rename">Rename</string>
    <!-- Storage setting.  Menu option for mounting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_mount">Mount</string>
    <!-- Storage setting.  Menu option for unmounting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_unmount">Eject</string>
    <!-- Storage setting.  Menu option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format">Format</string>
    <!-- Storage setting.  Menu option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format_public">Format as portable</string>
    <!-- Storage setting.  Menu option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format_private">Format as internal</string>
    <!-- Storage setting.  Menu option for migrating data to a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_migrate">Migrate data</string>
    <!-- Storage setting.  Menu option for forgetting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_forget">Forget</string>
    <!-- Storage setting.  Menu option for setting up a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_set_up">Set up</string>
    <!-- Storage setting.  Menu option for exploring a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_explore">Explore</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.  Summary for PTP checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_ptp_summary">Lets you transfer photos using camera software, and transfer any files on computers that don\u2019t support MTP</string>
    <!-- Storage setting.  Title for MIDI checkbox [CHAR LIMIT=30]-->
    <string name="usb_midi_title">MIDI</string>
    <!-- Storage setting.  Summary for MIDI checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_midi_summary">Lets MIDI enabled applications work over USB with MIDI software on your computer.</string>

    <!-- Section header above list of other users storage [CHAR LIMIT=32] -->
    <string name="storage_other_users">Other users</string>

    <!-- Section header above list of internal storage devices [CHAR LIMIT=30]-->
    <string name="storage_internal_title">Device storage</string>
    <!-- Section header above list of external storage devices [CHAR LIMIT=30]-->
    <string name="storage_external_title">Portable storage</string>

    <!-- Summary of a single storage volume, constrasting available and total storage space. [CHAR LIMIT=48]-->
    <string name="storage_volume_summary"><xliff:g id="used" example="1.2GB">%1$s</xliff:g> used of <xliff:g id="total" example="32GB">%2$s</xliff:g></string>
    <!-- Summary of a single storage volume used space. [CHAR LIMIT=24] -->
    <string name="storage_size_large"><xliff:g id="number" example="128">^1</xliff:g><small><small> <xliff:g id="unit" example="KB">^2</xliff:g></small></small></string>
    <!-- Summary of a single storage volume total space. [CHAR LIMIT=48]-->
    <string name="storage_volume_used">Used of <xliff:g id="total" example="32GB">%1$s</xliff:g></string>
    <!-- Summary of a single storage volume total space. [CHAR LIMIT=48]-->
    <string name="storage_volume_used_total">Total used of <xliff:g id="total" example="32GB">%1$s</xliff:g></string>

    <!-- Toast informing that storage mount operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_mount_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is mounted</string>
    <!-- Toast informing that storage unmount operation failed. [CHAR LIMIT=64]-->
    <string name="storage_mount_failure">Couldn\u2019t mount <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

    <!-- Toast informing that storage unmount operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_unmount_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is safely ejected</string>
    <!-- Toast informing that storage unmount operation failed. [CHAR LIMIT=64]-->
    <string name="storage_unmount_failure">Couldn\u2019t safely eject <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

    <!-- Toast informing that storage format operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_format_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is formatted</string>
    <!-- Toast informing that storage format operation failed. [CHAR LIMIT=64]-->
    <string name="storage_format_failure">Couldn\u2019t format <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

    <!-- Title of dialog prompting user to rename a storage volume [CHAR LIMIT=32]-->
    <string name="storage_rename_title">Rename storage</string>

    <!-- Dialog body informing user about an unmounted storage device. [CHAR LIMIT=NONE]-->
    <string name="storage_dialog_unmounted">This <xliff:g id="name" example="SD card">^1</xliff:g> is safely ejected, but still available.
\n\nTo use this <xliff:g id="name" example="SD card">^1</xliff:g>, you have to mount it first.</string>

    <!-- Dialog body informing user about an unmountable storage device. [CHAR LIMIT=NONE]-->
    <string name="storage_dialog_unmountable">This <xliff:g id="name" example="SD card">^1</xliff:g> is corrupted.
\n\nTo use this <xliff:g id="name" example="SD card">^1</xliff:g>, you have to set it up first.</string>

    <!-- Dialog body informing user about an unsupported storage device. [CHAR LIMIT=NONE]-->
    <string name="storage_dialog_unsupported">This device doesn\u2019t support this <xliff:g id="name" example="SD card">^1</xliff:g>.
\n\nTo use this <xliff:g id="name" example="SD card">^1</xliff:g> with this device, you have to set it up first.</string>

    <!-- Body of dialog informing user about consequences of formatting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_format_details">After formatting, you can use this <xliff:g id="name" example="SD card">^1</xliff:g> in other devices.
\n\nAll data on this <xliff:g id="name" example="SD card">^1</xliff:g> will be erased. Consider backing up first.
\n\n<b>Back up photos &amp; other media</b>
\nMove your media files to alternative storage on this device, or transfer them to a computer using a USB cable.
\n\n<b>Back up apps</b>
\nAll apps stored on this <xliff:g id="name" example="SD card">^1</xliff:g> will be uninstalled and their data will be erased. To keep these apps, move them to alternative storage on this device.</string>

    <!-- Body of dialog informing user about consequences of ejecting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_unmount_details"><b>When you eject this <xliff:g id="name" example="SD card">^1</xliff:g>, apps stored on it will stop working, and media files stored on it will not be available until it is reinserted.</b>
\n\nThis <xliff:g id="name" example="SD card">^1</xliff:g> is formatted to work on this device only.  It won\u2019t work on any others.</string>

    <!-- Body of dialog informing user about consequences of forgetting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_forget_details">To use the apps, photos, or data this <xliff:g id="name" example="SD card">^1</xliff:g> contains, reinsert it.
\n\nAlternatively, you can choose to forget this storage if the device isn\u2019t available.
\n\nIf you choose to forget, all the data the device contains will be lost forever.
\n\nYou can reinstall the apps later, but their data stored on this device will be lost.</string>

    <!-- Title of dialog confirming that user wants to forget an internal storage device [CHAR LIMIT=32]-->
    <string name="storage_internal_forget_confirm_title">Forget <xliff:g id="name" example="SD card">^1</xliff:g>?</string>
    <!-- Body of dialog confirming that user wants to forget an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_forget_confirm">All the apps, photos, and data stored on this <xliff:g id="name" example="SD card">^1</xliff:g> will be lost forever.</string>

    <!-- Item title describing storage used by apps [CHAR LIMIT=48]-->
    <string name="storage_detail_apps">Apps</string>
    <!-- Item title describing storage used by images [CHAR LIMIT=48]-->
    <string name="storage_detail_images">Images</string>
    <!-- Item title describing storage used by videos [CHAR LIMIT=48]-->
    <string name="storage_detail_videos">Videos</string>
    <!-- Item title describing storage used by audio [CHAR LIMIT=48]-->
    <string name="storage_detail_audio">Audio</string>
    <!-- Item title describing storage used by cached data [CHAR LIMIT=48]-->
    <string name="storage_detail_cached">Cached data</string>
    <!-- Item title describing storage used by other data [CHAR LIMIT=48]-->
    <string name="storage_detail_other">Other</string>
    <!-- Item title that will launch a file explorer [CHAR LIMIT=48]-->
    <string name="storage_detail_explore">Explore <xliff:g id="name" example="SD card">^1</xliff:g></string>

    <!-- Body of dialog informing user about other files on a storage device [CHAR LIMIT=NONE]-->
    <string name="storage_detail_dialog_other">Other includes shared files saved by apps, files downloaded from the Internet or Bluetooth, Android files, and so on.
\n\nTo see the entire contents of this <xliff:g id="name" example="SD card">^1</xliff:g>, touch Explore.</string>

    <!-- Body of dialog informing user about other users on a storage device [CHAR LIMIT=NONE]-->
    <string name="storage_detail_dialog_user"><xliff:g id="user" example="Guest user">^1</xliff:g> may have saved photos, music, movies, apps, or other data that is taking up <xliff:g id="size" example="1.2 GB">^2</xliff:g> of storage.
\n\nTo view details, switch to <xliff:g id="user" example="Guest user">^1</xliff:g>.</string>

    <!-- Title of wizard step prompting user to setup a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_title">Set up your <xliff:g id="name" example="SD card">^1</xliff:g></string>
    <!-- Title of wizard choice to use storage device as external storage [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_external_title">Use as portable storage</string>
    <!-- Summary of wizard choice to use storage device as external storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_init_external_summary">For moving photos and other media between devices.</string>
    <!-- Title of wizard choice to use storage device as internal storage [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_internal_title">Use as internal storage</string>
    <!-- Summary of wizard choice to use storage device as internal storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_init_internal_summary">For storing anything on this device only, including apps and photos. Requires formatting that prevents it from working with other devices.</string>

    <!-- Title of wizard step prompting user to format a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_title">Format as internal storage</string>
    <!-- Body of wizard step prompting user to format a storage device [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_confirm_body">This requires the <xliff:g id="name" example="SD card">^1</xliff:g> to be formatted to make it secure.
\n\nAfter formatting, this <xliff:g id="name" example="SD card">^1</xliff:g> will only work in this device.
\n\n<b>Formatting erases all data currently stored on the <xliff:g id="name" example="SD card">^1</xliff:g>.</b> To avoid losing the data, consider backing it up.
    </string>

    <!-- Title of wizard step prompting user to format a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_public_title">Format as portable storage</string>
    <!-- Body of wizard step prompting user to format a storage device [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_confirm_public_body">This requires the <xliff:g id="name" example="SD card">^1</xliff:g> to be formatted.
\n\n<b>Formatting erases all data currently stored on the <xliff:g id="name" example="SD card">^1</xliff:g>.</b> To avoid losing the data, consider backing it up.
    </string>

    <!-- Next button text of wizard step prompting user to format a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_next">Erase &amp; format</string>

    <!-- Title of wizard step showing formatting progress [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_progress_title">Formatting <xliff:g id="name" example="SD card">^1</xliff:g>\u2026</string>
    <!-- Body of wizard step showing formatting progress [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_progress_body">Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g> while it\u2019s formatting.</string>

    <!-- Title of wizard step prompting user to migrate data to new storage [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_title">Move data to new storage</string>
    <!-- Body of wizard step prompting user to migrate data to new storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_body">You can move your photos, files, and some apps to this new <xliff:g id="name" example="SD card">^1</xliff:g>.
\n\nThe move takes about <xliff:g id="time" example="1 hour">^2</xliff:g> and will free <xliff:g id="size" example="1.2 GB">^3</xliff:g> on internal storage. Some apps won\u2019t work while it\u2019s underway.
    </string>

    <!-- Title of wizard choice to migrate data right now [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_now">Move now</string>
    <!-- Title of wizard choice to migrate data at later time [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_later">Move later</string>

    <!-- Title of wizard step prompting user to start data migration [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_confirm_title">Move data now</string>
    <!-- Body of wizard step providing details about data migration [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_confirm_body"><b>The move takes about <xliff:g id="time" example="1 hour">^1</xliff:g>. It will free <xliff:g id="size" example="1.2 GB">^2</xliff:g> on <xliff:g id="name" example="Internal storage">^3</xliff:g>.</b></string>
    <!-- Title of wizard button prompting user to start data migration [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_confirm_next">Move</string>

    <!-- Title of wizard step showing migration progress [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_progress_title">Moving data\u2026</string>

    <!-- Body of wizard step providing details about data migration [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_details">During the move:
\n\u2022 Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g>.
\n\u2022 Some apps won\u2019t work correctly.
\n\u2022 Keep the device charged.
    </string>

    <!-- Title of wizard step indicating that storage is ready [CHAR LIMIT=32] -->
    <string name="storage_wizard_ready_title"><xliff:g id="name" example="SD card">^1</xliff:g> is ready</string>
    <!-- Body of wizard step indicating that external storage is ready [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_external_body">
        Your <xliff:g id="name" example="SD card">^1</xliff:g> is all set to use with photos and other media.
    </string>
    <!-- Body of wizard step indicating that internal storage is ready [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_internal_body">Your new <xliff:g id="name" example="SD card">^1</xliff:g> is working.
\n\nTo move photos, files, and app data to this device, go to Settings > Storage.
    </string>

    <!-- Title of wizard step prompting user to move an app [CHAR LIMIT=32] -->
    <string name="storage_wizard_move_confirm_title">Move <xliff:g id="app" example="Calculator">^1</xliff:g></string>
    <!-- Body of wizard step prompting user to move an app [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_move_confirm_body">Moving <xliff:g id="app" example="Calculator">^1</xliff:g> and its data to <xliff:g id="name" example="SD card">^2</xliff:g> will take only a few moments. You won\u2019t be able to use the app until the move is complete.
\n\nDon\u2019t remove the <xliff:g id="name" example="SD card">^2</xliff:g> during the move.
    </string>

    <!-- Title of wizard step showing app move progress [CHAR LIMIT=32] -->
    <string name="storage_wizard_move_progress_title">Moving <xliff:g id="app" example="Calculator">^1</xliff:g>\u2026</string>
    <!-- Body of wizard step showing app move progress [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_move_progress_body">Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g> during the move.
\n\nThe <xliff:g id="app" example="Calculator">^2</xliff:g> app on this device won\u2019t be available until the move is complete.
    </string>
    <!-- Title of wizard button offering to cancel move [CHAR LIMIT=32] -->
    <string name="storage_wizard_move_progress_cancel">Cancel move</string>

    <!-- Title of wizard step prompting user to start data migration [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_slow_body">This <xliff:g id="name" example="SD card">^1</xliff:g> appears to be slow.
\n\nYou can continue, but apps moved to this location may stutter and data transfers may take a long time.
\n\nConsider using a faster <xliff:g id="name" example="SD card">^1</xliff:g> for better performance.
</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 Mvno Type Info of APN -->
    <string name="mvno_type">MVNO type</string>
    <!-- Edit Mvno Match Data Info of APN -->
    <string name="mvno_match_data">MVNO value</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\u2019t be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_apn_empty">The APN can\u2019t 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>

    <!-- Reset Network -->
    <!-- SD card & phone storage settings screen, setting option name under Backup & Restore heading -->
    <string name="reset_network_title">Network settings reset</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset network settings [CHAR LIMIT=NONE] -->
    <string name="reset_network_desc">This will reset all network settings, including:\n\n<li>Wi\u2011Fi</li>\n<li>Cellular data</li>\n<li>Bluetooth</li>"</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset network settings -->
    <string name="reset_network_button_text">Reset settings</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset settings button -->
    <string name="reset_network_final_desc">Reset all network settings? You can\u2019t undo this action!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset settings button -->
    <string name="reset_network_final_button_text">Reset settings</string>
    <!-- Reset settings confirmation screen title [CHAR LIMIT=30] -->
    <string name="reset_network_confirm_title">Reset?</string>
    <!-- Error message for users that aren't allowed to reset network settings [CHAR LIMIT=none] -->
    <string name="network_reset_not_available">Network reset is not available for this user</string>
    <!-- Reset settings complete toast text [CHAR LIMIT=75] -->
    <string name="reset_network_complete_toast">Network settings have been reset</string>

    <!-- Master Clear -->
    <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading [CHAR LIMIT=30] -->
    <string name="device_reset_title">Reset device</string>
    <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading -->
    <string name="master_clear_title">Factory data reset</string>
    <!-- SD card & phone storage settings screen, 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\u2019s <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\u2019s <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, notification if other users are present on the device [CHAR LIMIT=NONE] -->
    <string name="master_clear_other_users_present" product="default">"\n\nThere are other users present on this device.\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\u2019t undo 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>
    <!-- Master clear failed message -->
    <string name="master_clear_failed">No reset was performed because the System Clear service isn\u2019t available.</string>
    <!-- Master clear confirmation screen title [CHAR LIMIT=30] -->
    <string name="master_clear_confirm_title">Reset?</string>
    <!-- Error message for users that aren't allowed to factory reset [CHAR LIMIT=none] -->
    <string name="master_clear_not_available">Factory reset is not available for this user</string>
    <!-- Master clear progress screen title [CHAR LIMIT=30] -->
    <string name="master_clear_progress_title" >Erasing</string>
    <!-- Master clear progress screen text [CHAR LIMIT=75] -->
    <string name="master_clear_progress_text">Please wait...</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>

    <!-- TODO: Remove them once the same entries in SettingsLib is translated. -->
    <!-- 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\u2019t tether when USB storage is in use</string>
    <!-- USB unavailable subtext - shown when USB is not connected -->
    <string name="usb_tethering_unavailable_subtext">USB not connected</string>
    <!-- USB unavailable subtext - shown when USB is not connected -->
    <string name="usb_tethering_turnon_subtext">Connect to turn on</string>
    <!-- USB errored subtext - shown when USB is broken for some reason -->
    <string name="usb_tethering_errored_subtext">USB tethering error</string>

    <!-- 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\u2019s 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\u2019s 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\u2019s 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\u2019s 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\u2019s 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\u2019s Internet connection to <xliff:g id="connectedDeviceCount">%1$d</xliff:g> devices</string>
    <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_off_subtext_config">Sharing this <xliff:g id="device_name">%1$d</xliff:g>\u2019s Internet connection</string>
    <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_off_subtext" product="tablet">Not sharing this tablet\u2019s 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\u2019s 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\u2019t 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">Cellular networks</string>

    <!-- Mobile plan [CHAR LIMIT=35]-->
    <string name="manage_mobile_plan_title" translatable="true">Mobile plan</string>

    <!-- SMS Application [CHAR LIMIT=35]-->
    <string name="sms_application_title" translatable="true">SMS app</string>
    <string name="sms_change_default_dialog_title" translatable="true">Change SMS app?</string>
    <string name="sms_change_default_dialog_text" translatable="true">Use <xliff:g id="new_app">%1$s</xliff:g> instead of <xliff:g id="current_app">%2$s</xliff:g> as your SMS app?</string>
    <string name="sms_change_default_no_previous_dialog_text" translatable="true">Use <xliff:g id="new_app">%s</xliff:g> as your SMS app?</string>

    <!-- Wifi Assistant change wi-fi assistant title.  [CHAR LIMIT=40] -->
    <string name="network_scorer_change_active_dialog_title">Change Wi\u2011Fi assistant?</string>
    <!-- Wifi Assistant request message.  This message asks the user if it is okay for an app to become the Wifi Assistant instead of the current Wifi Assistant app. [CHAR LIMIT=100] -->
    <string name="network_scorer_change_active_dialog_text">Use <xliff:g id="new_app">%1$s</xliff:g> instead of <xliff:g id="current_app">%2$s</xliff:g> to manage your network connections?</string>
    <!-- Wifi Assistant request message.  This message asks the user if it is okay for an app to become the Wifi Assistant. [CHAR LIMIT=100] -->
    <string name="network_scorer_change_active_no_previous_dialog_text">Use <xliff:g id="new_app">%s</xliff:g> to manage your network connections?</string>

    <!-- The SIM operator is not known [CHAR_ LIMIT=50]-->
    <string name="mobile_unknown_sim_operator" translatable="true">Unknown SIM operator</string>

    <!-- There is no mobile provisiong website for the operator which is the firat parameter [CHAR_ LIMIT=50]-->
    <string name="mobile_no_provisioning_url" translatable="true">%1$s has no known provisioning website</string>

    <!-- Ask user to insert a SIM card [CHAR_ LIMIT=50]-->
    <string name="mobile_insert_sim_card" translatable="true">Please insert SIM card and restart</string>

    <!-- Ask user to connect to the internet [CHAR_ LIMIT=50]-->
    <string name="mobile_connect_to_internet" translatable="true">Please connect to the internet</string>

    <!-- Security & location settings screen, section header for settings relating to location -->
    <string name="location_title">My Location</string>
    <!-- Title for managed profile preference category [CHAR_LIMIT=25] -->
    <string name="managed_profile_location_category">Work profile</string>
    <!-- [CHAR LIMIT=30] Title for managed profile location switch  -->
    <string name="managed_profile_location_switch_title">Location for work profile</string>
    <!-- [CHAR LIMIT=30] Text to show on managed profile location switch if MDM has locked down location access for managed profile-->
    <string name="managed_profile_location_switch_lockdown">Turned off by your company</string>
    <!-- [CHAR LIMIT=30] Location settings screen, setting preference screen box label for location mode -->
    <string name="location_mode_title">Mode</string>
    <!-- [CHAR LIMIT=30] Location settings screen, high accuracy location mode -->
    <string name="location_mode_high_accuracy_title">High accuracy</string>
    <!-- [CHAR LIMIT=30] Location settings screen, battery saving location mode -->
    <string name="location_mode_battery_saving_title">Battery saving</string>
    <!-- [CHAR LIMIT=30] Location settings screen, device only location mode -->
    <string name="location_mode_sensors_only_title">Device only</string>
    <!-- [CHAR LIMIT=30] Location settings screen, location off mode -->
    <string name="location_mode_location_off_title">Location off</string>
    <!-- [CHAR LIMIT=30] Location settings screen, sub category for recent location requests -->
    <string name="location_category_recent_location_requests">Recent location requests</string>
    <!-- Location settings screen, displayed when there's no recent app accessing location -->
    <string name="location_no_recent_apps">No apps have requested location recently</string>
    <!-- [CHAR LIMIT=30] Location settings screen, sub category for location services -->
    <string name="location_category_location_services">Location services</string>
    <!-- [CHAR LIMIT=30] Location settings screen, recent location requests high battery use-->
    <string name="location_high_battery_use">High battery use</string>
    <!-- [CHAR LIMIT=30] Location settings screen, recent location requests low battery use-->
    <string name="location_low_battery_use">Low battery use</string>
    <!-- [CHAR LIMIT=30] Location mode screen, screen title -->
    <string name="location_mode_screen_title">Location mode</string>
    <!-- [CHAR LIMIT=130] Location mode screen, description for high accuracy mode -->
    <string name="location_mode_high_accuracy_description">Use GPS, Wi\u2011Fi, Bluetooth, or cellular networks to determine location </string>
    <!-- [CHAR LIMIT=130] Location mode screen, description for battery saving mode -->
    <string name="location_mode_battery_saving_description">Use Wi\u2011Fi, Bluetooth, or cellular networks to determine location</string>
    <!-- [CHAR LIMIT=130] Location mode screen, description for sensors only mode -->
    <string name="location_mode_sensors_only_description">Use GPS to determine location</string>
    <!-- Help menu label [CHAR LIMIT=20] Location settings screen, overflow menu that takes the user
      to scanning settings activity -->
    <string name="location_menu_scanning">Scanning</string>
    <!-- [CHAR LIMIT=30] Wireless background scanning settings screen, screen title -->
    <string name="location_scanning_screen_title">Scanning</string>
    <!-- [CHAR LIMIT=130] Preference title for Wi-Fi always scanning -->
    <string name="location_scanning_wifi_always_scanning_title">Wi\u2011Fi scanning</string>
    <!-- Preference description text for Wi-Fi always scanning -->
    <string name="location_scanning_wifi_always_scanning_description">Improve location by allowing
      system apps and services to detect Wi\u2011Fi networks at any time.</string>
    <!-- [CHAR LIMIT=130] Description text for Bluetooth always scanning -->
    <string name="location_scanning_bluetooth_always_scanning_title">Bluetooth scanning</string>
    <!-- Description text for Bluetooth always scanning -->
    <string name="location_scanning_bluetooth_always_scanning_description">
        Improve location by allowing system apps and services to detect Bluetooth devices at any
        time.</string>

    <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for Google location service (cell ID, wifi, etc.) -->
    <string name="location_network_based">Wi\u2011Fi &amp; cellular network location</string>
    <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary for Google location service check box-->
    <string name="location_neighborhood_level">Let apps use Google\u2019s location service to estimate your location faster. Anonymous location data will be collected and sent to Google.</string>
    <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary when Use wireless networks check box is selected, for wifi-only devices -->
    <string name="location_neighborhood_level_wifi">Location determined by Wi\u2011Fi</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 on a tablet -->
    <string name="location_street_level" product="tablet">Let apps use GPS on your tablet to pinpoint your location</string>
    <!-- [CHAR LIMIT=100] Security & location settings screen, setting check box summary for GPS satellites on a phone -->
    <string name="location_street_level" product="default">Let apps use GPS on your phone 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>
    <!-- [CHAR LIMIT=45] Label for turning on/off location access completely. -->
    <string name="location_access_title">Access to my location</string>
    <!-- [CHAR LIMIT=none] Description text for location access switch -->
    <string name="location_access_summary">Let apps that have asked your permission use your location information</string>
    <!-- [CHAR LIMIT=45] Section heading for location sources -->
    <string name="location_sources_heading">Location sources</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>
    <!-- About phone settings screen, setting option name to show Manual [CHAR LIMIT=25] -->
    <string name="manual">Manual</string>
    <!-- About phone settings screen, setting option name to show regulatory information [CHAR LIMIT=25] -->
    <string name="regulatory_information">Regulatory information</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>
    <!-- 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 for WebView component. [CHAR LIMIT=35] -->
    <string name="webview_license_title">System WebView License</string>
    <!-- About phone settings screen, setting option name to see wallpapers attributions -->
    <string name="wallpaper_attributions">Wallpapers</string>
    <!-- About phone settings screen, setting option name to see wallpapers attributions values -->
    <string name="wallpaper_attributions_values">Satellite imagery providers:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky</string>

    <!-- Phone Manual -->
    <string name="settings_manual_activity_title">Manual</string>
    <!-- About phone settings screen, Manual dialog message when manual cannot be loaded -->
    <string name="settings_manual_activity_unavailable">There is a problem loading the manual.</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\u2019t 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\u2019t 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\u2019t 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>

    <!-- Message to be used to explain the user that he needs to enter his pattern to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pattern_generic">Use your device pattern to continue.</string>
    <!-- Message to be used to explain the user that he needs to enter his PIN to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pin_generic">Enter your device PIN to continue.</string>
    <!-- Message to be used to explain the user that he needs to enter his password to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_password_generic">Enter your device password to continue.</string>

    <!-- Security & location settings screen, change security method screen instruction if user
         enters incorrect PIN [CHAR LIMIT=30] -->
    <string name="lockpassword_invalid_pin">Wrong PIN</string>
    <!-- Security & location settings screen, change security method screen instruction if user
         enters incorrect password [CHAR LIMIT=30] -->
    <string name="lockpassword_invalid_password">Wrong password</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction if user
         draws incorrect pattern [CHAR LIMIT=30] -->
    <string name="lockpattern_need_to_unlock_wrong">Wrong pattern</string>

    <!-- Lock Pattern settings -->
    <!-- Security & location settings screen, header -->
    <string name="lock_settings_title">Device 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 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">Clear</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 optional summary when a trust agent is enabled-->
    <string name="lockpattern_settings_power_button_instantly_locks_summary">Except when kept unlocked by <xliff:g id="trust_agent_name">%1$s</xliff:g></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, confirm unlock pattern screen hint at the bottom after
         too many incorrect attempts [CHAR LIMIT=120]-->
    <string name="lockpattern_too_many_failed_confirmation_attempts">Too many incorrect attempts. Try again in <xliff:g id="number">%d</xliff:g> seconds.</string>
    <!-- Displayed when user launches a widget configuration activity that was uninstalled -->
    <string name="activity_not_found">Application is not installed on your phone.</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 title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  [CHAR LIMIT=30] -->
    <string name="install_applications_title">Allow all app sources</string>
    <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  [CHAR LIMIT=65] -->
    <string name="install_unknown_applications_title">Lets you install apps from sources other than Google Play</string>
    <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  -->
    <string name="install_unknown_applications">Allow installation of apps from unknown sources</string>
    <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
    <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">Open 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>
    <!-- Manage applications, individual application info screen, menu item to uninstall an application for all users. -->
    <string name="uninstall_all_users_text">Uninstall for all users</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, individual application info screen, button label under Storage heading. Button to install an application for the user. -->
    <string name="install_text">Install</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\u2019ve 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\u2019ve 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>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- 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] Advanced applications screen, preference title.  Choose the emergency application. -->
    <string name="default_emergency_app">Emergency app</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
        <li>Any permission restrictions</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>
    <!-- [CHAR LIMIT=NONE] Text for filter option in ManageApps screen to display disabled apps -->
    <string name="filter_apps_disabled">Disabled</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=30] Manage applications, text telling using an application is not installed for the current user. The key part is that it's not installed. -->
    <string name="not_installed">Not installed for this user</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=30] Title for internal device storage that is capitalized for placement as a phrase into another sentence -->
    <string name="internal_storage_sentence">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\u2019s 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\u2019t 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\u2019t 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\u2019t 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>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading after the app has tried to send to a premium SMS. [CHAR LIMIT=50] -->
    <string name="security_settings_billing_desc">This app may charge you money:</string>
    <!-- Manage applications, text for permission to send to premium SMS short codes. [CHAR LIMIT=40] -->
    <string name="security_settings_premium_sms_desc">Send premium SMS</string>
    <string name="computing_size">Computing\u2026</string>
    <string name="invalid_size_value">Couldn\u2019t compute package size.</string>
    <!-- String displayed when list is empty -->
    <string name="empty_list_msg">You don\u2019t 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\u2019t exist.</string>
    <string name="app_forward_locked">App is copy-protected.</string>
    <string name="invalid_location">Install location isn\u2019t valid.</string>
    <string name="system_package">System updates can\u2019t 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\u2019t 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=30] Manage applications, label for option to disable app -->
    <string name="app_disable_dlg_positive">Disable app</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when disabling apps -->
    <string name="app_disable_dlg_text">If you disable this app, other apps may no longer function as intended.</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, title for dialog when disabling updated apps -->
    <string name="app_special_disable_dlg_title">Delete data and disable app?</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, text for dialog when disabling update apps -->
    <string name="app_special_disable_dlg_text">If you disable this app, other apps may no longer function as intended.  Your data will also be deleted.</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>

    <!-- App Ops Settings --> <skip />
    <!-- [CHAR LIMIT=NONE] App ops settings title, on main settings screen. If clicked, the user is taken to a settings screen for app operations -->
    <string name="app_ops_settings">App ops</string>
    <!-- [CHAR LIMIT=NONE] Time label for an operation that is currently running. -->
    <string name="app_ops_running">Running</string>
    <!-- [CHAR LIMIT=NONE] Time label for an operation that has never executed. -->
    <string name="app_ops_never_used">(Never used)</string>

    <!-- [CHAR LIMIT=25] Text shown when there are no default Apps -->
    <string name="no_default_apps">No default Apps.</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>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- [CHAR LIMIT=NONE] Label of a running process that represents another user -->
    <string name="running_process_item_user_label">User: <xliff:g id="user_name">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Label of a running process that represents a removed -->
    <string name="running_process_item_removed_user_label">Removed user</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>
    <!-- [CHAR LIMIT=NONE] Top title of the header of the running processes/services list. -->
    <string name="running_processes_header_title">Device memory</string>
    <!-- [CHAR LIMIT=NONE] Bottom test of the header leading in to the running
         processes/services list. -->
    <string name="running_processes_header_footer">App RAM usage</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing RAM
         used by system. -->
    <string name="running_processes_header_system_prefix">System</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing RAM
         used by apps. -->
    <string name="running_processes_header_apps_prefix">Apps</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing RAM
         that is free. -->
    <string name="running_processes_header_free_prefix">Free</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing total RAM
         used by everything. -->
    <string name="running_processes_header_used_prefix">Used</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing portion
         of free RAM that is used by cached apps. -->
    <string name="running_processes_header_cached_prefix">Cached</string>
    <!-- [CHAR_LIMIT=20] Running processes/services header: formatter for RAM use amount. -->
    <string name="running_processes_header_ram"><xliff:g id="ram">%1$s</xliff:g> of RAM</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\u2019t 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\u2019s 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>
    <!-- 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 title of the list item to go into the Personal dictionary settings screen. [CHAR LIMIT=35] -->
    <string name="user_dict_settings_title">Personal dictionary</string>
    <!-- User dictionary settings.  The summary of the list item to go into the Personal 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. Hint for the text field to type the word to add to the user dictionary. [CHAR LIMIT=35] -->
    <string name="user_dict_settings_add_word_hint">Type a word</string>
    <!-- User dictionary settings. Hint for the text field to type the optional shortcut to add to the user dictionary. [CHAR LIMIT=35] -->
    <string name="user_dict_settings_add_shortcut_hint">Optional shortcut</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\u2019t 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>
    <!-- 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>

    <!-- 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 keyboard, also known as input method [CHAR LIMIT=35] -->
    <string name="current_input_method">Current Keyboard</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. -->
    <!-- Error message for users that aren't allowed to modify developer options [CHAR LIMIT=none] -->
    <string name="development_settings_not_available">Developer options are not available for this user</string>
    <!-- Error message for users that aren't allowed to modify VPN settings [CHAR LIMIT=none] -->
    <string name="vpn_settings_not_available">VPN settings are not available for this user</string>
    <!-- Error message for users that aren't allowed to modify Tethering settings [CHAR LIMIT=none] -->
    <string name="tethering_settings_not_available">Tethering settings are not available for this user</string>
    <!-- Error message for users that aren't allowed to modify Access Point Names settings [CHAR LIMIT=none] -->
    <string name="apn_settings_not_available">Access Point Name settings are not available for this user</string>
    <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 title to revoke secure USB debugging authorizations -->
    <string name="clear_adb_keys">Revoke USB debugging authorizations</string>
    <!-- [CHAR LIMIT=NONE] Setting checkbox title for Whether to include bug report item in power menu. -->
    <string name="bugreport_in_power">Bug report shortcut</string>
    <!-- [CHAR LIMIT=NONE] Setting checkbox summary for Whether to include bug report item in power -->
    <string name="bugreport_in_power_summary">Show a button in the power menu for taking a bug report</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 enable bluetooth HCI snoop log -->
    <string name="bt_hci_snoop_log">Enable Bluetooth HCI snoop log</string>
    <!-- setting Checkbox summary whether to capture all bluetooth HCI packets in a file -->
    <string name="bt_hci_snoop_log_summary">Capture all bluetooth HCI packets in a file</string>
    <!-- setting Checkbox title whether to enable OEM unlock [CHAR_LIMIT=35] -->
    <string name="oem_unlock_enable">OEM unlocking</string>
    <!-- setting Checkbox summary whether to enable OEM unlock [CHAR_LIMIT=50] -->
    <string name="oem_unlock_enable_summary">Allow the bootloader to be unlocked</string>
    <!-- Confirmation dialog title to ensure user wishes to enable OEM unlock and disable theft protection features -->
    <string name="confirm_enable_oem_unlock_title">Allow OEM unlocking?</string>
    <!-- Warning dialog message to confirm user wishes to enable OEM unlock and disable theft protection features -->
    <string name="confirm_enable_oem_unlock_text">WARNING: Device protection features will not work on this device while this setting is turned on.</string>

    <!-- UI debug setting: limit size of Android logger buffers -->
    <string name="select_logd_size_title">Logger buffer sizes</string>
    <!-- UI debug setting: limit size of Android logger buffers [CHAR LIMIT=59] -->
    <string name="select_logd_size_dialog_title">Select Logger sizes per log buffer</string>

    <!-- UI debug setting: select current app to mock location [CHAR LIMIT=50] -->
    <string name="mock_location_app">Select mock location app</string>
    <!-- UI debug setting: no mock location app has been set [CHAR LIMIT=50] -->
    <string name="mock_location_app_not_set">No mock location app set</string>
    <!-- UI debug setting: mock location app has been set [CHAR LIMIT=50] -->
    <string name="mock_location_app_set">Mock location app: <xliff:g id="app_name">%1$s</xliff:g></string>

    <!-- Setting Checkbox title whether to enable view attribute inspection -->
    <string name="debug_view_attributes">Enable view attribute inspection</string>
    <!-- Title of warning dialog about the implications of enabling USB debugging -->

    <!-- Preference category for networking debugging development settings. [CHAR LIMIT=50] -->
    <string name="debug_networking_category">Networking</string>

    <!-- Setting Checkbox title whether to show options for wireless display certification -->
    <string name="wifi_display_certification">Wireless display certification</string>
    <!-- Setting Checkbox title whether to enable WiFi Verbose Logging. [CHAR LIMIT=40] -->
    <string name="wifi_verbose_logging">Enable Wi\u2011Fi Verbose Logging</string>
    <!-- Setting Checkbox title whether to enable WiFi Aggressive Handover. [CHAR LIMIT=40] -->
    <string name="wifi_aggressive_handover">Aggressive Wi\u2011Fi to Cellular handover</string>
    <!-- Setting Checkbox title whether to enable WiFi Scanning in the presence of traffic. [CHAR LIMIT=80] -->
    <string name="wifi_allow_scan_with_traffic">Always allow Wi\u2011Fi Roam Scans</string>
    <!-- Setting Checkbox title whether to enable WiFi Scanning in the presence of traffic. [CHAR LIMIT=80] -->
    <string name="legacy_dhcp_client">Use legacy DHCP client</string>
    <!-- Setting Checkbox title whether to always keep cellular data active. [CHAR LIMIT=80] -->
    <string name="mobile_data_always_on">Cellular data always active</string>

    <!-- setting Checkbox summary whether to show options for wireless display certification  -->
    <string name="wifi_display_certification_summary">Show options for wireless display certification</string>
    <!-- Setting Checkbox summary whether to enable Wifi verbose Logging [CHAR LIMIT=80] -->
    <string name="wifi_verbose_logging_summary">Increase Wi\u2011Fi logging level, show per SSID RSSI in Wi\u2011Fi Picker</string>
    <!-- Setting Checkbox summary whether to enable Wifi aggressive handover [CHAR LIMIT=130] -->
    <string name="wifi_aggressive_handover_summary">When enabled, Wi\u2011Fi will be more aggressive in handing over the data connection to Cellular, when Wi\u2011Fi signal is low</string>
    <!-- Setting Checkbox summary whether to always allow WiFi Roam Scans [CHAR LIMIT=130] -->
    <string name="wifi_allow_scan_with_traffic_summary">Allow/Disallow Wi\u2011Fi Roam Scans based on the amount of data traffic present at the interface</string>
    <!-- UI debug setting: limit size of Android logger buffers -->
    <string name="select_logd_size_title">Logger buffer sizes</string>
    <!-- UI debug setting: limit size of Android logger buffers [CHAR LIMIT=59] -->
    <string name="select_logd_size_dialog_title">Select Logger sizes per log buffer</string>
    <!-- UI debug setting: select USB configuration -->
    <string name="select_usb_configuration_title">Select USB Configuration</string>
    <!-- UI debug setting: limit size of Android logger buffers [CHAR LIMIT=59] -->
    <string name="select_usb_configuration_dialog_title">Select USB Configuration</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>
    <!-- Setting Checkbox title whether to enable view attribute inspection -->
    <string name="debug_view_attributes">Enable view attribute inspection</string>
    <!-- Title of warning dialog about the implications of enabling USB debugging -->
    <!-- Setting Checkbox summary whether to use DHCP client from Lollipop (Android 5.0) [CHAR LIMIT=130] -->
    <string name="legacy_dhcp_client_summary">Use the DHCP client from Lollipop instead of the new Android DHCP client.</string>
    <string name="mobile_data_always_on_summary">Always keep mobile data active, even when Wi\u2011Fi is active (for fast network switching).</string>
    <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>
    <!-- Message of dialog confirming that user wants to revoke access to adb from all computers they have authorized -->
    <string name="adb_keys_warning_message">Revoke access to USB debugging from all computers you\u2019ve previously authorized?</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 to perform package verification on apps installed over USB/ADT/ADB [CHAR LIMIT=32] -->
    <string name="verify_apps_over_usb_title">Verify apps over USB</string>
    <!-- Summary of checkbox setting to perform package verification on apps installed over USB/ADT/ADB [CHAR LIMIT=NONE] -->
    <string name="verify_apps_over_usb_summary">Check apps installed via ADB/ADT for harmful behavior.</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 of checkbox setting that enables the terminal app. [CHAR LIMIT=32] -->
    <string name="enable_terminal_title">Local terminal</string>
    <!-- Summary of checkbox setting that enables the terminal app. [CHAR LIMIT=64] -->
    <string name="enable_terminal_summary">Enable terminal app that offers local shell access</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>

    <!-- 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_no_seconds"><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</string>

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

    <!-- Used to show an amount of time in the form "m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_minutes_no_seconds"><xliff:g id="minutes">%1$d</xliff:g>m</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 last time used -->
    <string name="last_time_used_label">Last time used</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 category of display related preferences. [CHAR LIMIT=25] -->
    <string name="accessibility_display_title">Display</string>
    <!-- Title for the accessibility preference screen to enable video captioning. [CHAR LIMIT=35] -->
    <string name="accessibility_captioning_title">Captions</string>
    <!-- Title for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_title">Magnification gestures</string>
    <!-- Summary for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_summary">When this feature is turned on, you can zoom in and out by triple-tapping the screen.\n\nWhile zoomed in, you can:\n<ul><li>Pan: Drag two or more fingers across the screen.</li>\n<li>Adjust zoom level: Pinch two or more fingers together or spread them apart.</li></ul>\n\nYou can also temporarily magnify what\u2019s under your finger by triple-tapping and holding. In this magnified state, you can drag your finger to explore different parts of the screen. Lift your finger to return to your previous state.\n\nNote: Triple-tap for magnification works everywhere except the keyboard and navigation bar.</string>
    <!-- Title for the preference to enable the global geture that turns on accessibility. [CHAR LIMIT=35] -->
    <string name="accessibility_global_gesture_preference_title">Accessibility shortcut</string>
    <!-- Summary for the preference to enable the global geture that turns on accessibility (on state). [CHAR LIMIT=60] -->
    <string name="accessibility_global_gesture_preference_summary_on">On</string>
    <!-- Summary for the preference screen to enable the global geture that turns on accessibility (off state). [CHAR LIMIT=35] -->
    <string name="accessibility_global_gesture_preference_summary_off">Off</string>
    <!--  Description for the preference screen to enable the global geture taht turns on accessibility. [CHAR LIMIT=none] -->
    <string name="accessibility_global_gesture_preference_description">When this feature is turned on, you can quickly enable accessibility features in two steps:\n\nStep 1: Press and hold the power button until you hear a sound or feel a vibration.\n\nStep 2: Touch and hold two fingers until you hear audio confirmation.\n\nIf the device has multiple users, using this shortcut on the lock screen temporarily enables accessibility until the device is unlocked.</string>
    <!-- Title for the accessibility preference to enable large text. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_large_text_preference_title">Large text</string>
    <!-- Title for the accessibility preference to high contrast text. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_high_text_contrast_preference_title">High contrast text</string>
    <!-- Title for the accessibility preference to enable screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_screen_magnification_preference_title">Screen magnification</string>
    <!-- Title for the accessibility preference to auto update screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title">Auto
        update screen magnification</string>
    <!-- Summary for the accessibility preference to auto update screen magnification. [CHAR LIMIT=50] -->
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary">Update
        screen magnification on app transitions</string>
    <!-- Title for the accessibility preference to power button to end a call. [CHAR LIMIT=35] -->
    <string name="accessibility_power_button_ends_call_prerefence_title">Power button ends call</string>
    <!-- Title for the accessibility preference to speak passwords. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_speak_password_preference_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_preference_title">Touch &amp; hold delay</string>
    <!-- Title for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_title">Color inversion</string>
    <!-- Subtitle for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_subtitle">(Experimental) May affect performance</string>
    <!-- Title for the accessibility preference to configure display color space correction. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_daltonizer_preference_title">Color correction</string>
    <!-- Subtitle for the accessibility preference to configure display color space correction. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_daltonizer_preference_subtitle">This feature is experimental and may affect performance.</string>

    <!-- Title for the preference to show a tile for a particular feature in the Quick Settings pane. [CHAR LIMIT=NONE] -->
    <string name="enable_quick_setting">Show in Quick Settings</string>
    <!-- Title for the preference to configure the type of color space correction to apply. [CHAR LIMIT=NONE] -->
    <string name="daltonizer_type">Correction mode</string>
    <!-- Summary shown for color space correction preference when its value is overridden by another preference [CHAR LIMIT=35] -->
    <string name="daltonizer_type_overridden">Overridden by <xliff:g id="title" example="Simulate color space">%1$s</xliff:g></string>

    <!-- Label for disabling color space adjustment [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_disabled">Disabled</string>
    <!-- Label for converting display colors to grayscale, which simulates monochromacy (complete color blindness). [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_monochromacy">Monochromacy</string>
    <!-- Label for deuteranomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_deuteranomaly">Deuteranomaly (red-green)</string>
    <!-- Label for protanomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_protanomaly">Protanomaly (red-green)</string>
    <!-- Label for tritanomaly (blue-yellow color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_tritanomaly">Tritanomaly (blue-yellow)</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 accessibility feature. [CHAR LIMIT=10] -->
    <string name="accessibility_feature_state_on">On</string>
    <!-- Summary for the disabled state of an accessibility feature. [CHAR LIMIT=10] -->
    <string name="accessibility_feature_state_off">Off</string>
    <!-- Summary when an accessibility feature or ime is not permitted. [CHAR LIMIT=40] -->
    <string name="accessibility_feature_or_input_method_not_allowed">Not allowed by your organization</string>

    <!-- Title for the preference category containing the video caption preview. [CHAR LIMIT=35] -->
    <string name="captioning_preview_title">Preview</string>
    <!-- Title for the preference catgeory containing standard video caption options. [CHAR LIMIT=35] -->
    <string name="captioning_standard_options_title">Standard options</string>
    <!-- Title for the preference to change video caption locale. [CHAR LIMIT=35] -->
    <string name="captioning_locale">Language</string>
    <!-- Title for the preference to change video caption text size. [CHAR LIMIT=35] -->
    <string name="captioning_text_size">Text size</string>
    <!-- Title for the preference category containing video caption property presets. [CHAR LIMIT=35] -->
    <string name="captioning_preset">Caption style</string>
    <!-- Title for the preference catgeory containing custom video caption properties. [CHAR LIMIT=35] -->
    <string name="captioning_custom_options_title">Custom options</string>
    <!-- Title for the preference to change video caption background color. [CHAR LIMIT=35] -->
    <string name="captioning_background_color">Background color</string>
    <!-- Title for the preference to change video caption background opacity. [CHAR LIMIT=35] -->
    <string name="captioning_background_opacity">Background opacity</string>
    <!-- Title for the preference to change video caption window color. [CHAR LIMIT=35] -->
    <string name="captioning_window_color">Caption window color</string>
    <!-- Title for the preference to change video caption window opacity. [CHAR LIMIT=35] -->
    <string name="captioning_window_opacity">Caption window opacity</string>
    <!-- Title for the preference to change video caption text color. [CHAR LIMIT=35] -->
    <string name="captioning_foreground_color">Text color</string>
    <!-- Title for the preference to change video caption text opacity. [CHAR LIMIT=35] -->
    <string name="captioning_foreground_opacity">Text opacity</string>
    <!-- Title for the preference to change video caption edge color. [CHAR LIMIT=35] -->
    <string name="captioning_edge_color">Edge color</string>
    <!-- Title for the preference to change video caption edge type. [CHAR LIMIT=35] -->
    <string name="captioning_edge_type">Edge type</string>
    <!-- Title for the preference to change video caption font family (ex. monospace, sans-serif). [CHAR LIMIT=35] -->
    <string name="captioning_typeface">Font family</string>
    <!-- Sample text for previewing video caption preferences. [CHAR LIMIT=NONE] -->
    <string name="captioning_preview_text">Captions will look like this</string>
    <!-- Sample characters for previewing video caption preferences. [CHAR LIMIT=2] -->
    <string name="captioning_preview_characters">Aa</string>

    <!-- Label for the default device locale. [CHAR LIMIT=35] -->
    <string name="locale_default">Default</string>

    <!-- Label for color selection title in sim settings [CHAR LIMIT=35] -->
    <string name = "color_title">Color</string>
    <!-- Label for default color. This lets the app pick the color. [CHAR LIMIT=35] -->
    <string name="color_unspecified">Default</string>
    <!-- Label for no color (transparent). [CHAR LIMIT=35] -->
    <string name="color_none">None</string>
    <!-- Label for the color white. [CHAR LIMIT=35] -->
    <string name="color_white">White</string>
    <!-- Label for the color gray. [CHAR LIMIT=35] -->
    <string name="color_gray">Gray</string>
    <!-- Label for the color black. [CHAR LIMIT=35] -->
    <string name="color_black">Black</string>
    <!-- Label for the color red. [CHAR LIMIT=35] -->
    <string name="color_red">Red</string>
    <!-- Label for the color green. [CHAR LIMIT=35] -->
    <string name="color_green">Green</string>
    <!-- Label for the color blue. [CHAR LIMIT=35] -->
    <string name="color_blue">Blue</string>
    <!-- Label for the color cyan. [CHAR LIMIT=35] -->
    <string name="color_cyan">Cyan</string>
    <!-- Label for the color yellow. [CHAR LIMIT=35] -->
    <string name="color_yellow">Yellow</string>
    <!-- Label for the color magenta. [CHAR LIMIT=35] -->
    <string name="color_magenta">Magenta</string>
    <!-- Label for custom colors, formats as a HTML color. -->
    <string name="color_custom" translatable="false">#%1$02X%2$02X%3$02X</string>

    <!-- Title for a warning about security implications of enabling an accessibility
         service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_title">Use
         <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Title for the list of capabilities of an accessibility service. -->
    <string name="capabilities_list_title"><xliff:g id="service" example="TalkBack">%1$s</xliff:g>
        needs to:</string>
    <!-- Warning shown when user input has been blocked due to another app overlaying screen
         content. Since we don't know what the app is showing on top of the input target, we
         can't verify user consent. [CHAR LIMIT=NONE] -->
    <string name="touch_filtered_warning">Because an app is obscuring a permission request, Settings
        can’t verify your response.</string>
    <!-- Warning that the device data will not be encrypted with password or PIN if
        enabling an accessibility service and there is a secure lock setup. [CHAR LIMIT=NONE] -->
    <string name="enable_service_encryption_warning">If you turn on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g>, your device won’t use your screen lock to enhance
        data encryption.</string>
    <!-- Warning that the device data will not be encrypted with password or PIN if
         choosing a secure lock and there is an enabled accessibility service. [CHAR LIMIT=NONE] -->
    <string name="secure_lock_encryption_warning">Because you\u2019ve turned on an accessibility service,
        your device won’t use your screen lock to enhance data encryption.</string>

    <!-- Message to the user to enter his pattern before enabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_pattern_reason">Because turning on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> affects data encryption, you need to confirm your pattern.
    </string>

    <!-- Message to the user to enter his PIN before enabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_pin_reason">Because turning on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> affects data encryption, you need to confirm your PIN.
    </string>

    <!-- Message to the user to enter his password before enabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_password_reason">Because turning on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> affects data encryption, you need to confirm your password.
    </string>

    <!-- Title for the capability of an accessibility service to receive events and keys. -->
    <string name="capability_title_receiveAccessibilityEvents">Observe your actions</string>
    <!-- Description for the capability of an accessibility service to receive events and keys. -->
    <string name="capability_desc_receiveAccessibilityEvents">Receive notifications when you\u2019re
        interacting with an app.</string>

    <!-- Title for a warning about disabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="disable_service_title">Stop <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Message for a warning about disabling accessibility service. [CHAR LIMIT=NONE] -->
    <string name="disable_service_message">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>

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

     <!-- Printing settings -->
    <skip />

    <!-- Title in main settings screen for printing settings [CHAR LIMIT=15] -->
    <string name="print_settings">Printing</string>
    <!-- Title for print service settings screen [CHAR LIMIT=25] -->
    <string name="print_settings_title">Print services</string>

    <!-- Title for a warning message about security implications of enabling a print service,
         displayed as a dialog message when the user selects to enable a print service (tablet). [CHAR LIMIT=NONE] -->
    <string name="print_service_security_warning_title">Use
         <xliff:g id="service" example="My Print Service">%1$s</xliff:g>?</string>
    <!-- Summary for a warning message about security implications of enabling a print service,
         displayed as a dialog message when the user selects to enable a print service. [CHAR LIMIT=NONE] -->
    <string name="print_service_security_warning_summary">Your document may pass through
        one or more servers on its way to the printer.</string>

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

    <!-- Title for the prompt shown as a placeholder if no printers are found while searching. [CHAR LIMIT=50] -->
    <string name="print_no_printers_found">No printers found</string>

    <!-- Title for print menu item to launch a settings activity. [CHAR LIMIT=25] -->
    <string name="print_menu_item_settings">Settings</string>

    <!-- Title for print menu item to launch the add printers activity. [CHAR LIMIT=25] -->
    <string name="print_menu_item_add_printers">Add printers</string>

    <!-- Summary for the enabled state of a print feature. [CHAR LIMIT=10] -->
    <string name="print_feature_state_on">On</string>
    <!-- Summary for the disabled state of a print feature. [CHAR LIMIT=10] -->
    <string name="print_feature_state_off">Off</string>

    <!-- Title of the action bar button to got to Play Store to download a print service. [CHAR LIMIT=25] -->
    <string name="print_menu_item_add_service">Add service</string>

    <!-- Title of the action bar button to got to add a printer. [CHAR LIMIT=25] -->
    <string name="print_menu_item_add_printer">Add printer</string>

    <!-- Title for the search action bar menu item. [CHAR LIMIT=20] -->
    <string name="print_menu_item_search">Search</string>

    <!-- Title for the prompt if no printers are available and the system is searching for such. [CHAR LIMIT=50] -->
    <string name="print_searching_for_printers">Searching for printers</string>

    <!-- Title for the prompt if no printers are available because the print service is disabled. [CHAR LIMIT=50] -->
    <string name="print_service_disabled">Service disabled</string>

    <!-- Title for the menu item to open the print jobs screen. [CHAR LIMIT=25] -->
    <string name="print_print_jobs">Print jobs</string>

    <!-- Title for the print job settings screen. [CHAR LIMIT=25] -->
    <string name="print_print_job">Print job</string>

    <!-- Title for the button to restart a print job. [CHAR LIMIT=25] -->
    <string name="print_restart">Restart</string>

    <!-- Title for the button to cancel a print job. [CHAR LIMIT=25] -->
    <string name="print_cancel">Cancel</string>

    <!-- Template for the summary of a print job. [CHAR LIMIT=25] -->
    <string name="print_job_summary"><xliff:g id="printer">%1$s</xliff:g>\n<xliff:g id="time">%2$s</xliff:g></string>

    <!-- Template for the label of the state for a ongoing print job. [CHAR LIMIT=25] -->
    <string name="print_printing_state_title_template">Printing <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label for a cancelling print job. [CHAR LIMIT=25] -->
    <string name="print_cancelling_state_title_template" >Cancelling <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label of the state for a failed print job. [CHAR LIMIT=25] -->
    <string name="print_failed_state_title_template">Printer error <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label of the state for a blocked print job. [CHAR LIMIT=25] -->
    <string name="print_blocked_state_title_template">Printer blocked <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Utterance to announce that the search box is shown. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <string name="print_search_box_shown_utterance">Search box shown</string>

    <!-- Utterance to announce that the search box is hidden. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <string name="print_search_box_hidden_utterance">Search box hidden</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\u2019t available.</string>
    <!-- Display the battery level and status [CHAR_LIMIT=60] -->
    <string name="power_usage_level_and_status"><xliff:g id="level">%1$s</xliff:g>
            - <xliff:g id="status">%2$s</xliff:g></string>
    <!-- Display time remaining until battery is discharged [CHAR_LIMIT=60] -->
    <string name="power_discharge_remaining"><xliff:g id="remain">%1$s</xliff:g> remaining</string>
    <!-- Display time remaining until battery is charged [CHAR_LIMIT=60] -->
    <string name="power_charge_remaining"><xliff:g id="until_charged">%1$s</xliff:g> to charge</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when discharging with duration -->
    <string name="power_discharging_duration"><xliff:g id="level">%1$s</xliff:g>
            - approx. <xliff:g id="time">%2$s</xliff:g> left</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging -->
    <string name="power_charging"><xliff:g id="level">%1$s</xliff:g> -
            <xliff:g id="state">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging with duration -->
    <string name="power_charging_duration"><xliff:g id="level">%1$s</xliff:g> -
            <xliff:g id="time">%2$s</xliff:g> until full</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging with duration -->
    <string name="power_charging_duration_ac"><xliff:g id="level">%1$s</xliff:g> -
            <xliff:g id="time">%2$s</xliff:g> until full on AC</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging with duration -->
    <string name="power_charging_duration_usb"><xliff:g id="level">%1$s</xliff:g> -
            <xliff:g id="time">%2$s</xliff:g> until full over USB</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging with duration -->
    <string name="power_charging_duration_wireless"><xliff:g id="level">%1$s</xliff:g> -
            <xliff:g id="time">%2$s</xliff:g> until full from wireless</string>
    <!-- [CHAR_LIMIT=40] Label for list of apps using battery in power use UI -->
    <string name="power_usage_list_summary">Use since last full charge</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 camera on state graph -->
    <string name="battery_stats_camera_on_label">Camera on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats flashlight on state graph -->
    <string name="battery_stats_flashlight_on_label">Flashlight on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats wifi running state graph -->
    <string name="battery_stats_wifi_running_label">Wi\u2011Fi</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">Cellular network signal</string>
    <!-- Battery usage during last unplugged period -->
    <string name="battery_stats_last_duration">@string/menu_stats_last_unplugged</string>
    <!-- CPU awake time title -->
    <string name="awake">Device awake time</string>
    <!-- Wifi on time -->
    <string name="wifi_on_time">Wi\u2011Fi on time</string>
    <!-- Bluetooth on time -->
    <string name="bluetooth_on_time">Wi\u2011Fi on time</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 the flashlight -->
    <string name="power_flashlight">Flashlight</string>
    <!-- Label for power consumed by the camera -->
    <string name="power_camera">Camera</string>
    <!-- Label for power consumed by Wi-Fi -->
    <string name="power_wifi">Wi\u2011Fi</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 power that we aren't able to account for -->
    <string name="power_unaccounted">Miscellaneous</string>
    <!-- Label for power that we computed too much for -->
    <string name="power_overcounted">Over-counted</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\u2011Fi 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 mobile network data sent [CHAR LIMIT=32] -->
    <string name="usage_type_data_send">Mobile packets sent</string>
    <!-- Label for mobile network data received [CHAR LIMIT=32] -->
    <string name="usage_type_data_recv">Mobile packets received</string>
    <!-- Label for mobile network radio active time [CHAR LIMIT=32] -->
    <string name="usage_type_radio_active">Mobile radio active</string>
    <!-- Label for Wi-Fi network data sent [CHAR LIMIT=32] -->
    <string name="usage_type_data_wifi_send">Wi\u2011Fi packets sent</string>
    <!-- Label for Wi-Fi network data received [CHAR LIMIT=32] -->
    <string name="usage_type_data_wifi_recv">Wi\u2011Fi packets 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 Camera usage time -->
    <string name="usage_type_camera">Camera</string>
    <!-- Label for Flashlight usage time -->
    <string name="usage_type_flashlight">Flashlight</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 the total power capacity of the device's battery -->
    <string name="usage_type_total_battery_capacity">Total battery capacity</string>
    <!-- [CHAR_LIMIT=NONE] Label for amount of power use that was computed -->
    <string name="usage_type_computed_power">Computed power use</string>
    <!-- [CHAR_LIMIT=NONE] Label for amount of power use that was actually observed (though
         the change in battery level) -->
    <string name="usage_type_actual_power">Observed power use</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\u2011Fi 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>

    <!-- [CHAR_LIMIT=NONE] Description for power consumed by the flashlight -->
    <string name="battery_desc_flashlight">Battery used by the flashlight</string>

    <!-- [CHAR_LIMIT=NONE] Description for power consumed by the camera -->
    <string name="battery_desc_camera">Battery used by the camera</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\u2011Fi</string>
    <!-- Suggestion for wifi connectivity power drain -->
    <string name="battery_sugg_wifi">Turn off Wi\u2011Fi when not using it or when it isn\u2019t 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\u2019t 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">Select battery-saving mode</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>

    <!-- [CHAR LIMIT=50] Description for power consumed by users -->
    <string name="battery_desc_users">Battery used by user</string>

    <!-- [CHAR LIMIT=50] Description for unaccounted power use -->
    <string name="battery_desc_unaccounted">Miscellaneous power use</string>
    <!-- [CHAR LIMIT=NONE] Description for unaccounted power use -->
    <string name="battery_msg_unaccounted">Battery use is an approximation of power
        use and does not include every source of battery drain.  Miscellaneous is the difference
        between the computed approximate power use and the actual drain observed on the
        battery.</string>
    <!-- [CHAR LIMIT=50] Description for over-counted power use -->
    <string name="battery_desc_overcounted">Over-counted power use</string>
    <!-- Representation of a mAh value. [CHAR LIMIT=NONE] -->
    <string name="mah"><xliff:g id="number" example="30">%d</xliff:g> mAh</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>

    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Label for kernel threads in battery usage -->
    <string name="process_kernel_label">Android OS</string>
    <!-- Label for mediaserver process in battery usage -->
    <string name="process_mediaserver_label">Mediaserver</string>
    <!-- Label for dex2oat process in battery usage used for the optimization of one or more apps -->
    <string name="process_dex2oat_label">App optimization</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Label for feature, title + menu item -->
    <string name="battery_saver">Battery saver</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Title for automatic entry option -->
    <string name="battery_saver_turn_on_automatically_title">Turn on automatically</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Value for automatic entry option: Never -->
    <string name="battery_saver_turn_on_automatically_never">Never</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Value for automatic entry option: pct% battery -->
    <string name="battery_saver_turn_on_automatically_pct">at %1$s battery</string>

    <!-- Process Stats strings -->
    <skip />

    <!-- [CHAR LIMIT=NONE] Activity title for Process Stats summary -->
    <string name="process_stats_summary_title">Process Stats</string>
    <!-- [CHAR LIMIT=NONE] Activity title summary for Process Stats summary -->
    <string name="process_stats_summary">Geeky stats about running processes</string>
    <!-- [CHAR LIMIT=NONE] Label for amount of memory use -->
    <string name="app_memory_use">Memory use</string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, duration of time the stats are over;
         timeDuration is a duration such as "1h 30m" -->
    <string name="process_stats_total_duration"><xliff:g id="usedRam">%1$s</xliff:g>
        of <xliff:g id="totalRam">%2$s</xliff:g> used over last
        <xliff:g id="timeDuration">%3$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, duration of time the stats are over;
         timeDuration is a duration such as "1h 30m" -->
    <string name="process_stats_total_duration_percentage"><xliff:g id="percent" example="50%">%1$s</xliff:g>
        of RAM used over
        <xliff:g id="timeDuration">%2$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, text for stats type -->
    <string name="process_stats_type_background">Background</string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, text for stats type -->
    <string name="process_stats_type_foreground">Foreground</string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, text for stats type -->
    <string name="process_stats_type_cached">Cached</string>
    <!-- [CHAR LIMIT=NONE] Label OS "process" app -->
    <string name="process_stats_os_label">Android OS</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for all native processes -->
    <string name="process_stats_os_native">Native</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for all kernel memory -->
    <string name="process_stats_os_kernel">Kernel</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for all zram memory -->
    <string name="process_stats_os_zram">Z-Ram</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for base memory needed for caches -->
    <string name="process_stats_os_cache">Caches</string>
    <!-- [CHAR LIMIT=NONE] Label for item showing details of average RAM use -->
    <string name="process_stats_ram_use">RAM use</string>
    <!-- [CHAR LIMIT=NONE] Label for item showing details of average RAM use -->
    <string name="process_stats_bg_ram_use">RAM use (background)</string>
    <!-- [CHAR LIMIT=NONE] Label for item showing percent of time spent running -->
    <string name="process_stats_run_time">Run time</string>
    <!-- [CHAR LIMIT=NONE] Subtitle for process stats processes list -->
    <string name="processes_subtitle">Processes</string>
    <!-- [CHAR LIMIT=NONE] Subtitle for process stats services list -->
    <string name="services_subtitle">Services</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to select duration of stats to show -->
    <string name="menu_proc_stats_duration">Duration</string>
    <!-- [CHAR LIMIT=NONE] Activity title for process stats details on overall memory state -->
    <string name="mem_details_title">Memory details</string>
    <!-- [CHAR LIMIT=NONE] Subtitle for process stats memory state details for list of memory states -->
    <string name="mem_state_subtitle">Memory states</string>
    <!-- [CHAR LIMIT=NONE] Subtitle for process stats memory state details for list of memory use -->
    <string name="mem_use_subtitle">Memory use</string>
    <!-- [CHAR LIMIT=NONE] Type of memory use associated with the kernel -->
    <string name="mem_use_kernel_type">Kernel</string>
    <!-- [CHAR LIMIT=NONE] Type of memory use associated with native processes -->
    <string name="mem_use_native_type">Native</string>
    <!-- [CHAR LIMIT=NONE] Type of memory use associated with kernel caches -->
    <string name="mem_use_kernel_cache_type">Kernel caches</string>
    <!-- [CHAR LIMIT=NONE] Type of memory use associated with kernel zram swap -->
    <string name="mem_use_zram_type">ZRam swap</string>
    <!-- [CHAR LIMIT=NONE] Type of memory use that is available/free -->
    <string name="mem_use_free_type">Free</string>
    <!-- [CHAR LIMIT=NONE] Total of all memory use -->
    <string name="mem_use_total">Total</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_3h">3 hours</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_6h">6 hours</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_12h">12 hours</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_1d">1 day</string>
    <!-- [CHAR LIMIT=NONE] Menu for manage apps to control whether system processes are shown -->
    <string name="menu_show_system">Show system</string>
    <!-- [CHAR LIMIT=NONE] Menu for manage apps to control whether system processes are hidden -->
    <string name="menu_hide_system">Hide system</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to control whether stats are shown
         as percentages-->
    <string name="menu_show_percentage">Show percentages</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to control whether computation should be based
        on Uss (Unique Set Size) instead of Pss (Proportional Set Size) -->
    <string name="menu_use_uss">Use Uss</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to select which type of stats to show -->
    <string name="menu_proc_stats_type">Stats type</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show information on background processes -->
    <string name="menu_proc_stats_type_background">Background</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show information on foreground processes -->
    <string name="menu_proc_stats_type_foreground">Foreground</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show information on cached processes -->
    <string name="menu_proc_stats_type_cached">Cached</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>

    <!-- Voice input settings --><skip />
    <!-- [CHAR_LIMIT=NONE] Name of the settings item to open the voice input settings. -->
    <string name="voice_input_settings">Voice input settings</string>
    <!-- [CHAR_LIMIT=NONE] Title of the screen of the voice input settings -->
    <string name="voice_input_settings_title">Voice input</string>
    <!-- [CHAR LIMIT=50] The text for the settings section in which users select
         a voice interaction or recognition service to use. -->
    <string name="voice_service_preference_section_title">Voice input services</string>
    <!-- [CHAR LIMIT=NONE] The summary text for the voice service preference that is
         a full voice interaction service.  This is something that provides interactive
         voice control of applications; for example you can tell it commands to have it
         launch and let you interact with applications through your voice. -->
    <string name="voice_interactor_preference_summary">Full hotword and interaction</string>
    <!-- [CHAR LIMIT=NONE] The summary text for the voice service preference that is
         a simple voice recognition service.  This is something that only provides simple
         speech to text conversions that applications can use when they want to allow you
         to provide text to them through your voice (instead of with a keyboard). -->
    <string name="voice_recognizer_preference_summary">Simple speech to text</string>
    <!-- [CHAR_LIMIT=NONE] Warning message about security implications of enabling a
         voice interaction service, displayed as a dialog
         message when the user selects to enable a service. -->
    <string name="voice_interaction_security_warning">This voice input service will be able to
        perform always-on voice monitoring and control voice enabled applications on your
        behalf.  It comes from the <xliff:g id="voice_input_service_app_name">%s</xliff:g>
        application.  Enable the use of this service?</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">Set 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>
    <!-- Entry in the TTS engine language/locale picker, when selected will try to default to the system language [CHAR LIMIT=50] -->
    <string name="tts_lang_use_system">Use system language</string>
    <!-- On main TTS Settings screen, language summary if it can't default to system language [CHAR LIMIT=50] -->
    <string name="tts_lang_not_selected">Language not selected</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\u2019t 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>
    <!-- Warning message about required internet conectivity for TTS synthesis, displayed as a dialog
         message when the user selects to play an example for network only locale and there's no internet connectivity. -->
    <string name="tts_engine_network_required">This language requires a working network connection for text-to-speech output.</string>
    <!-- Text spoken by the TTS engine as an example if the engine doesn't provide sample text [CHAR LIMIT=100] -->
    <string name="tts_default_sample_string">This is an example of speech synthesis</string>
    <!-- On main TTS Settings screen, title of a field explaining current TTS engine status for
         current default language [CHAR LIMIT=50] -->
    <string name="tts_status_title">Default language status</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         selected language is fully supported by the engine [CHAR LIMIT=150]-->
    <string name="tts_status_ok"><xliff:g id="locale" example="English (United States)">%1$s</xliff:g> is fully supported</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         selected language is supported by the engine only if there's a working network connection [CHAR LIMIT=150] -->
    <string name="tts_status_requires_network"><xliff:g id="locale" example="English (United States)">%1$s</xliff:g> requires network connection</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         selected language is not supported by the engine [CHAR LIMIT=150] -->
    <string name="tts_status_not_supported"><xliff:g id="locale" example="English (United States)">%1$s</xliff:g> is not supported</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         tts engine is queried for status [CHAR LIMIT=150] -->
    <string name="tts_status_checking">Checking...</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\u2011Fi setting</string>
    <string name="gadget_toggle_bluetooth">Updating Bluetooth setting</string>
    <!-- Template for gadget toggle button description. Populated examples are "Wi-Fi off" or "Wi-Fi turning on". -->
    <string name="gadget_state_template"><xliff:g name="feature" example="Wi\u2011Fi">%1$s</xliff:g> <xliff:g name="state" example="off">%2$s</xliff:g></string>
    <!-- Gadget value used to describe on state. -->
    <string name="gadget_state_on">on</string>
    <!-- Gadget value used to describe off state. -->
    <string name="gadget_state_off">off</string>
    <!-- Gadget value used to describe turning on state. -->
    <string name="gadget_state_turning_on">turning on</string>
    <!-- Gadget value used to describe turning off state. -->
    <string name="gadget_state_turning_off">turning off</string>
    <!-- Spoken description for the Wi-Fi power control gadget. -->
    <string name="gadget_wifi">Wi\u2011Fi</string>
    <!-- Spoken description for the Bluetooth power control gadget. -->
    <string name="gadget_bluetooth">Bluetooth</string>
    <!-- Spoken description for the Location power control gadget. -->
    <string name="gadget_location">Location</string>
    <!-- Spoken description for the data synchronization gadget. -->
    <string name="gadget_sync">Sync</string>
    <!-- Template for brightness gadget toggle button description. -->
    <string name="gadget_brightness_template">Brightness <xliff:g name="state" example="half">%1$s</xliff:g></string>
    <!-- Brightness gadget value used to describe automatic brightness state. -->
    <string name="gadget_brightness_state_auto">auto</string>
    <!-- Brightness gadget value used to describe maximum brightness state. -->
    <string name="gadget_brightness_state_full">full</string>
    <!-- Brightness gadget value used to describe half brightness state. -->
    <string name="gadget_brightness_state_half">half</string>
    <!-- Brightness gadget value used to describe minimum brightness state. -->
    <string name="gadget_brightness_state_off">off</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>
    <!-- Title of preference group for advance security settings [CHAR LIMIT=30] -->
    <string name="advanced_security_title">Advanced</string>
    <!-- Title of preference of what type of credential storage this device has: hardware or software [CHAR LIMIT=30] -->
    <string name="credential_storage_type">Storage type</string>
    <!-- Summary text for preference showing what type of credential storage this device has when it is stored in a hardware-backed storage (as opposed to "software only") [CHAR LIMIT=NONE] -->
    <string name="credential_storage_type_hardware">Hardware-backed</string>
    <!-- Summary text for preference showing what type of credential storage this device has when it is stored in software only (as opposed to "hardware-backed") [CHAR LIMIT=NONE] -->
    <string name="credential_storage_type_software">Software only</string>
    <!-- Error message for users that aren't allowed to see or modify credentials [CHAR LIMIT=none] -->
    <string name="credentials_settings_not_available">Credentials are not available for this user</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\u2019t 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>

    <!-- Title of Usage Access preference item [CHAR LIMIT=30] -->
    <string name="usage_access_title">Apps with usage access</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\u2011Fi 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>
    <!-- Auto-restore menu title [CHAR LIMIT=30] -->
    <string name="include_app_data_title">Include app data</string>
    <!-- Auto-restore menu title -->
    <string name="auto_restore_title">Automatic restore</string>
    <!-- Summary text of the "automatic restore" setting -->
    <string name="auto_restore_summary">When reinstalling an app, restore backed up settings and data</string>
    <!-- Title of the preference informing the user about the backup service being inactive [CHAR LIMIT=50]-->
    <string name="backup_inactive_title">Backup service is inactive.</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>

    <!-- 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\u2019t 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\u2019t 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\u2011Fi passwords, bookmarks, other settings, and app data, plus erase all copies on Google servers?</string>
    <!-- Dialog title for confirmation to erase full backup data from server -->
    <string name="fullbackup_erase_dialog_message">Stop backing up device data (such as Wi-Fi passwords and call history) and app data (such as settings and files stored by apps), plus erase all copies on Google Drive?</string>
    <!-- Summary for explanation of what full app data backup means. Manufacturers may wish to overlay this resource with their own text  -->
    <string name="fullbackup_data_summary">Automatically back up device data (such as Wi-Fi passwords and call history) and app data (such as settings and files stored by apps) remotely.\n\nWhen you turn on automatic backup, device and app data is periodically saved remotely. App data can be any data that an app has saved (based on developer settings), including potentially sensitive data such as contacts, messages, and photos.</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>
    <!-- Message displayed when the device admin can only be disabled by deleting the work profile [CHAR_LIMIT=120] -->
    <string name="managed_profile_device_admin_info">To stop <xliff:g id="app_name">%1$s</xliff:g> from accessing your work profile, remove the profile under Settings &gt; Accounts</string>
    <!-- Title for personal device admins on the list [CHAR_LIMIT=25] -->
    <string name="personal_device_admin_title">Personal</string>
    <!-- Title for managed device admins on the list [CHAR_LIMIT=25] -->
    <string name="managed_device_admin_title">Work</string>

    <!-- Message when there are no available trust agents to display -->
    <string name="no_trust_agents">No available trust agents</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>

    <!-- Title for screen to set a profile owner [CHAR LIMIT=40] -->
    <string name="profile_owner_add_title">Activate Profile Manager?</string>
    <!-- Warning when trying to add a profile owner admin after setup has completed. [CHAR LIMIT=none] -->
    <string name="adding_profile_owner_warning">By proceeding, your User will be managed by your Administrator which may also be able to store associated data, in addition to your personal data.\n\nYour Administrator has the ability to monitor and manage settings, access, apps, and data associated with this User, including network activity and your device\u2019s location information.</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="notification_log_title">Notification log</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\u2011Fi 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\u2011Fi 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\u2011Fi 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\u2011Fi 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. [CHAR LIMIT=10] -->
    <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. [CHAR LIMIT=10] -->
    <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\u2019t 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\u2019t configure an EAP Wi\u2011Fi 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\u2011Fi 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 in progress sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_in_progress">Syncing now</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>
    <!-- Label for the state of the work profile [CHAR LIMIT=80] -->
    <string name="managed_profile_not_available_label">Work profile isn\u2019t available yet</string>
    <!-- Button label to remove the work profile [CHAR LIMIT=35] -->
    <string name="remove_managed_profile_label">Remove work profile</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. [CHAR LIMIT=NONE] -->
    <string name="remove_account_failed">This change isn\u2019t allowed by your administrator</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\u2019t 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</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">To start Android, enter your password</string>
    <!-- Informational text on the pin entry screen prompting the user for their pin -->
    <string name="enter_pin">To start Android, enter your PIN</string>
    <!-- Informational text on the pattern entry screen prompting the user for their pattern -->
    <string name="enter_pattern">To start Android, draw your pattern</string>

    <!-- Message shown when user enters wrong pattern -->
    <string name="cryptkeeper_wrong_pattern">Wrong Pattern</string>
    <!-- Message shown when user enters wrong password -->
    <string name="cryptkeeper_wrong_password">Wrong Password</string>
    <!-- Message shown when user enters wrong PIN -->
    <string name="cryptkeeper_wrong_pin">Wrong PIN</string>

    <!-- Shown when a password has been entered, and we're checking it -->
    <string name="checking_decryption">Checking\u2026</string>
    <!-- Shown when password is correct, and we're starting Android -->
    <string name="starting_android">Starting Android</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 hardware accelerated drawing debugging development settings. [CHAR LIMIT=50] -->
    <string name="debug_hw_drawing_category">Hardware accelerated rendering</string>

    <!-- Preference category for media development settings. [CHAR LIMIT=50] -->
    <string name="media_category">Media</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: show when hardware layers get updated [CHAR LIMIT=25] -->
    <string name="show_hw_layers_updates">Show hardware layers updates</string>
    <!-- UI debug setting: show hardware layers updates summary [CHAR LIMIT=50] -->
    <string name="show_hw_layers_updates_summary">Flash hardware layers green when they update</string>

    <!-- UI debug setting: show the amount of overdraw in apps using the GPU [CHAR LIMIT=25] -->
    <string name="debug_hw_overdraw">Debug GPU overdraw</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: simulate color space anomalies. [CHAR LIMIT=25] -->
    <string name="simulate_color_space">Simulate color space</string>

    <!-- UI debug setting: enable various types of OpenGL traces [CHAR LIMIT=25] -->
    <string name="enable_opengl_traces_title">Enable OpenGL traces</string>

    <!-- UI debug setting: disable USB audio routing title [CHAR LIMIT=32] -->
    <string name="usb_audio_disable_routing">Disable USB audio routing</string>
    <!-- UI debug setting: disable USB audio routing summary [CHAR LIMIT=50] -->
    <string name="usb_audio_disable_routing_summary">Disable automatic routing to USB audio peripherals</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: force right to left layout [CHAR LIMIT=37] -->
    <string name="force_rtl_layout_all_locales">Force RTL layout direction</string>
    <!-- UI debug setting: force right to left layout summary [CHAR LIMIT=100] -->
    <string name="force_rtl_layout_all_locales_summary">Force screen layout direction to RTL for all locales</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: force anti-aliasing to render apps [CHAR LIMIT=25] -->
    <string name="force_msaa">Force 4x MSAA</string>
    <!-- UI debug setting: force anti-aliasing summary [CHAR LIMIT=50] -->
    <string name="force_msaa_summary">Enable 4x MSAA in OpenGL ES 2.0 apps</string>

    <!-- UI debug setting: show when non-rectangular clip operations are used [CHAR LIMIT=100] -->
    <string name="show_non_rect_clip">Debug non-rectangular clip operations</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: 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>

    <!-- UI debug setting: simulate secondary display devices using overlays [CHAR LIMIT=25] -->
    <string name="overlay_display_devices_title">Simulate secondary displays</string>

    <!-- UI debug setting: enable/disable debug multi-window ui [CHAR LIMIT=25] -->
    <string name="enable_multi_window">Multi-window mode</string>
    <!-- setting Checkbox summary whether to enable debug multi-window ui [CHAR_LIMIT=50] -->
    <string name="enable_multi_window_summary">Multiple activities on screen at the same time.</string>
    <string name="confirm_enable_multi_window_title">Enable multi-window mode?</string>
    <!-- Warning dialog message to confirm user wishes to enable experimental multi-window mode feature -->
    <string name="confirm_enable_multi_window_text">WARNING: This is a highly experimental feature that allows multiple activities on-screen at the same time through the Recent apps UI. Some apps may crash or not function correctly when used with this feature.</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\u2019t 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>
    <!-- Activity title for Appk data usage summary. [CHAR LIMIT=25] -->
    <string name="data_usage_app_summary_title">App data usage</string>
    <!-- Message about carrier data accounting.  [CHAR LIMIT=100] -->
    <string name="data_usage_accounting">Carrier data accounting may differ from your device.</string>
    <!-- Title for app usage. [CHAR LIMIT=40] -->
    <string name="data_usage_app">App usage</string>
    <!-- Title for app usage. [CHAR LIMIT=40] -->
    <string name="data_usage_app_info_label">APP INFO</string>
    <!-- Title for cellular data usage. [CHAR LIMIT=40] -->
    <string name="data_usage_cellular_data">Cellular data</string>
    <!-- Title for setting data limit. [CHAR LIMIT=40] -->
    <string name="data_usage_data_limit">Set data limit</string>
    <!-- Title for option to pick visible time range from a list available usage periods. [CHAR LIMIT=25] -->
    <string name="data_usage_cycle">Data usage cycle</string>
    <!-- Title for application data usage separator in data usage list. [CHAR LIMIT=25] -->
    <string name="data_usage_app_items_header_text">App usage</string>
    <!-- Title for menu option to enable mobile data when roaming. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_roaming">Data roaming</string>
    <!-- Title for menu option to restrict background data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_restrict_background">Restrict background data</string>
    <!-- Title for menu option to allow background data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_allow_background">Allow background data</string>
    <!-- Title for 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 menu option to show Wi-Fi data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_show_wifi">Show Wi\u2011Fi</string>
    <!-- Title for menu option to hide Wi-Fi data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_hide_wifi">Hide Wi\u2011Fi</string>
    <!-- Title for 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 hide Ethernet data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_hide_ethernet">Hide Ethernet usage</string>
    <!-- Title for menu option to configure metered networks. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_metered">Network restrictions</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 menu option to show details for all SIM cards. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_sim_cards">SIM cards</string>
    <!-- Title for menu option to show details for all cellular networks. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_cellular_networks">Cellular networks</string>
    <!-- Summary String for Cellular data enable toggle. [CHAR LIMIT=33] -->
    <string name="data_usage_cellular_data_summary">Paused at limit</string>

    <!--  Title for menu option to enable global auto-sync of personal account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync">Auto-sync data</string>
    <!--  Title for menu option to enable global auto-sync of personal account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync_personal">Auto-sync personal data</string>
    <!--  Title for menu option to enable global auto-sync of work account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync_work">Auto-sync work 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">Turn off cellular data?</string>
    <!-- Checkbox label that will disable mobile network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_mobile_limit">Set cellular data limit</string>
    <!-- Checkbox label that will disable 4G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_4g_limit">Set 4G data limit</string>
    <!-- Checkbox label that will disable 2G-3G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <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\u2011Fi data limit</string>

    <!-- Tab title for showing Wi-Fi data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_wifi">Wi\u2011Fi</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=20] -->
    <string name="data_usage_tab_mobile">Cellular</string>
    <!-- Tab title for showing 4G data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_4g">4G</string>
    <!-- Tab title for showing 2G and 3G data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_3g">2G-3G</string>

    <!-- Title shown when current operation applies to mobile networks. [CHAR LIMIT=20] -->
    <string name="data_usage_list_mobile">Cellular</string>
    <!-- Title shown when current operation applies to no networks. [CHAR LIMIT=20] -->
    <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">Cellular data</string>
    <!-- Toggle switch title for enabling 2G and 3G data network connections. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_3g">2G-3G data</string>
    <!-- Toggle switch title for enabling 4G data network connection. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_4g">4G data</string>

    <!-- Data Usage Foreground label.  [CHAR LIMIT=40] -->
    <string name="data_usage_forground_label">Foreground:</string>
    <!-- Data Usage Background label.  [CHAR LIMIT=40] -->
    <string name="data_usage_background_label">Background:</string>
    <!-- Button title for launching application-specific data usage settings. [CHAR LIMIT=32] -->
    <string name="data_usage_app_settings">App settings</string>
    <!-- Checkbox label that restricts background data usage of a specific application. [CHAR LIMIT=40] -->
    <string name="data_usage_app_restrict_background">Restrict app background data</string>
    <!-- Summary message for checkbox that restricts background data usage of a specific application. [CHAR LIMIT=64] -->
    <string name="data_usage_app_restrict_background_summary">Disable background data on cellular networks.</string>
    <!-- Summary message for checkbox that restricts background data usage of a specific application when no networks have been limited. [CHAR LIMIT=84] -->
    <string name="data_usage_app_restrict_background_summary_disabled">To restrict background data for this app, first set a cellular data limit.</string>
    <!-- Title of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=48] -->
    <string name="data_usage_app_restrict_dialog_title">Restrict background data?</string>
    <!-- Body of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_app_restrict_dialog">This feature may cause an app that depends on background data to stop working when only cellular networks are available.\n\nYou can find more appropriate data usage controls in the settings available within the app.</string>
    <!-- Body of dialog shown when user attempts to restrict background data before a network data limit has been set. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_denied_dialog">Restricting background data is possible only when you\u2019ve set a cellular data limit.</string>
    <!--  Title of dialog shown when user enables global auto sync [CHAR LIMIT=32] -->
    <string name="data_usage_auto_sync_on_dialog_title">Turn auto-sync data on?</string>
    <!--  Body of dialog shown when user enables global auto sync, for tablet [CHAR LIMIT=none] -->
    <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.</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.</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\u2019ll need to sync each account manually to collect recent information. And you won\u2019t 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 tablet will turn off cellular data once it reaches the limit you set.\n\nSince data usage is measured by your tablet, and your carrier may account for usage differently, consider setting a conservative limit.</string>
    <!-- Body of dialog shown before user limits mobile data usage. [CHAR LIMIT=NONE] -->
    <string name="data_usage_limit_dialog_mobile" product="default">Your phone will turn off cellular data once it reaches the limit you set.\n\nSince data usage is measured by your phone, and your carrier may account for usage differently, consider setting a conservative limit.</string>

    <!-- Title of dialog shown before user restricts background data usage. [CHAR LIMIT=48] -->
    <string name="data_usage_restrict_background_title">Restrict background data?</string>
    <!-- Body of dialog shown before user restricts background data usage. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background">If you restrict background cellular data, some apps and services won\u2019t work unless you\u2019re connected to Wi\u2011Fi.</string>
    <!-- Body of dialog shown before user restricts background data usage. This is for multiuser tablets. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background_multiuser" product="tablet">If you restrict background cellular data, some apps and services won\u2019t work unless you\u2019re connected to Wi\u2011Fi.\n\nThis setting affects all users on this tablet.</string>
    <!-- Body of dialog shown before user restricts background data usage. This is for multiuser phones. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background_multiuser" product="default">If you restrict background cellular data, some apps and services won\u2019t work unless you\u2019re connected to Wi\u2011Fi.\n\nThis setting affects all users on this phone.</string>

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

    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title of data usage item that represents all uninstalled applications. [CHAR LIMIT=48] -->
    <string name="data_usage_uninstalled_apps">Removed apps</string>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title of data usage item that represents all uninstalled applications or removed users. [CHAR LIMIT=48] -->
    <string name="data_usage_uninstalled_apps_users">Removed apps and users</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\u2019s 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\u2019s data usage accounting may differ.</string>

    <!-- Dialog title for selecting metered networks. [CHAR LIMIT=25] -->
    <string name="data_usage_metered_title">Network restrictions</string>
    <!-- Dialog body for selecting paid networks. [CHAR LIMIT=NONE] -->
    <string name="data_usage_metered_body">Metered networks are treated like cellular when background data is restricted. Apps may warn before using these networks for large downloads.</string>
    <!-- Header for list of mobile networks. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_mobile">Cellular networks</string>
    <!-- Header for list of Wi-Fi networks. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_wifi">Metered Wi\u2011Fi 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 metered networks, turn Wi\u2011Fi on.</string>

    <!-- Disclaimer string for data usage measured by device. [CHAR LIMIT=80] -->
    <string name="data_usage_disclaimer">Carrier data accounting may differ from your device.</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\u2019t 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 finish editing a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_done">Dismiss</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>
    <!-- Button label to forget a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_forget">Forget</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>
    <!-- Dialog message body to disconnect from a VPN profile. -->
    <string name="vpn_disconnect_confirm">Disconnect this VPN.</string>
    <!-- Button label to disconnect from a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_disconnect">Disconnect</string>
    <!-- Field label to show the version number for a VPN app. [CHAR LIMIT=40] -->
    <string name="vpn_version">Version <xliff:g id="version" example="3.3.0">%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>
    <!-- Menu item to select always-on VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_menu_lockdown">Always-on VPN</string>

    <!-- Summary describing the always-on VPN feature. [CHAR LIMIT=NONE] -->
    <string name="vpn_lockdown_summary">Select a VPN profile to always remain connected to. Network traffic will only be allowed when connected to this VPN.</string>
    <!-- List item indicating that no always-on VPN is selected. [CHAR LIMIT=64] -->
    <string name="vpn_lockdown_none">None</string>
    <!-- Error indicating that the selected VPN doesn't meet requirements. [CHAR LIMIT=NONE] -->
    <string name="vpn_lockdown_config_error">Always-on VPN requires an IP address for both server and DNS.</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>

    <!-- 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>
    <!-- These statuses are displayed when a device was built with SE Android supoprt.
    These are displayed by the settings app in the about section. -->
    <string name="selinux_status_disabled">Disabled</string>
    <string name="selinux_status_permissive">Permissive</string>
    <string name="selinux_status_enforcing">Enforcing</string>

    <!-- Notification of installed CA Certs --> <skip/>

    <!-- Shows up when there is a user SSL CA Cert installed on the
         device.  Indicates to the user that SSL traffic can be intercepted.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_warning">Network may be monitored</string>
    <!-- Button to close the SSL CA cert warning dialog box, meaning the user is done reading.  [CHAR LIMIT=NONE] -->
    <string name="done_button">Done</string>
    <!-- Title of Dialog warning users of SSL monitoring. [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_dialog_title">Network monitoring</string>
    <!-- Text of message to show to users whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_info_message">This device is managed by:\n<xliff:g id="managing_domain">%s</xliff:g>\n\nYour administrator is capable of monitoring your network activity, including emails, apps, and secure websites.\n\nFor more information, contact your administrator.</string>
    <!-- Text of warning to show to users that have a SSL CA Cert installed.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_warning_message">A third party is capable of monitoring your network activity, including emails, apps, and secure websites.\n\nA trusted credential installed on your device is making this possible.</string>
    <!-- Label on button that will take the user to the Trusted Credentials settings page.  [CHAR LIMIT=NONE]-->
    <string name="ssl_ca_cert_settings_button">Check trusted credentials</string>

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

    <!-- User settings screen title [CHAR LIMIT=25] -->
    <string name="user_settings_title">Users</string>
    <!-- User settings header for list of users and profiles [CHAR LIMIT=40] -->
    <string name="user_list_title">Users &amp; profiles</string>
    <!-- User settings add user or restricted profile menu [CHAR LIMIT=35] -->
    <string name="user_add_user_or_profile_menu">Add user or profile</string>
    <!-- User settings add user menu [CHAR LIMIT=35] -->
    <string name="user_add_user_menu">Add user</string>
    <!-- User settings summary for a restricted profile [CHAR LIMIT=50] -->
    <string name="user_summary_restricted_profile">Restricted profile</string>
    <!-- User settings warning that restricted profile needs a screen lock [CHAR LIMIT=NONE] -->
    <string name="user_need_lock_message">Before you can create a restricted profile, you\u2019ll need to set up a screen lock to protect your apps and personal data.</string>
    <!-- User settings dialog button to set screen lock [CHAR LIMIT=25] -->
    <string name="user_set_lock_button">Set lock</string>
    <!-- User summary to indicate that user is currently not set up [CHAR LIMIT=100] -->
    <string name="user_summary_not_set_up">Not set up</string>
    <!-- User summary to indicate that restricted profile is currently not set up [CHAR LIMIT=100] -->
    <string name="user_summary_restricted_not_set_up">Not set up - Restricted profile</string>
    <!-- User summary to indicate that a work profile is currently not set up [CHAR LIMIT=100] -->
    <string name="user_summary_managed_profile_not_set_up">Not set up - Work profile</string>
    <!-- User information string to represent the owner of the device [CHAR LIMIT=25] -->
    <string name="user_owner">Owner</string>
    <!-- User settings title for current user entry "You" user. [CHAR LIMIT=30] -->
    <string name="user_you">You (<xliff:g id="name" example="Name">%s</xliff:g>)</string>
    <!-- Title for the preference to enter the nickname of the userto display in the user switcher [CHAR LIMIT=25]-->
    <string name="user_nickname">Nickname</string>
    <!-- Title for add user type dialog [CHAR LIMIT=45] -->
    <string name="user_add_user_type_title">Add</string>
    <!-- Summary for add user action, when it's disabled [CHAR LIMIT=100] -->
    <string name="user_add_max_count">You can add up to <xliff:g id="user_count">%1$d</xliff:g> users</string>
    <!-- Summary for add user entry in the choice dialog [CHAR LIMIT=none] -->
    <string name="user_add_user_item_summary">Users have their own apps and content</string>
    <!-- Summary for add restricted profile entry in the choice dialog [CHAR LIMIT=none] -->
    <string name="user_add_profile_item_summary">You can restrict access to apps and content from your account</string>
    <!-- Button text for adding a regular user [CHAR LIMIT=25] -->
    <string name="user_add_user_item_title">User</string>
    <!-- Button text for adding a restricted profile [CHAR LIMIT=25] -->
    <string name="user_add_profile_item_title">Restricted profile</string>
    <!-- Title for add user confirmation dialog [CHAR LIMIT=30] -->
    <string name="user_add_user_title">Add new user?</string>
    <!-- Message for add user confirmation dialog - long version. [CHAR LIMIT=none] -->
    <string name="user_add_user_message_long">You can share this device with other people by creating additional users. Each user has their own space, which they can customize with apps, wallpaper, and so on. Users can also adjust device settings like Wi\u2011Fi that affect everyone.\n\nWhen you add a new user, that person needs to set up their space.\n\nAny user can update apps for all other users.</string>
    <!-- Message for add user confirmation dialog - short version. [CHAR LIMIT=none] -->
    <string name="user_add_user_message_short">When you add a new user, that person needs to set up their space.\n\nAny user can update apps for all other users. </string>
    <!-- Title of dialog to setup a new user [CHAR LIMIT=30] -->
    <string name="user_setup_dialog_title">Set up user now?</string>
    <!-- Message in dialog to setup a new user after creation [CHAR LIMIT=none] -->
    <string name="user_setup_dialog_message">Make sure the person is available to take the device and set up their space</string>
    <!-- Message in dialog to setup a new restricted profile after creation [CHAR LIMIT=none] -->
    <string name="user_setup_profile_dialog_message">Set up profile now?</string>
    <!-- Button text to setup the new user now [CHAR LIMIT=25] -->
    <string name="user_setup_button_setup_now">Set up now</string>
    <!-- Button text to setup the new user later [CHAR LIMIT=25] -->
    <string name="user_setup_button_setup_later">Not now</string>
    <!-- Message to secondary users that only owner can manage users [CHAR LIMIT=none] -->
    <string name="user_cannot_manage_message" product="tablet">Only the tablet\u2019s owner can manage users.</string>
    <!-- Message to secondary users that only owner can manage users [CHAR LIMIT=none] -->
    <string name="user_cannot_manage_message" product="default">Only the phone\u2019s owner can manage users.</string>
    <!-- Message to limited users that they cannot add accounts [CHAR LIMIT=100] -->
    <string name="user_cannot_add_accounts_message">Restricted profiles cannot add accounts</string>

    <!-- User details remove user menu [CHAR LIMIT=20] -->
    <string name="user_remove_user_menu">Delete <xliff:g id="user_name">%1$s</xliff:g> from this device</string>
    <!-- User menu to allow creating new users from lockscreen [CHAR LIMIT=30] -->
    <string name="user_add_on_lockscreen_menu">Add users when device is locked</string>
    <!-- User details new user name [CHAR LIMIT=30] -->
    <string name="user_new_user_name">New user</string>
    <!-- User details new restricted profile name [CHAR LIMIT=30] -->
    <string name="user_new_profile_name">New profile</string>
    <!-- User (self) removal confirmation title [CHAR LIMIT=30] -->
    <string name="user_confirm_remove_self_title">Delete yourself?</string>
    <!-- User removal confirmation title [CHAR LIMIT=25] -->
    <string name="user_confirm_remove_title">Remove this user?</string>
    <!-- Profile removal confirmation title [CHAR LIMIT=25] -->
    <string name="user_profile_confirm_remove_title">Remove this profile?</string>
    <!-- Work profile removal confirmation title [CHAR LIMIT=25] -->
    <string name="work_profile_confirm_remove_title">Remove work profile?</string>
    <!-- User (self) removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_self_message" product="tablet">You will lose your space and data on this tablet. You can\u2019t undo this action.</string>
    <!-- User (self) removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_self_message" product="default">You will lose your space and data on this phone. You can\u2019t undo this action.</string>
    <!-- User removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_message">All apps and data will be deleted.</string>
    <!-- Work profile removal confirmation message [CHAR LIMIT=none] -->
    <string name="work_profile_confirm_remove_message">All apps and data in this profile will be deleted if you continue.</string>
    <!-- User profile removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_profile_confirm_remove_message">All apps and data will be deleted.</string>
    <!-- Setting label to show that a new user is being added [CHAR LIMIT=30] -->
    <string name="user_adding_new_user">Adding new user\u2026</string>
    <!-- Spoken content description for delete icon beside a user [CHAR LIMIT=none] -->
    <string name="user_delete_user_description">Delete user</string>
    <!-- Delete button text [CHAR LIMIT=25] -->
    <string name="user_delete_button">Delete</string>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title for Guest user [CHAR LIMIT=35] -->
    <string name="user_guest">Guest</string>
    <!-- Label for item to exit guest mode [CHAR LIMIT=35] -->
    <string name="user_exit_guest_title">Remove guest</string>
    <!-- Title of dialog to user to confirm exiting guest. [CHAR LIMIT=50] -->
    <string name="user_exit_guest_confirm_title">Remove guest?</string>
    <!-- Message to user to confirm exiting guest. [CHAR LIMIT=none] -->
    <string name="user_exit_guest_confirm_message">All apps and data in this session will be deleted.</string>
    <!-- Label for button in confirmation dialog when exiting guest session [CHAR LIMIT=35] -->
    <string name="user_exit_guest_dialog_remove">Remove</string>

    <!-- Title of preference to enable calling[CHAR LIMIT=40] -->
    <string name="user_enable_calling">Turn on phone calls</string>
    <!-- Title of preference to enable calling and SMS [CHAR LIMIT=45] -->
    <string name="user_enable_calling_sms">Turn on phone calls &amp; SMS</string>
    <!-- Title of preference to remove the user [CHAR LIMIT=35] -->
    <string name="user_remove_user">Remove user</string>
    <!-- Title for confirmation of turning on calls [CHAR LIMIT=40] -->
    <string name="user_enable_calling_confirm_title">Turn on phone calls?</string>
    <!-- Message for confirmation of turning on calls [CHAR LIMIT=none] -->
    <string name="user_enable_calling_confirm_message">Call history will be shared with this user.</string>
    <!-- Title for confirmation of turning on calls and SMS [CHAR LIMIT=45] -->
    <string name="user_enable_calling_and_sms_confirm_title">Turn on phone calls &amp; SMS?</string>
    <!-- Message for confirmation of turning on calls and SMS [CHAR LIMIT=none] -->
    <string name="user_enable_calling_and_sms_confirm_message">Call and SMS history will be shared with this user.</string>

    <!-- Application Restrictions screen title [CHAR LIMIT=45] -->
    <string name="application_restrictions">Allow apps and content</string>
    <!-- Applications with restrictions header [CHAR LIMIT=45] -->
    <string name="apps_with_restrictions_header">Applications with restrictions</string>
    <!-- Applicaitons with restrictions - settings button [CHAR LIMIT=30] -->
    <string name="apps_with_restrictions_settings_button">Expand settings for application</string>

    <!-- Home application selection - uninstall button [CHAR LIMIT=80] -->
    <string name="home_app_uninstall_button">Uninstall this application</string>
    <!-- Message to user that Home Settings will be hidden because there is now only one available home application -->
    <string name="only_one_home_message">Home settings will be hidden until you install another home application.</string>

    <!-- Warning message when changing a global setting for a tablet.[CHAR LIMIT=none] -->
    <string name="global_change_warning" product="tablet">This setting affects all users on this tablet.</string>
    <!-- Warning message when changing a global setting for a phone.[CHAR LIMIT=none] -->
    <string name="global_change_warning" product="default">This setting affects all users on this phone.</string>
    <!-- Warning message title for global locale change [CHAR LIMIT=40] -->
    <string name="global_locale_change_title">Change language</string>
    <!-- Warning message title for global font change [CHAR LIMIT=40] -->
    <string name="global_font_change_title">Change font size</string>

    <!-- NFC payment settings --><skip/>
    <string name="nfc_payment_settings_title">Tap &amp; pay</string>
    <!-- Caption for button linking to a page explaining how Tap and Pay works-->
    <string name="nfc_payment_how_it_works">How it works</string>
    <!-- String shown when there are no NFC payment applications installed -->
    <string name="nfc_payment_no_apps">Pay with your phone in stores</string>
    <!-- Header text that can be clicked on to change the default payment app -->
    <string name="nfc_payment_default">Payment default</string>
    <!-- Summary text that is shown when no default app is set -->
    <string name="nfc_payment_default_not_set">Not set</string>
    <!-- String indicating the label of the default payment app and a description of its state; eg Google Wallet - MasterCard 1234 -->
    <string name="nfc_payment_app_and_desc"><xliff:g id="app">%1$s</xliff:g> - <xliff:g id="description">%2$s</xliff:g></string>
    <!-- Header for what to do when the open app supports TapPay: use the default set app, or the open app -->
    <string name="nfc_payment_use_default">Use default</string>
    <!-- Always use the default app (independent of what app is open) -->
    <string name="nfc_payment_favor_default">Always</string>
    <!-- If open app supports TapPay, use that app instead of the default -->
    <string name="nfc_payment_favor_open">Except when another payment app is open</string>
    <!-- Header for a dialog asking the user which payment app to use -->
    <string name="nfc_payment_pay_with">At a Tap &amp; pay terminal, pay with:</string>
    <!-- Header for text explaning how to pay at a payment terminal in a store -->
    <string name="nfc_how_it_works_title">Paying at the terminal</string>
    <!-- Content for text explaning how to pay at a payment terminal in a store -->
    <string name="nfc_how_it_works_content">Set up a payment app. Then just hold the back of your phone up to any terminal with the contactless symbol.</string>
    <!-- Button the user can click to indicate he understood and dismiss the screen -->
    <string name="nfc_how_it_works_got_it">Got it</string>
    <!-- NFC More... title.  [CHAR LIMIT=40] -->
    <string name="nfc_more_title">More...</string>
    <!-- Label for the dialog that is shown when the user is asked to set a
         preferred payment application -->
    <string name="nfc_payment_set_default_label">Set as your preference?</string>
    <string name="nfc_payment_set_default">Always use <xliff:g id="app">%1$s</xliff:g> when you Tap &amp; pay?</string>
    <string name="nfc_payment_set_default_instead_of">Always use <xliff:g id="app">%1$s</xliff:g> instead of <xliff:g id="app">%2$s</xliff:g> when you Tap &amp; pay?</string>
    <!-- Restrictions settings --><skip/>

    <!-- Restriction settings title [CHAR LIMIT=35] -->
    <string name="restriction_settings_title">Restrictions</string>
    <!-- Restrictions screen - reset menu to reset to unrestricted [CHAR LIMIT=25] -->
    <string name="restriction_menu_reset">Remove restrictions</string>
    <!-- Restrictions screen - menu label to change restrictions pin [CHAR LIMIT=25] -->
    <string name="restriction_menu_change_pin">Change PIN</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 &amp; feedback</string>

    <!-- Help URI, Default [DO NOT TRANSLATE] -->
    <string name="help_uri_default" translatable="false"></string>
    <!-- Help URI, Dashboard [DO NOT TRANSLATE] -->
    <string name="help_uri_dashboard" translatable="false"></string>
    <!-- Help URI, Android beam [DO NOT TRANSLATE] -->
    <string name="help_uri_beam" translatable="false"></string>
    <!-- Help URI, Display [DO NOT TRANSLATE] -->
    <string name="help_uri_display" translatable="false"></string>
    <!-- Help URI, Wallpaper [DO NOT TRANSLATE] -->
    <string name="help_uri_wallpaper" translatable="false"></string>
    <!-- Help URI, Interruptions [DO NOT TRANSLATE] -->
    <string name="help_uri_interruptions" translatable="false"></string>
    <!-- Help URI, Other sounds [DO NOT TRANSLATE] -->
    <string name="help_uri_other_sounds" translatable="false"></string>
    <!-- Help URI, Notifications [DO NOT TRANSLATE] -->
    <string name="help_uri_notifications" translatable="false"></string>
    <!-- Help URI, Apps [DO NOT TRANSLATE] -->
    <string name="help_uri_apps" translatable="false"></string>
    <!-- Help URI, Storage [DO NOT TRANSLATE] -->
    <string name="help_uri_storage" translatable="false"></string>
    <!-- Help URI, Accessibility [DO NOT TRANSLATE] -->
    <string name="help_uri_accessibility" translatable="false"></string>
    <!-- Help URI, Printing [DO NOT TRANSLATE] -->
    <string name="help_uri_printing" translatable="false"></string>
    <!-- Help URI, About phone [DO NOT TRANSLATE] -->
    <string name="help_uri_about" translatable="false"></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>
    <!-- Help URL, Dreams [DO NOT TRANSLATE] -->
    <string name="help_url_dreams" translatable="false"></string>
    <!-- Help URL, User settings [DO NOT TRANSLATE] -->
    <string name="help_url_users" translatable="false"></string>
    <!-- Help URL, Location access [DO NOT TRANSLATE] -->
    <string name="help_url_location_access" translatable="false"></string>
    <!-- Help URL, Security settings [DO NOT TRANSLATE] -->
    <string name="help_url_security" translatable="false"></string>
    <!-- Help URL, Tap & pay [DO NOT TRANSLATE] -->
    <string name="help_url_nfc_payment" translatable="false"></string>
    <!-- Help URL, Remote display [DO NOT TRANSLATE] -->
    <string name="help_url_remote_display" translatable="false"></string>
    <!-- Help URL, Fingerprint [DO NOT TRANSLATE] -->
    <string name="help_url_fingerprint" translatable="false"></string>

    <!-- User account title [CHAR LIMIT=30] -->
    <string name="user_account_title">Account for content</string>
    <!-- User picture title [CHAR LIMIT=30] -->
    <string name="user_picture_title">Photo ID</string>

    <!-- Extreme threats title.  [CHAR LIMIT=30] -->
    <string name="extreme_threats_title">Extreme threats</string>
    <!-- Extreme threats summary.  [CHAR LIMIT=62] -->
    <string name="extreme_threats_summary">Receive alerts for extreme threats to life and property</string>
    <!-- Severe threats title.  [CHAR LIMIT=30] -->
    <string name="severe_threats_title">Severe threats</string>
    <!-- Extreme threats summary.  [CHAR LIMIT=60] -->
    <string name="severe_threats_summary">Receive alerts for severe threats to life and property</string>
    <!-- Amber alerts title.  [CHAR LIMIT=30] -->
    <string name="amber_alerts_title">AMBER alerts</string>
    <!-- Amber alerts summary.  [CHAR LIMIT=60] -->
    <string name="amber_alerts_summary">Receive bulletins about child abductions</string>
    <!-- repeat title.  Allows the user to set how oftem to repeat alert reminders.
         For example, they may have alerts just once or every 2 or 15 minutes.  [CHAR LIMIT=30] -->
    <string name="repeat_title">Repeat</string>

    <!-- Call Manager enable settings title.  [CHAR LIMIT=50] -->
    <string name="call_manager_enable_title">Enable Call Manager</string>
    <!-- Call Manager enable settings summary.  [CHAR LIMIT=80] -->
    <string name="call_manager_enable_summary">Allow this service to manage how your calls are made.</string>
    <!-- Call Manager settings title.  [CHAR LIMIT=50] -->
    <string name="call_manager_title">Call Manager</string>
    <!-- Call Manager settings summary.  [CHAR LIMIT=50] -->
    <string name="call_manager_summary"><xliff:g id="app">%1$s</xliff:g></string>
    <!-- Cell Broadcast settings title.  [CHAR LIMIT=50] -->
    <string name="cell_broadcast_settings">Emergency broadcasts</string>
    <!-- Network operators settings title.  [CHAR LIMIT=50] -->
    <string name="network_operators_settings">Network operators</string>
    <!-- Access point names title.  [CHAR LIMIT=50] -->
    <string name="access_point_names">Access point names</string>
    <!-- Enhaced 4G LTE Mode title.  [CHAR LIMIT=50] -->
    <string name="enhanced_4g_lte_mode_title">Enhanced 4G LTE Mode</string>
    <!-- Enhaced 4G LTE Mode summary.  [CHAR LIMIT=100] -->
    <string name="enhanced_4g_lte_mode_summary">Use LTE data to enhance voice and communications (Recommended)</string>
    <!-- Preferred network type title.  [CHAR LIMIT=50] -->
    <string name="preferred_network_type_title">Preferred network type</string>
    <!-- Preferred network type summary.  [CHAR LIMIT=100] -->
    <string name="preferred_network_type_summary">LTE (recommended)</string>
    <!-- Work SIM title.  [CHAR LIMIT=50] -->
    <string name="work_sim_title">Work SIM</string>

    <!-- User app limits screen title [CHAR LIMIT=35] -->
    <string name="user_restrictions_title">App &amp; content access</string>
    <!-- User limits screen, user name rename text [CHAR LIMIT=15] -->
    <string name="user_rename">RENAME</string>
    <!-- Preference label for custom restrictions [CHAR LIMIT=35] -->
    <string name="app_restrictions_custom_label">Set app restrictions</string>
    <!-- Summary for app entries that are controlled by another entry [CHAR LIMIT=none] -->
    <string name="user_restrictions_controlled_by">Controlled by <xliff:g id="app">%1$s</xliff:g></string>
    <!-- Summary text for apps that are allowed to access accounts from the primary user [CHAR LIMIT=none] -->
    <string name="app_sees_restricted_accounts">This app can access your accounts</string>
    <!-- Summary for a case when app entries that are controlled by another entry and app can access user accounts [CHAR LIMIT=none] -->
    <string name="app_sees_restricted_accounts_and_controlled_by">This app can access your accounts. Controlled by <xliff:g id="app">%1$s</xliff:g></string>

    <!-- Restrictions title for configuring wifi and mobile [CHAR LIMIT=35] -->
    <string name="restriction_wifi_config_title">Wi\u2011Fi and Mobile</string>
    <!-- Restrictions summary for configuring wifi and mobile [CHAR LIMIT=100] -->
    <string name="restriction_wifi_config_summary">Allow modification of Wi\u2011Fi and Mobile settings</string>
    <!-- Restrictions title for changing bluetooth configuration [CHAR LIMIT=35] -->
    <string name="restriction_bluetooth_config_title">Bluetooth</string>
    <!-- Restrictions summary for changing bluetooth configuration [CHAR LIMIT=100] -->
    <string name="restriction_bluetooth_config_summary">Allow modification of Bluetooth pairings and settings</string>
    <!-- Restrictions title for allowing NFC transfers [CHAR LIMIT=35] -->
    <string name="restriction_nfc_enable_title">NFC</string>
    <!-- Restrictions summary for allowing NFC transfers (tablet) [CHAR LIMIT=100] -->
    <string name="restriction_nfc_enable_summary_config">Allow data exchange when this <xliff:g id="device_name">%1$s</xliff:g> touches another NFC device</string>
    <!-- Restrictions summary for allowing NFC transfers (tablet) [CHAR LIMIT=100] -->
    <string name="restriction_nfc_enable_summary" product="tablet">Allow data exchange when the tablet touches another device</string>
    <!-- Restrictions summary for allowing NFC transfers (phone) [CHAR LIMIT=100] -->
    <string name="restriction_nfc_enable_summary" product="default">Allow data exchange when the phone touches another device</string>
    <!-- Restrictions title for allowing location sharing [CHAR LIMIT=35] -->
    <string name="restriction_location_enable_title">Location</string>
    <!-- Restrictions summary for allowing location sharing [CHAR LIMIT=100] -->
    <string name="restriction_location_enable_summary" >Let apps use your location information</string>

    <!-- Wizard back button label [CHAR LIMIT=25] -->
    <string name="wizard_back">Back</string>
    <!-- Wizard next button label [CHAR LIMIT=25] -->
    <string name="wizard_next">Next</string>
    <!-- Wizard next button label [CHAR LIMIT=25] -->
    <string name="wizard_finish">Finish</string>

    <!-- An option in a photo selection dialog, if there is no photo yet [CHAR LIMIT=50] -->
    <string name="user_image_take_photo" msgid="7496128293167402354">Take photo</string>
    <!-- An option in a photo selection dialog, if there is no photo yet [CHAR LIMIT=50] -->
    <string name="user_image_choose_photo" msgid="3746334626214970837">Choose photo from Gallery</string>
    <!-- Accessibility message for the photo selector which is a button/popup with the current photo [CHAR LIMIT=50] -->
    <string name="user_image_photo_selector">Select photo</string>

    <!-- Text to display in regulatory info screen (from device overlay). -->
    <string name="regulatory_info_text"></string>

    <!-- Title for SIM card settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_setup_wizard_title">SIM cards</string>
    <!-- Title for SIM settings title settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_settings_title">SIM cards</string>
    <!-- Summary for SIM settings title settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_settings_summary"><xliff:g id="sim_name">%1$s</xliff:g> - <xliff:g id="sim_number">%2$s</xliff:g></string>
    <!-- Message that SIM cards have changed.  [CHAR LIMIT=40] -->
    <string name="sim_cards_changed_message">SIM cards have changed</string>
    <!-- Message smmary that SIM cards have changed.  [CHAR LIMIT=60] -->
    <string name="sim_cards_changed_message_summary">Touch to set activities</string>
    <!-- Message that Cellular data is unavailable.  [CHAR LIMIT=40] -->
    <string name="sim_cellular_data_unavailable">Cellular data is unavailable</string>
    <!-- Message summary that Cellular data is unavailable.  [CHAR LIMIT=60] -->
    <string name="sim_cellular_data_unavailable_summary">Touch to select a data SIM</string>
    <!-- Checkbox to always use for calls.  [CHAR LIMIT=40] -->
    <string name="sim_calls_always_use">Always use this for calls</string>
    <!-- Message for selecting sim for data in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_data">Select a SIM for data</string>
    <!-- Message for switching data SIM; switching takes a while -->
    <string name="data_switch_started">Switching data SIM, this may take up to a minute...</string>
    <!-- Message for selecting sim for call in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_calls">Call with</string>
    <!-- Title for selecting a SIM card.  [CHAR LIMIT=40] -->
    <string name="sim_select_card">Select a SIM card</string>
    <!-- Label for a numbered SIM card.  [CHAR LIMIT=40] -->
    <string name="sim_card_number_title">SIM <xliff:g id="card_number">%1$d</xliff:g></string>
    <!-- Name label of Sim card that is empty.  [CHAR LIMIT=40] -->
    <string name="sim_slot_empty">SIM empty</string>
    <!-- Name label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_name">SIM name</string>
    <!-- Hint for SIM name in sim name editor dialog.  [CHAR LIMIT=40] -->
    <string name="sim_name_hint">Enter SIM name</string>
    <!-- Title label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_title">SIM slot %1$d</string>
    <!-- Carrier label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_carrier">Carrier</string>
    <!-- Number label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_number">Number</string>
    <!-- Color label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_color">SIM color</string>
    <!-- Select label Title of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_card_select_title">Select SIM card</string>
    <!-- Orange label.  [CHAR LIMIT=40] -->
    <string name="color_orange">Orange</string>
    <!-- Purple label.  [CHAR LIMIT=40] -->
    <string name="color_purple">Purple</string>
    <!-- Message informing the user that no SIM card is inserted  [CHAR LIMIT=60] -->
    <string name="sim_no_inserted_msg">No SIM cards inserted</string>
    <!-- SIM status title  [CHAR LIMIT=40] -->
    <string name="sim_status_title">SIM status</string>
    <!-- Title for call back. [CHAR LIMIT=60] -->
    <string name="sim_call_back_title">Call back from default SIM</string>
    <!-- Title for outgoing back. [CHAR LIMIT=60] -->
    <string name="sim_outgoing_call_title">SIM for outgoing calls</string>
    <!-- Title for other call settings. [CHAR LIMIT=60] -->
    <string name="sim_other_call_settings">Other call settings</string>
    <!-- Preferred Network offload title.  [CHAR LIMIT=25] -->
    <string name="preferred_network_offload_title">Preferred network Offload</string>
    <!-- Preferred Network offload Header.  [CHAR LIMIT=25] -->
    <string name="preferred_network_offload_header">Disable Network Name Broadcast</string>
    <!-- Preferred Network offload Footer.  [CHAR LIMIT=100] -->
    <string name="preferred_network_offload_footer">Disable Network Name Broadcast protects from third parties getting access to your network information.</string>
    <!-- Preferred Network offload Popup.  [CHAR LIMIT=100] -->
    <string name="preferred_network_offload_popup">Disabling Network Name Broadcast will prevent automatic connection to hidden networks.</string>
    <!-- Summary text describing signal strength to the user.  [CHAR LIMIT=60] -->
    <string name="sim_signal_strength"><xliff:g id="dbm">%1$d</xliff:g> dBm <xliff:g id="asu">%2$d</xliff:g> asu</string>
    <!-- Title for SIM card notification.  [CHAR LIMIT=40] -->
    <string name="sim_notification_title">SIM cards changed.</string>
    <!-- Message under title informing the user to touch to go to SIM Cards in Settings.  [CHAR LIMIT=40] -->
    <string name="sim_notification_summary">Touch to set up</string>

    <!-- This is a divider in the SIM cards preferences that is the header of various settings where the user chooses which SIM to use for phone calls, data, and SMS messages [CHAR LIMIT=50] -->
    <string name="sim_pref_divider">Preferred SIM for</string>
    <!-- When a user chooses this "Ask first" preference for the SIM to use for phone calls, they'll be prompted to choose a SIM every time they initiate a call [CHAR LIMIT=50] -->
    <string name="sim_calls_ask_first_prefs_title">Ask every time</string>
    <!-- When a SIM preference hasn't been selected yet, this string is displayed as the pref summary until the user chooses a SIM subscription from the preference list [CHAR LIMIT=50] -->
    <string name="sim_selection_required_pref">Selection required</string>

    <!--Dashboard strings-->
    <!-- Text to describe the dashboard fragment title [CHAR LIMIT=16] -->
    <string name="dashboard_title">Settings</string>

    <!-- Search strings -->
    <!-- Text to describe the search results fragment title [CHAR LIMIT=16] -->
    <string name="search_results_title">Settings</string>
    <!-- Text used as a search hint into the search box -->
    <string name="search_menu">Search settings</string>
    <!-- Text used as a search hint into the search box -->
    <string name="query_hint_text">Search settings</string>

    <!-- Text used to identify the search query suggestions / recent searches -->
    <string name="search_recents_queries_label">Recent searches</string>
    <!-- Text used to identify the search results -->
    <string name="search_results_label">Results</string>

    <!--Search Keywords [CHAR LIMIT=NONE]-->
    <string name="keywords_wifi">wifi wi-fi network connection</string>
    <string name="keywords_more_default_sms_app">text message texting messages messaging</string>
    <string name="keywords_more_mobile_networks">cellular cell carrier wireless data 4g 3g 2g lte</string>
    <string name="keywords_wifi_calling">wifi wi-fi call calling</string>
    <string name="keywords_home">launcher</string>
    <string name="keywords_display">screen touchscreen</string>
    <string name="keywords_display_brightness_level">dim screen touchscreen battery</string>
    <string name="keywords_display_auto_brightness">dim screen touchscreen battery</string>
    <!-- Search keywords for display light/dark theme: dark theme, night mode, dim screen, invert brightness [CHAR LIMIT=NONE] -->
    <string name="keywords_display_night_mode">dark theme night mode dim screen invert brightness</string>
    <string name="keywords_display_wallpaper">background personalize customize display</string>
    <string name="keywords_display_font_size">text size</string>
    <string name="keywords_display_cast_screen">project cast</string>
    <string name="keywords_storage">space disk hard drive device usage</string>
    <string name="keywords_battery">power usage charge</string>
    <string name="keywords_spell_checker">spelling dictionary spellcheck auto-correct</string>
    <string name="keywords_voice_input">recognizer input speech speak language hands-free hand free recognition offensive word audio history bluetooth headset</string>
    <string name="keywords_text_to_speech_output">rate language default speak speaking tts accessibility reader blind</string>
    <string name="keywords_date_and_time">clock military</string>
    <string name="keywords_network_reset">reset restore factory</string>
    <string name="keywords_factory_data_reset">wipe delete restore clear remove</string>
    <string name="keywords_printing">printer</string>
    <string name="keywords_sounds_and_notifications">speaker beep</string>
    <string name="keywords_sounds_and_notifications_interruptions">dont don\u2019t disturb interrupt interruption break</string>
    <string name="keywords_app">RAM</string>
    <string name="keywords_location">nearby location history reporting</string>
    <string name="keywords_location_mode">accuracy</string>
    <string name="keywords_accounts">account</string>
    <string name="keywords_users">restriction restrict restricted</string>
    <string name="keywords_keyboard_and_ime">text correction correct sound vibrate auto language gesture suggest suggestion theme offensive word type emoji international</string>
    <string name="keywords_reset_apps">reset preferences default</string>
    <string name="keywords_emergency_app">emergency ice app default</string>
    <string name="keywords_default_phone_app">phone dialer default</string>
    <string name="keywords_all_apps">apps download applications system</string>
    <string name="keywords_app_permissions">apps permissions security</string>
    <string name="keywords_default_apps">apps default</string>
    <string name="keywords_ignore_optimizations">ignore optimizations doze app standby</string>
    <string name="keywords_color_mode">vibrant rgb srgb color natural standard</string>
    <!-- Search keywords for different screen unlock modes : slide to unlock, password, pattern and PIN [CHAR LIMIT=none] -->
    <string name="keywords_lockscreen">slide password pattern pin</string>

    <!-- NFC Wi-Fi pairing/setup strings-->

    <!-- Write NFC tag for Wi-Fi pairing/setup title [CHAR_LIMIT=30]-->
    <string name="setup_wifi_nfc_tag">Set up Wi-Fi NFC Tag</string>
    <!-- Text for button to confirm writing tag -->
    <string name="write_tag">Write</string>
    <!-- Text to inform the user to tap a tag to complete the setup process -->
    <string name="status_awaiting_tap">Tap a tag to write...</string>
    <!-- Text to inform the user that the network key entered was incorrect -->
    <string name="status_invalid_password">Invalid password, try again.</string>
    <!-- Text displayed when tag successfully writen -->
    <string name="status_write_success">Success!</string>
    <!-- Text displayed in error cases (failure to write to tag) -->
    <string name="status_failed_to_write">Unable to write data to NFC tag. If the problem persists, try a different tag</string>
    <!-- Text displayed when tag is not writable -->
    <string name="status_tag_not_writable">NFC tag is not writable. Please use a different tag.</string>

    <!-- Option title for the default sound, context based on screen -->
    <string name="default_sound">Default sound</string>


    <!-- Sounds and Notification -->

    <!-- Sound & notification: Settings header. [CHAR LIMIT=30] -->
    <string name="notification_settings">Sound &amp; notification</string>

    <!-- Sound & notification > Sound section: Title for the option managing media volume. [CHAR LIMIT=30] -->
    <string name="media_volume_option_title">Media volume</string>

    <!-- Sound & notification > Sound section: Title for the option managing alarm volume. [CHAR LIMIT=30] -->
    <string name="alarm_volume_option_title">Alarm volume</string>

    <!-- Sound & notification > Sound section: Title for the option managing ringer volume. [CHAR LIMIT=30] -->
    <string name="ring_volume_option_title">Ring volume</string>

    <!-- Sound & notification > Sound section: Title for the option managing notification volume. [CHAR LIMIT=30] -->
    <string name="notification_volume_option_title">Notification volume</string>

    <!-- Sound & notification > Sound section: Title for the Interruptions option and associated settings page. [CHAR LIMIT=30] -->
    <string name="zen_mode_settings_title" translatable="false">@*android:string/zen_mode_feature_name</string>

    <!-- Sound & notification > Sound section: Title for the Priority interruptions option and associated settings page. [CHAR LIMIT=30] -->
    <string name="zen_mode_priority_settings_title">Priority only allows</string>

    <!-- Sound & notification > Sound section: Title for the zen mode automation option and associated settings page. [CHAR LIMIT=30] -->
    <string name="zen_mode_automation_settings_title">Automatic rules</string>

    <!-- Sound & notification > Sound section: Zen mode option: Important interruptions [CHAR LIMIT=60] -->
    <string name="zen_mode_option_important_interruptions">Priority only</string>

    <!-- Sound & notification > Sound section: Zen mode option: Alarms only [CHAR LIMIT=60] -->
    <string name="zen_mode_option_alarms">Alarms only</string>

    <!-- Sound & notification > Sound section: Zen mode option: No interruptions [CHAR LIMIT=60] -->
    <string name="zen_mode_option_no_interruptions">Total silence</string>

    <!-- Sound & notification > Sound section: Zen mode combined summary + condition line [CHAR LIMIT=60] -->
    <string name="zen_mode_summary_combination"><xliff:g id="mode" example="Priority only">%1$s</xliff:g>: <xliff:g id="exit condition" example="Until you turn this off">%2$s</xliff:g></string>

    <!-- Sound & notification > Sound section: Title for the option defining the phone ringtone. [CHAR LIMIT=30] -->
    <string name="ringtone_title">Phone ringtone</string>

    <!-- Sound & notification > Sound section: Title for the option defining the default notification ringtone. [CHAR LIMIT=30] -->
    <string name="notification_ringtone_title">Default notification ringtone</string>

    <!-- Sound & notification > Sound section: Title for the option managing whether or not to vibrate when ringing. [CHAR LIMIT=30] -->
    <string name="vibrate_when_ringing_title">Also vibrate for calls</string>

    <!-- Sound & notification: Notification section header [CHAR LIMIT=30] -->
    <string name="notification_section_header">Notification</string>

    <!-- Sound & notification: Advanced section header [CHAR LIMIT=30] -->
    <string name="advanced_section_header">Advanced</string>

    <!-- Sound & notification > Notification section: Title for the pulse notification light option. [CHAR LIMIT=30] -->
    <string name="notification_pulse_title">Pulse notification light</string>

    <!-- Sound & notification > Notification section: Title for the option controlling notifications on the lockscreen. [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_title">When device is locked</string>

    <!-- Sound & notification > Notification section: Value for lockscreen notifications:  all information will be
         shown in notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_show">Show all notification content</string>

    <!-- Sound & notification > Notification section: Value for lockscreen notifications: sensitive information will be
         hidden or redacted from notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_hide">Hide sensitive notification content</string>

    <!-- Sound & notification > Notification section: Value for lockscreen notifications: notifications will not appear on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_disable">Don\u2019t show notifications at all</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Message asking the user how they want their notifications to appear when the device is locked [CHAR LIMIT=NONE] -->
    <string name="lock_screen_notifications_interstitial_message">When your device is locked, how do you want notifications to show?</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Title for the screen asking the user how they want their notifications to appear when the device is locked [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_interstitial_title">Notifications</string>

    <!-- Sound & notification > Notification section: Title for the option managing notifications per application. [CHAR LIMIT=30] -->
    <string name="app_notifications_title">App notifications</string>

    <!-- Sound & notification > Sound section: Title for the other sounds option and associated settings page. [CHAR LIMIT=30] -->
    <string name="other_sound_settings">Other sounds</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling touch sounds for dial pad tones. [CHAR LIMIT=30] -->
    <string name="dial_pad_tones_title">Dial pad tones</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling touch sounds for screen locking sounds. [CHAR LIMIT=30] -->
    <string name="screen_locking_sounds_title">Screen locking sounds</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling charging sounds. [CHAR LIMIT=30] -->
    <string name="charging_sounds_title">Charging sounds</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling docking sounds. [CHAR LIMIT=30] -->
    <string name="docking_sounds_title">Docking sounds</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling touch sounds. [CHAR LIMIT=30] -->
    <string name="touch_sounds_title">Touch sounds</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling haptic feedback on touch. [CHAR LIMIT=30] -->
    <string name="vibrate_on_touch_title">Vibrate on touch</string>

    <!-- Sound & notification > Other sounds: Title for the option enabling dock audio media. [CHAR LIMIT=50] -->
    <string name="dock_audio_media_title">Dock speaker plays</string>

    <!-- Sound & notification > Other sounds: Value for the dock audio media with value 0: disabled. [CHAR LIMIT=30] -->
    <string name="dock_audio_media_disabled">All audio</string>

    <!-- Sound & notification > Other sounds: Value for the dock audio media with value 1: enabled. [CHAR LIMIT=30] -->
    <string name="dock_audio_media_enabled">Media audio only</string>

    <!-- Sound & notification > Other sounds: Value for the emergency tone option with value 0: silent. [CHAR LIMIT=30] -->
    <string name="emergency_tone_silent">Silent</string>

    <!-- Sound & notification > Other sounds: Value for the emergency tone option with value 1: alert. [CHAR LIMIT=30] -->
    <string name="emergency_tone_alert">Alert</string>

    <!-- Sound & notification > Other sounds: Value for the emergency tone option with value 2: vibrate. [CHAR LIMIT=30] -->
    <string name="emergency_tone_vibrate">Vibrate</string>

    <!-- Sound & notification > Advanced section: Title for managing notification listeners option. [CHAR LIMIT=30] -->
    <string name="manage_notification_access_title">Notification access</string>

    <!-- Summary of preference to manage notification listeners, when none are enabled -->
    <string name="manage_notification_access_summary_zero">Apps cannot read notifications</string>

    <!-- Summary of preference to manage notification listeners, when one or more are enabled
         and are therefore able to read the user's notifications -->
    <plurals name="manage_notification_access_summary_nonzero">
        <item quantity="one">%d app can read notifications</item>
        <item quantity="other">%d apps can read notifications</item>
    </plurals>

    <!-- String to show in the list of notification listeners, when none is installed -->
    <string name="no_notification_listeners">No installed apps have requested notification access.</string>

    <!-- Title for a warning message about security implications of enabling a notification
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="notification_listener_security_warning_title">Allow notification access for
         <xliff:g id="service" example="NotificationReader">%1$s</xliff:g>?</string>
    <!-- Summary for a warning message about security implications of enabling a notification
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="notification_listener_security_warning_summary">
        <xliff:g id="notification_listener_name">%1$s</xliff:g> will be able to read all notifications,
        including personal information such as contact names and the text of messages you receive.
        It will also be able to dismiss notifications or trigger action buttons they contain.
    </string>

    <!-- Sound & notification > Advanced section: Title for managing Do Not Disturb access option. [CHAR LIMIT=40] -->
    <string name="manage_zen_access_title">Do Not Disturb access</string>

    <!-- Sound & notification > Do Not Disturb access > Text to display when the list is empty. [CHAR LIMIT=NONE] -->
    <string name="zen_access_empty_text">No installed apps have requested Do Not Disturb access</string>

    <!-- [CHAR LIMIT=NONE] Text when loading app list in notification settings -->
    <string name="loading_notification_apps">Loading apps...</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Block option title -->
    <string name="app_notification_block_title">Block all</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Block option description-->
    <string name="app_notification_block_summary">Never show notifications from this app</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Priority option title -->
    <string name="app_notification_priority_title">Treat as priority</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Priority option description-->
    <string name="app_notification_priority_summary">Let this app\u2019s notifications be heard when Do not disturb is set to Priority only</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Peekable option title -->
    <string name="app_notification_peekable_title">Allow peeking</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Peekable option description-->
    <string name="app_notification_peekable_summary">Let this app emphasize certain notifications by sliding them briefly into view on the current screen</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Sensitive option title -->
    <string name="app_notification_sensitive_title">Hide sensitive content</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Sensitive option description-->
    <string name="app_notification_sensitive_summary">When the device is locked, hide content in this app\u2019s notifications that might reveal private information</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications row summary when banned -->
    <string name="app_notification_row_banned">Blocked</string>

    <!-- [CHAR LIMIT=40] Notification settings: App notifications row summary when high priority -->
    <string name="app_notification_row_priority">Priority</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications row summary when sensitive -->
    <string name="app_notification_row_sensitive">Sensitive</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications dialog dismiss button caption -->
    <string name="app_notifications_dialog_done">Done</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule name option and edit dialog title -->
    <string name="zen_mode_rule_name">Rule name</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule name hint text -->
    <string name="zen_mode_rule_name_hint">Enter rule name</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Warning text for invalid zen rule names -->
    <string name="zen_mode_rule_name_warning">Rule name already in use</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Add rule menu option name -->
    <string name="zen_mode_add_rule">Add rule</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Delete rule menu option name -->
    <string name="zen_mode_delete_rule">Delete rule</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Delete rule dialog confirmation message -->
    <string name="zen_mode_delete_rule_confirmation">Delete \u201c<xliff:g id="rule" example="Weekends">%1$s</xliff:g>\u201d rule?</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Delete rule dialog button caption -->
    <string name="zen_mode_delete_rule_button">Delete</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: External rule type -->
    <string name="zen_mode_rule_type">Rule type</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: External rule type name if unknown -->
    <string name="zen_mode_rule_type_unknown">Unknown</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Configure external rule -->
    <string name="zen_mode_configure_rule">Configure rule</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Schedule rule type name -->
    <string name="zen_schedule_rule_type_name">Time rule</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Schedule rule toast hint when enabled -->
    <string name="zen_schedule_rule_enabled_toast">Automatic rule set to turn on Do Not Disturb during specified times</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event rule type name -->
    <string name="zen_event_rule_type_name">Event rule</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Event rule toast hint when enabled -->
    <string name="zen_event_rule_enabled_toast">Automatic rule set to turn on Do Not Disturb during specified events</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule calendar option title -->
    <string name="zen_mode_event_rule_calendar">During events for</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule summary fragment: During events for -->
    <string name="zen_mode_event_rule_summary_calendar_template">During events for <xliff:g id="calendar" example="any calendar">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule summary fragment: any calendar -->
    <string name="zen_mode_event_rule_summary_any_calendar">any calendar</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule summary fragment: Where reply is -->
    <string name="zen_mode_event_rule_summary_reply_template">Where reply is <xliff:g id="reply" example="Yes, Maybe, or Not replied">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule calendar option value for any calendar -->
    <string name="zen_mode_event_rule_calendar_any">Any calendar</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option title -->
    <string name="zen_mode_event_rule_reply">Where reply is</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option value: Yes, Maybe, or Not replied -->
    <string name="zen_mode_event_rule_reply_any_except_no">Yes, Maybe, or Not replied</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option value: Yes or Maybe -->
    <string name="zen_mode_event_rule_reply_yes_or_maybe">Yes or Maybe</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option value: Yes -->
    <string name="zen_mode_event_rule_reply_yes">Yes</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Text to display if rule isn't found -->
    <string name="zen_mode_rule_not_found_text">Rule not found.</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule summary template (when enabled) -->
    <string name="zen_mode_rule_summary_combination"><xliff:g id="description" example="Sun - Thu">%1$s</xliff:g> / <xliff:g id="mode" example="Alarms only">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Time-based rule days option title -->
    <string name="zen_mode_schedule_rule_days">Days</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Downtime days option value, no days set -->
    <string name="zen_mode_schedule_rule_days_none">None</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Downtime days option value, all days set -->
    <string name="zen_mode_schedule_rule_days_all">Every day</string>

    <!-- [CHAR LIMIT=40] General divider text when concatenating multiple items in a text summary -->
    <string name="summary_divider_text">,\u0020</string>

    <!-- [CHAR LIMIT=40] General template for a symbolic start - end range in a text summary -->
    <string name="summary_range_symbol_combination"><xliff:g id="start" example="Sun">%1$s</xliff:g> - <xliff:g id="end" example="Thu">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] General template for a verbal start to end range in a text summary -->
    <string name="summary_range_verbal_combination"><xliff:g id="start" example="Sun">%1$s</xliff:g> to <xliff:g id="end" example="Thu">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=20] Zen mode settings: Calls option -->
    <string name="zen_mode_calls">Calls</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: Messages option -->
    <string name="zen_mode_messages">Messages</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Selected messages summary -->
    <string name="zen_mode_selected_messages">Selected messages</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From anyone -->
    <string name="zen_mode_from_anyone">From anyone</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From contacts only -->
    <string name="zen_mode_from_contacts">From contacts only</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From starred contacts only -->
    <string name="zen_mode_from_starred">From starred contacts only</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: None -->
    <string name="zen_mode_from_none">None</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Alarms option -->
    <string name="zen_mode_alarms">Alarms</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Reminders option -->
    <string name="zen_mode_reminders">Reminders</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Events option -->
    <string name="zen_mode_events">Events</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Selected callers summary -->
    <string name="zen_mode_selected_callers">Selected callers</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Repeat callers option -->
    <string name="zen_mode_repeat_callers">Repeat callers</string>

    <!-- [CHAR LIMIT=200] Zen mode settings: Repeat callers option summary -->
    <string name="zen_mode_repeat_callers_summary">If the same person calls a second time within a <xliff:g id="minutes">%d</xliff:g> minute period, allow it</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option -->
    <string name="zen_mode_when">Automatically turn on</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option value: Never -->
    <string name="zen_mode_when_never">Never</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option value: Every night -->
    <string name="zen_mode_when_every_night">Every night</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option value: Weeknights -->
    <string name="zen_mode_when_weeknights">Weeknights</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: Start time option -->
    <string name="zen_mode_start_time">Start time</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: End time option -->
    <string name="zen_mode_end_time">End time</string>

    <!-- [CHAR LIMIT=60] Zen mode settings: End time option: Summary text value format when end time = next day -->
    <string name="zen_mode_end_time_next_day_summary_format"><xliff:g id="formatted_time" example="7:00 AM">%s</xliff:g> next day</string>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only forever. -->
    <string name="zen_mode_summary_alarms_only_indefinite">Change to alarms only indefinitely</string>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only for < 60 minutes. -->
    <plurals name="zen_mode_summary_alarms_only_by_minute">
        <item quantity="one">Change to alarms only for one minute until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g></item>
        <item quantity="other">Change to alarms only for <xliff:g id="duration" example="2">%1$d</xliff:g> minutes (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only for N hours. -->
    <plurals name="zen_mode_summary_alarms_only_by_hour">
        <item quantity="one">Change to alarms only for one hour until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g></item>
        <item quantity="other">Change to alarms only for <xliff:g id="duration" example="2">%1$d</xliff:g> hours until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g></item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only until a specific time. -->
    <string name="zen_mode_summary_alarms_only_by_time">Change to alarms only until <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: Turn on all notifications. -->
    <string name="zen_mode_summary_always">Change to always interrupt</string>

    <!-- [CHAR LIMIT=20] Notifications settings: Apps section header -->
    <string name="notification_settings_apps_title">App notifications</string>

    <!-- [CHAR LIMIT=NONE] Content description for per-app notification
         settings button -->
    <string name="notification_app_settings_button">Notification settings</string>


   <!-- [CHAR LIMIT=35] Feedback on the device -->
   <string name="device_feedback">Send feedback about this device</string>

    <!-- Full package name of OEM preferred device feedback reporter [DO NOT TRANSLATE] -->
    <string name="oem_preferred_feedback_reporter" translatable="false"></string>

    <!-- PIN entry dialog title for entering the administrator PIN [CHAR LIMIT=none] -->
    <string name="restr_pin_enter_admin_pin">Enter administrator PIN</string>

    <!-- Switch On/Off  -->
    <string name="switch_on_text">On</string>
    <string name="switch_off_text">Off</string>

    <!-- [CHAR LIMIT=28] Screen pinning title -->
    <string name="screen_pinning_title">Screen pinning</string>
    <!-- [CHAR LIMIT=300] Screen pinning description -->
    <string name="screen_pinning_description">When this setting is turned on, you can use screen pinning to keep the current screen in view until you unpin.\n\nTo use screen pinning:\n\n1. Make sure screen pinning is turned on.\n\n2. Open the screen you want to pin.\n\n3. Touch Overview.\n\n4. Swipe up and then touch the pin icon.</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_pattern">Ask for unlock pattern before unpinning</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_pin">Ask for PIN before unpinning</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_password">Ask for password before unpinning</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_none">Lock device when unpinning</string>

    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title for a work profile. [CHAR LIMIT=25] -->
    <string name="managed_user_title">Work profile</string>
    <!-- Opening string on the dialog that prompts the user to confirm that they really want to delete their existing work profile. The administration app icon and name appear after the final colon. [CHAR LIMIT=NONE] -->
    <string name="opening_paragraph_delete_profile_unknown_company">This work profile is managed by:</string>
    <!-- Summary for work profile accounts group. [CHAR LIMIT=25] -->
    <string name="managing_admin">Managed by <xliff:g id="admin_app_label">%s</xliff:g></string>

    <!-- Summary Title for saying that the preference is experimental and will evolve over time due to User feedback. [CHAR LIMIT=NONE] -->
    <string name="experimental_preference">(Experimental)</string>

    <!-- [CHAR LIMIT=45] Auto-rotate setting title -->
    <string name="display_auto_rotate_title">When device is rotated</string>
    <!-- [CHAR LIMIT=70] Rotate when screen is turned option -->
    <string name="display_auto_rotate_rotate">Rotate the contents of the screen</string>
    <!-- [CHAR LIMIT=70] Keep the screen in portrait when rotated -->
    <string name="display_auto_rotate_stay_in_portrait">Stay in portrait view</string>
    <!-- [CHAR LIMIT=70] Keep the screen in landscape when rotated -->
    <string name="display_auto_rotate_stay_in_landscape">Stay in landscape view</string>
    <!-- [CHAR LIMIT=70] Don't rotate when screen is turned option -->
    <string name="display_auto_rotate_stay_in_current">Stay in current orientation</string>

    <!-- Title and summary for SIM Status -->
    <!-- Title for IMEI preference [CHAR LIMIT=30] -->
    <string name="imei_information_title">IMEI information</string>

    <!-- Encryption interstitial title. This screen asks the user whether the device will ask for a PIN / pattern / password before the device starts up. [CHAR LIMIT=30] -->
    <string name="encryption_interstitial_header">Secure start-up</string>

    <!-- Encryption interstitial button to continue with the shown setting.  Appears on screen that asks the user to opt in/out of encrypting device with a pin/pattern/password. [CHAR LIMIT=NONE] -->
    <string name="encryption_continue_button">Continue</string>

    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a PIN to encrypt the device. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pin">
   You can further protect this device by requiring your PIN before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.
   \n\nThis helps protect data on lost or stolen devices.
   </string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a pattern to encrypt the device. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pattern">
   You can further protect this device by requiring your pattern before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.
   \n\nThis helps protect data on lost or stolen devices.
   </string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a password to encrypt the device. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_password">
   You can further protect this device by requiring your password before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.
   \n\nThis helps protect data on lost or stolen devices.
   </string>

    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a PIN to encrypt the device while setting up fingerprint unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pin_for_fingerprint">In addition to using your fingerprint to unlock your device, you can further protect this device by requiring your PIN before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.\n\nThis helps protect data on lost or stolen devices.</string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a pattern to encrypt the device while setting up fingerprint unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pattern_for_fingerprint">In addition to using your fingerprint to unlock your device, you can further protect this device by requiring your pattern before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.\n\nThis helps protect data on lost or stolen devices.</string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a password to encrypt the device while setting up fingerprint unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_password_for_fingerprint">In addition to using your fingerprint to unlock your device, you can further protect this device by requiring your password before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.\n\nThis helps protect data on lost or stolen devices.</string>

    <!-- Radio button text that require a PIN to start device [CHAR LIMIT=NONE] -->
    <string name="encrypt_require_pin">Require PIN to start device</string>
    <!-- Radio button text that require a pattern to start device [CHAR LIMIT=NONE] -->
    <string name="encrypt_require_pattern">Require pattern to start device</string>
    <!-- Radio button text that require a password to start device [CHAR LIMIT=NONE] -->
    <string name="encrypt_require_password">Require password to start device</string>

    <!-- Radio button text that doesn't require a PIN to decrypt [CHAR LIMIT=NONE] -->
    <string name="encrypt_dont_require_pin">No thanks</string>
    <!-- Radio button text that doesn't require a pattern to decrypt [CHAR LIMIT=NONE] -->
    <string name="encrypt_dont_require_pattern">No thanks</string>
    <!-- Radio button text that doesn't require a password to decrypt [CHAR LIMIT=NONE] -->
    <string name="encrypt_dont_require_password">No thanks</string>

   <!-- Title for encryption dialog that disables TalkBack. [CHAR_LIMIT=25] -->
   <string name="encrypt_talkback_dialog_require_pin">Require PIN?</string>

   <!-- Title for encryption dialog that disables TalkBack. [CHAR_LIMIT=25] -->
   <string name="encrypt_talkback_dialog_require_pattern">Require pattern?</string>

   <!-- Title for encryption dialog that disables TalkBack. [CHAR_LIMIT=25] -->
   <string name="encrypt_talkback_dialog_require_password">Require password?</string>

   <!-- Message for encryption dialog telling the user that Talkback and other accessibility services will be disabled. -->
   <string name="encrypt_talkback_dialog_message_pin">When you enter your PIN to start this device, accessibility services like <xliff:g id="service" example="TalkBack">%1$s</xliff:g> won\u2019t yet be available.</string>

   <!-- Message for encryption dialog telling the user that Talkback and other accessibility services will be disabled. -->
   <string name="encrypt_talkback_dialog_message_pattern">When you enter your pattern to start this device, accessibility services like <xliff:g id="service" example="TalkBack">%1$s</xliff:g> won\u2019t yet be available.</string>

   <!-- Message for encryption dialog telling the user that Talkback and other accessibility services will be disabled. -->
   <string name="encrypt_talkback_dialog_message_password">When you enter your password to start this device, accessibility services like <xliff:g id="service" example="TalkBack">%1$s</xliff:g> won\u2019t yet be available.</string>

   <!-- Title and summary for SIM Status -->
   <string name="imei_information_title">IMEI information</string>
   <string name="imei_information_summary">IMEI relative information</string>
   <string name="slot_number">(Slot<xliff:g id="slot_num">%1$d</xliff:g>)</string>

   <!-- New strings needed for App Info 2 -->
   <!-- Preference label for app default launch settings [CHAR LIMIT=35]-->
   <string name="launch_by_default">Open by default</string>

   <!-- Summary for app storage preference [CHAR LIMIT=15] -->
   <string name="storage_summary_format"><xliff:g id="size" example="30.00MB">%1$s</xliff:g> used in <xliff:g id="storage_type" example="internal storage">%2$s</xliff:g></string>

   <!-- Category name for App Launch -->
   <string name="app_launch_domain_links_title">App links</string>
   <string name="app_launch_open_domain_urls_title">Open supported links</string>
   <string name="app_launch_open_domain_urls_summary">Open without asking</string>
   <string name="app_launch_supported_domain_urls_title">Supported links</string>
   <string name="app_launch_other_defaults_title">Other defaults</string>

   <!-- Summary for app storage preference -->
   <string name="storage_summary_format"><xliff:g id="size" example="30.00MB">%1$s</xliff:g> used in <xliff:g id="storage_type" example="internal memory">%2$s</xliff:g></string>
   <!-- Internal storage label -->
   <string name="storage_type_internal">internal memory</string>
   <!-- External storage label -->
   <string name="storage_type_external">external memory</string>

   <!-- Summary describing internal storage for applications [CHAR LIMIT=25] -->
   <string name="storage_type_internal">Internal storage</string>
   <!-- Summary describing external storage for applications [CHAR LIMIT=25] -->
   <string name="storage_type_external">External storage</string>

   <!-- Title for data usage screen when entered from app info [CHAR LIMIT=30] -->
   <string name="app_data_usage">App data usage</string>
   <!-- Summary for data usage preference [CHAR LIMIT=15] -->
   <string name="data_summary_format"><xliff:g id="size" example="30.00MB">%1$s</xliff:g> used since <xliff:g id="date" example="Jan 12">%2$s</xliff:g></string>

   <!-- Title of storage preference to control where app is stored -->
   <string name="storage_used">Storage used</string>

   <!-- Title of button to change storage [CHAR LIMIT=25] -->
   <string name="change">Change</string>

   <!-- Title of dialog to change storage [CHAR LIMIT=25] -->
   <string name="change_storage">Change storage</string>

   <!-- Label for notification settings for an specific app [CHAR LIMIT=40] -->
   <string name="notifications_label">Notifications</string>
   <!-- App notification summary with notifications enabled [CHAR LIMIT=40] -->
   <string name="notifications_enabled">Normal</string>
   <!-- App notification summary with notifications disabled [CHAR LIMIT=40] -->
   <string name="notifications_disabled">Block</string>
   <!-- App notification summary with notifications sensitive [CHAR LIMIT=40] -->
   <string name="notifications_sensitive">Sensitive content hidden</string>
   <!-- App notification summary with notifications priority [CHAR LIMIT=40] -->
   <string name="notifications_priority">Priority</string>
   <!-- App notification summary with notification peeking disabled [CHAR LIMIT=40] -->
   <string name="notifications_no_peeking">No peeking</string>
   <!-- App notification summary with 2 items [CHAR LIMIT=15] -->
   <string name="notifications_two_items"><xliff:g id="notif_state" example="Priority">%1$s</xliff:g> / <xliff:g id="notif_state" example="Priority">%2$s</xliff:g></string>
   <!-- App notification summary with 3 items [CHAR LIMIT=15] -->
   <string name="notifications_three_items"><xliff:g id="notif_state" example="Priority">%1$s</xliff:g> / <xliff:g id="notif_state" example="Priority">%2$s</xliff:g> / <xliff:g id="notif_state" example="Priority">%3$s</xliff:g></string>


   <!-- Permissions preference summary [CHAR LIMIT=40] -->
   <plurals name="permissions_summary">
       <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> permission granted</item>
       <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> permissions granted</item>
   </plurals>

   <!-- Runtime permissions preference summary [CHAR LIMIT=40] -->
   <plurals name="runtime_permissions_summary">
       <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> of <xliff:g id="count" example="1">%d</xliff:g> permission granted</item>
       <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> permissions granted</item>
   </plurals>

    <!-- Runtime permissions preference summary.  Number of additional permissions granted. [CHAR LIMIT=40] -->
    <plurals name="runtime_permissions_additional_count">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> additional permission</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> additional permissions</item>
    </plurals>

    <!-- Runtime permissions preference summary, shown when the app has no permissions granted. [CHAR LIMIT=40] -->
    <string name="runtime_permissions_summary_no_permissions_granted">No permissions granted</string>

    <!-- Runtime permissions preference summary, shown when the app requests no permissions. [CHAR LIMIT=40] -->
    <string name="runtime_permissions_summary_no_permissions_requested">No permissions requested</string>

    <!-- Launch defaults preference summary with some set [CHAR LIMIT=40] -->
    <string name="launch_defaults_some">Some defaults set</string>
    <!-- Launch defaults preference summary with none set [CHAR LIMIT=40] -->
    <string name="launch_defaults_none">No defaults set</string>

    <!-- Label for showing all apps in list [CHAR LIMIT=30] -->
    <string name="filter_all_apps">All apps</string>
    <!-- Label for showing enabled apps in list [CHAR LIMIT=30] -->
    <string name="filter_enabled_apps">Enabled</string>
    <!-- Label for showing personal apps in list [CHAR LIMIT=30] -->
    <string name="filter_personal_apps">Personal</string>
    <!-- Label for showing work apps in list [CHAR LIMIT=30] -->
    <string name="filter_work_apps">Work</string>
    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_blocked_apps">Blocked</string>
    <!-- Label for showing apps with priority notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_priority_apps">Priority</string>
    <!-- Label for showing apps with sensitive notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_sensitive_apps">Sensitive content hidden</string>
    <!-- Label for showing apps with peeking disabled in list [CHAR LIMIT=30] -->
    <string name="filter_notif_no_peeking">No peeking</string>
    <!-- Label for showing apps with domain URLs (data URI with http or https) in list [CHAR LIMIT=30] -->
    <string name="filter_with_domain_urls_apps">With domain URLs</string>

    <!-- Summary for a trust agent that was disabled by the device policy [LIMIT=NONE] -->
    <string name="trust_agent_disabled_device_admin">Disabled by administrator</string>

    <!-- Title for advanced application management settings [CHAR LIMIT=30] -->
    <string name="advanced_apps">Advanced</string>

    <!-- Title for application configuration settings [CHAR LIMIT=30] -->
    <string name="configure_apps">Configure apps</string>

   <!-- Warning toast shown when data usage screen can't find specified app -->
   <string name="unknown_app">Unknown app</string>

   <!-- Title for profile selection dialog [CHAR LIMIT=30] -->
   <string name="choose_profile">Choose Profile</string>

   <!-- Label for list that shows all permissions -->
   <string name="app_permissions">App permissions</string>
   <!-- Summary of permissions currently granted to apps [CHAR LIMIT=45] -->
   <string name="app_permissions_summary"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> apps allowed additional access</string>
   <!-- Summary of number of apps currently granted a single permission [CHAR
        LIMIT=45] -->
   <string name="app_permissions_group_summary"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> apps allowed</string>

   <!-- Label for tap to wake setting [CHAR LIMIT=30] -->
   <string name="tap_to_wake">Tap to wake</string>

   <!-- Summary for take to wake setting [CHAR LIMIT=90] -->
   <string name="tap_to_wake_summary">Double-tap anywhere on the screen to wake device</string>

    <!-- Label for the Domain URLs list that shows domain urls per App [CHAR LIMIT=30] -->
    <string name="domain_urls_title">App links</string>

    <!-- Summary for an App that dont open any domain URLs [CHAR LIMIT=45] -->
    <string name="domain_urls_summary_none">Don\u2019t open supported links</string>

    <!-- Summary of number of App that can open one and only one domain URLs [CHAR LIMIT=45] -->
    <string name="domain_urls_summary_one">Open <xliff:g id="domain" example="mail.google.com">%s</xliff:g></string>

    <!-- Summary of number of App that can open several domain URLs [CHAR LIMIT=45] -->
    <string name="domain_urls_summary_some">Open <xliff:g id="domain" example="mail.google.com">%s</xliff:g> and related URLs</string>

    <!-- Description of settings item that leads to list of all apps with Domain URLs [CHAR LIMIT=NONE] -->
    <plurals name="domain_urls_apps_summary">
        <item quantity="zero">No app can open any supported link</item>
        <item quantity="one">One app can open its supported links</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> apps can open their supported links</item>
    </plurals>

    <!-- Explanation that the app that will ALWAYS be launched to open web links to domains that it understands -->
    <string name="app_link_open_always">Open in this app</string>

    <!-- Explanation that the user will be asked whether to launch the app to open web links to domains that it understands -->
    <string name="app_link_open_ask">Ask every time</string>

    <!-- Explanation that the app that will NEVER be launched to open web links to domains that it understands -->
    <string name="app_link_open_never">Don&#8217;t open in this app</string>

    <!-- Fingerprint hint message when finger was not recognized.-->
    <string name="fingerprint_not_recognized">Not recognized</string>

    <!-- Title for Default Apps settings [CHAR LIMIT=30] -->
    <string name="default_apps_title">Default Apps</string>

    <!-- Title for Assist and voice input settings [CHAR LIMIT=30] -->
    <string name="assist_and_voice_input_title">Assist &amp; voice input</string>

    <!-- Title for Default Assist settings [CHAR LIMIT=30] -->
    <string name="default_assist_title">Assist app</string>

    <!-- Summary for No Default Assist settings [CHAR LIMIT=45] -->
    <string name="default_assist_none">None</string>

    <!-- Title for Choose Assist dialog [CHAR LIMIT=35] -->
    <string name="choose_assist_title">Choose Assist app</string>

    <!-- [CHAR_LIMIT=45] Title of the security warning dialog for setting an assitant -->
    <string name="assistant_security_warning_title">
        Make <xliff:g id="assistant_app_name">%s</xliff:g> your assistant?
    </string>

    <!-- [CHAR_LIMIT=NONE] Warning message about security implications of setting an assistant,
         displayed as a dialog message when the user selects an assistant. -->
    <string name="assistant_security_warning">The assistant will be able to read information about
        apps in use on your system, including information visible on your screen or accessible
        within the apps.</string>

    <!-- Label for the button to acknowledge assistant security implications. [CHAR LIMIT=30] -->
    <string name="assistant_security_warning_agree">Agree</string>

    <!-- Label for the button to bail out assistant security implications. [CHAR LIMIT=30] -->
    <string name="assistant_security_warning_disagree">Disagree</string>

    <!-- Title for Choose voice input dialog [CHAR LIMIT=30] -->
    <string name="choose_voice_input_title">Choose voice input</string>

    <!-- Title for Default Browser settings [CHAR LIMIT=30] -->
    <string name="default_browser_title">Browser app</string>

    <!-- Summary for No Default Browser settings [CHAR LIMIT=45] -->
    <string name="default_browser_title_none">No default Browser</string>

    <!--  Title for Default Phone app settings [CHAR LIMIT=30] -->
    <string name="default_phone_title">Phone app</string>

    <!-- Label of default app for current setting [CHAR LIMIT=40] -->
    <string name="default_app">(Default)</string>

    <!-- Title of app storage screen [CHAR LIMIT=30] -->
    <string name="apps_storage">Apps storage</string>

    <!-- Title of usage access screen [CHAR LIMIT=30] -->
    <string name="usage_access">Usage access</string>

    <!-- Label for setting which controls whether app has usage access [CHAR LIMIT=45] -->
    <string name="permit_usage_access">Permit usage access</string>

    <!-- Link to the apps page for app usage settings [CHAR LIMIT=45] -->
    <string name="app_usage_preference">App usage preferences</string>

    <!-- Description of the usage access setting [CHAR LIMIT=NONE] -->
    <string name="usage_access_description">Usage access allows an app to track what other apps you\u2019re using and how often, as well as your carrier, language settings, and other details.</string>

    <!-- Title for screen showing recent memory usage of device [CHAR LIMIT=30]-->
    <string name="memory_settings_title">Memory</string>

    <!-- Title for screen showing recent memory usage of specific app [CHAR LIMIT=30]-->
    <string name="memory_details_title">Memory details</string>

    <!-- Description of app always running [CHAR LIMIT=45] -->
    <string name="always_running">Always running (<xliff:g id="percentage" example="5%">%s</xliff:g>)</string>

    <!-- Description of app sometimes running [CHAR LIMIT=45] -->
    <string name="sometimes_running">Sometimes running (<xliff:g id="percentage" example="5%">%s</xliff:g>)</string>

    <!-- Description of app rarely running [CHAR LIMIT=45] -->
    <string name="rarely_running">Rarely running (<xliff:g id="percentage" example="5%">%s</xliff:g>)</string>

    <!-- Maximum memory usage key [CHAR LIMIT=25] -->
    <string name="memory_max_use">Maximum</string>

    <!-- Average memory usage key [CHAR LIMIT=25] -->
    <string name="memory_avg_use">Average</string>

    <!-- Maximum memory used by an app [CHAR LIMIT=25] -->
    <string name="memory_max_desc">Maximum <xliff:g id="memory" example="30MB">%1$s</xliff:g></string>

    <!-- Average memory used by an app [CHAR LIMIT=25] -->
    <string name="memory_avg_desc">Average <xliff:g id="memory" example="30MB">%1$s</xliff:g></string>

    <!-- Formatting for memory description [CHAR LIMIT=25] -->
    <string name="memory_use_running_format"><xliff:g id="memory" example="30MB">%1$s</xliff:g> / <xliff:g id="running" example="Always running">%2$s</xliff:g></string>

    <!-- Label for process [CHAR LIMIT=25] -->
    <string name="process_format"><xliff:g id="app_name" example="Settings">%1$s</xliff:g> (<xliff:g id="count" example="3">%2$d</xliff:g>)</string>

    <!-- Label for list to control apps that ignore battery saving restrictions [CHAR LIMIT=27]-->
    <string name="high_power_apps">Battery optimization</string>

    <!-- Filter for apps allowed to use a lot of power [CHAR LIMIT=25] -->
    <string name="high_power_filter_on">Not optimized</string>

    <!-- Summary of app allowed to use a lot of power [CHAR LIMIT=60] -->
    <string name="high_power_on">Ignoring battery optimization</string>

    <!-- Summary of app not allowed to use a lot of power [CHAR LIMIT=60] -->
    <string name="high_power_off">Optimizing battery use</string>

    <!-- Summary of app which doesn't have a battery optimization setting [CHAR LIMIT=60] -->
    <string name="high_power_system">Battery optimization not available</string>

    <!-- Description of high power switch [CHAR LIMIT=NONE] -->
    <string name="high_power_desc">Don\u2019t apply battery optimization. May drain your battery more quickly.</string>

    <!-- Description of number of apps with high power turned on [CHAR LIMIT=NONE] -->
    <plurals name="high_power_count">
        <item quantity="one">1 app allowed to ignore battery optimization</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> apps allowed to ignore battery optimization</item>
    </plurals>

    <!-- Title of prompt dialog app can invoke to turn off optimization [CHAR LIMIT=NONE] -->
    <string name="high_power_prompt_title">Ignore battery optimizations?</string>

    <!-- Body text of prompt dialog app can invoke to turn off optimization [CHAR LIMIT=NONE] -->
    <string name="high_power_prompt_body">Let app
        <xliff:g id="app_name" example="Settings">%1$s</xliff:g> stay connected in the
        background?  This may use more battery.</string>

    <!-- Summary of power usage for an app [CHAR LIMIT=NONE] -->
    <string name="battery_summary"><xliff:g id="percentage" example="2">%1$d</xliff:g>%% use since last full charge</string>

    <!-- Summary for app with no battery usage [CHAR LIMIT=NONE] -->
    <string name="no_battery_summary">No battery use since last full charge</string>

    <!-- Link to an apps notification settings [CHAR LIMIT=50] -->
    <string name="app_notification_preferences">App settings</string>

    <!-- Turn on settings for system ui tuner [CHAR LIMIT=40] -->
    <string name="system_ui_settings">Show SystemUI Tuner</string>

    <!-- Label for button that leads to more permissions [CHAR LIMIT=40] -->
    <string name="additional_permissions">Additional permissions</string>

    <!-- Description of how many more permissions to view on next page [CHAR LIMIT=30] -->
    <string name="additional_permissions_more"><xliff:g id="count" example="2">%1$d</xliff:g> more</string>

    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for charging only. -->
    <string name="usb_use_charging_only">Charging</string>
    <!-- Decription of one of the choices in a dialog (with title defined in usb_use) that lets the
         user select what the USB connection for this device should be used for. This choice
         is for charging only. -->
    <string name="usb_use_charging_only_desc">Just charge this device</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for powering the other device only. -->
    <string name="usb_use_power_only">Power supply</string>
    <!-- Decription of one of the choices in a dialog (with title defined in usb_use) that lets the
         user select what the USB connection for this device should be used for. This choice
         is for powering the other device only. -->
    <string name="usb_use_power_only_desc">Charge the other connected device</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring files via MTP. -->
    <string name="usb_use_file_transfers">File transfers</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring files via MTP. -->
    <string name="usb_use_file_transfers_desc">Transfer files to Windows or Mac (MTP)</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring photos via PTP. -->
    <string name="usb_use_photo_transfers">Photo transfer (PTP)</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring photos via PTP. -->
    <string name="usb_use_photo_transfers_desc">Transfer photos or files if MTP is not supported (PTP)</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for entering MIDI mode. -->
    <string name="usb_use_MIDI">MIDI</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for entering MIDI mode. -->
    <string name="usb_use_MIDI_desc">Use device for MIDI input</string>
    <!-- The title used in a dialog which lets the user select what the USB connection
         for this device should be used for. Choices are usb_use_charging_only,
         usb_use_file_transfer, use_use_photo_transfer, and usb_use_MIDI -->
    <string name="usb_use">Use USB for</string>

    <!-- Settings item title for inactive apps [CHAR LIMIT=35] -->
    <string name="inactive_apps_title">Inactive apps</string>
    <!-- Settings item summary for inactive app [CHAR LIMIT=100] -->
    <string name="inactive_app_inactive_summary">Inactive. Touch to toggle.</string>
    <!-- Settings item summary for active app [CHAR LIMIT=100] -->
    <string name="inactive_app_active_summary">Active. Touch to toggle.</string>

    <!-- Title for the "context" preference to determine whether assist can access the data currently displayed on-screen [CHAR LIMIT=40] -->
    <string name="assist_access_context_title">Use text from screen</string>

    <!-- Summary for the "context" preference to determine whether assist can access the data currently displayed on-screen [CHAR LIMIT=NONE] -->
    <string name="assist_access_context_summary">Allow the assist app to access the screen contents as text</string>

    <!-- Title for the "screenshot" preference to determine whether assist can access the screenshot of your screen [CHAR LIMIT=40] -->
    <string name="assist_access_screenshot_title">Use screenshot</string>

    <!-- Summary for the "screenshot" preference to determine whether assist can access the screenshot of your screen [CHAR LIMIT=NONE] -->
    <string name="assist_access_screenshot_summary">Allow the assist app to access an image of the screen</string>


    <!-- Footer text in the manage assist screen. [CHAR LIMIT=NONE] -->
    <string name="assist_footer">Assist apps can help you based on information from the screen you\u2019re viewing. Some apps support both launcher and voice input services to give you integrated assistance.</string>

    <!-- Label for average memory use section [CHAR LIMIT=30] -->
    <string name="average_memory_use">Average memory use</string>

    <!-- Label for maximum memory use section [CHAR LIMIT=30] -->
    <string name="maximum_memory_use">Maximum memory use</string>

    <!-- Label for app list of memory use [CHAR LIMIT=30] -->
    <string name="memory_usage">Memory usage</string>

    <!-- Label for app list of memory use [CHAR LIMIT=30] -->
    <string name="app_list_memory_use">App usage</string>

    <!-- Label for details about an app's memory use [CHAR LIMIT=30] -->
    <string name="memory_details">Details</string>

    <!-- Summary for how much memory an app has used [CHAR LIMIT=NONE] -->
    <string name="memory_use_summary"><xliff:g id="size" example="30MB">%1$s</xliff:g> avg memory used in last 3 hours</string>

    <!-- Summary for no memory use for an app [CHAR LIMIT=NONE] -->
    <string name="no_memory_use_summary">No memory used in last 3 hours</string>

    <!-- Menu item for Sorting list by average memory use [CHAR LIMIT=NONE]-->
    <string name="sort_avg_use">Sort by avg use</string>

    <!-- Menu item for Sorting list by maximum memory use [CHAR LIMIT=NONE] -->
    <string name="sort_max_use">Sort by max use</string>

    <!-- Label for the current performance of the device [CHAR LIMIT=25] -->
    <string name="memory_performance">Performance</string>

    <!-- Label for total memory of device [CHAR LIMIT=25] -->
    <string name="total_memory">Total memory</string>

    <!-- Label for average memory usage of device [CHAR LIMIT=25] -->
    <string name="average_used">Average used (&#x0025;)</string>

    <!-- Label for free memory of device [CHAR LIMIT=25] -->
    <string name="free_memory">Free</string>

    <!-- Label for button that leads to list of apps and their memory usage [CHAR LIMIT=40]-->
    <string name="memory_usage_apps">Memory used by apps</string>

    <!-- Description of number of apps using memory [CHAR LIMIT=NONE] -->
    <plurals name="memory_usage_apps_summary">
        <item quantity="one">1 app used memory in the last <xliff:g id="duration" example="3 hours">%2$s</xliff:g></item>
        <item quantity="other"><xliff:g id="count" example="10">%1$d</xliff:g> apps used memory in the last <xliff:g id="duration" example="3 hours">%2$s</xliff:g></item>
    </plurals>

    <!-- Label for frequency that the app is runnig (e.g. always, sometimes, etc.) [CHAR LIMIT=25] -->
    <string name="running_frequency">Frequency</string>

    <!-- Label for maximum amount of memory app has used [CHAR LIMIT=25] -->
    <string name="memory_maximum_usage">Maximum usage</string>

    <!-- Summary of data item when no data usage [CHAR LIMIT=40] -->
    <string name="no_data_usage">No data used</string>

    <!-- Zen mode access settings - title for warning dialog when enabling access [CHAR LIMIT=NONE] -->
    <string name="zen_access_warning_dialog_title">Allow access to Do Not Disturb for <xliff:g id="app" example="Tasker">%1$s</xliff:g>?</string>

    <!-- Zen mode access settings - summary for warning dialog when enabling access [CHAR LIMIT=NONE] -->
    <string name="zen_access_warning_dialog_summary">The app will be able to turn on/off Do Not Disturb and make changes to related settings.</string>

    <!-- Ignore battery optimizations on label [CHAR LIMIT=30] -->
    <string name="ignore_optimizations_on">Don\u2019t optimize</string>

    <!-- Ignore battery optimizations off label [CHAR LIMIT=30] -->
    <string name="ignore_optimizations_off">Optimize</string>

    <!-- Ignore battery optimizations on description [CHAR LIMIT=NONE] -->
    <string name="ignore_optimizations_on_desc">May drain your battery more quickly</string>

    <!-- Ignore battery optimizations off description [CHAR LIMIT=NONE] -->
    <string name="ignore_optimizations_off_desc">Recommended for better battery life</string>

    <!-- Ignore battery optimizations dialog title [CHAR LIMIT=NONE] -->
    <string name="ignore_optimizations_title">Allow <xliff:g id="app" example="Tasker">%s</xliff:g> to ignore battery optimizations?</string>

    <!-- Label for None item in AppListPreference [CHAR LIMIT=40] -->
    <string name="app_list_preference_none">None</string>

    <!-- Warning message about disabling usage access on profile owner [CHAR LIMIT=NONE] -->
    <string name="work_profile_usage_access_warning">Turning off usage access for this app doesn\u2019t prevent your administrator tracking data usage for apps in your work profile.</string>

    <!-- Number of characters used for lock screen text [CHAR LIMIT=NONE] -->
    <string name="accessibility_lock_screen_progress"><xliff:g id="count" example="1">%1$d</xliff:g> of <xliff:g id="count" example="1">%2$d</xliff:g> characters used</string>

    <!-- System Alert Window settings -->
    <!-- Title of Draw Overlay preference item [CHAR LIMIT=55] -->
    <string name="draw_overlay_title">Apps that can draw over other apps</string>
    <!-- Title of draw overlay screen [CHAR LIMIT=30] -->
    <string name="draw_overlay">Draw over other apps</string>
    <!-- Settings title in main settings screen for SYSTEM_ALERT_WINDOW [CHAR LIMIT=45] -->
    <string name="system_alert_window_settings">Draw over other apps</string>
    <!-- Title for the apps with SYSTEM_ALERT_WINDOW permission/privilege [CHAR LIMIT=20] -->
    <string name="system_alert_window_apps_title">Apps</string>
    <!-- Title for the apps that are allowed to draw on top of other apps [CHAR LIMIT=60] -->
    <string name="system_alert_window_access_title">Draw over other apps</string>
    <!-- Label for setting which controls whether app can draw overlays [CHAR LIMIT=45] -->
    <string name="permit_draw_overlay">Permit drawing over other apps</string>
    <!-- Link to the apps page for SYSTEM_ALERT_WINDOW settings [CHAR LIMIT=45] -->
    <string name="app_overlay_permission_preference">App draw on top permission</string>
    <!-- Description of allowing overlay setting [CHAR LIMIT=NONE] -->
    <string name="allow_overlay_description">This permission allows an app to display on top of other apps you\u2019re using and may interfere with your use of the interface in other applications, or change what you think you are seeing in other applications.</string>

    <!-- Keyword for SYSTEM_ALERT_WINDOW -->
    <string name="keywords_system_alert_window">system alert window dialog draw on top other apps</string>
    <!-- Main settings screen item's title to go into the overlay settings screen [CHAR LIMIT=30] -->
    <string name="overlay_settings">Draw over other apps</string>

    <!-- Summary of number of apps currently can draw overlays [CHAR LIMIT=60] -->
    <string name="system_alert_window_summary"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> apps allowed to draw on top of other apps</string>

    <!-- Label for showing apps that can draw overlays [CHAR LIMIT=45] -->
    <string name="filter_overlay_apps">Apps with permission</string>
    <!-- Summary of app allowed to draw overlay [CHAR LIMIT=60] -->
    <string name="system_alert_window_on">Yes</string>
    <!-- Summary of app not allowed to draw overlay [CHAR LIMIT=60] -->
    <string name="system_alert_window_off">No</string>


    <!-- Write Settings settings -->
    <!-- Settings title in main settings screen for WRITE_SETTINGS [CHAR LIMIT=30] -->
    <string name="write_settings">Modify system settings</string>
    <!-- Keyword for WRITE_SETTINGS -->
    <string name="keywords_write_settings">write modify system settings</string>
    <!-- Summary of number of apps currently can draw overlays [CHAR LIMIT=60] -->
    <string name="write_settings_summary"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> apps allowed to modify system settings</string>

    <!-- Label for showing apps that can write system settings [CHAR LIMIT=45] -->
    <string name="filter_write_settings_apps">Can modify system settings</string>
    <!-- Title for the apps that are allowed to write system settings [CHAR LIMIT=60] -->
    <string name="write_settings_title">Can modify system settings</string>
    <!-- Main settings screen item's title to go into the write system settings screen [CHAR LIMIT=30] -->
    <string name="write_system_settings">Modify system settings</string>
    <!-- Link to the apps page for WRITE_SETTINGS settings [CHAR LIMIT=52] -->
    <string name="write_settings_preference">App modify system settings permission</string>
    <!-- Label for setting which controls whether app can write system settings [CHAR LIMIT=45] -->
    <string name="permit_write_settings">Allow modify system settings</string>
    <!-- Description of the write system settings [CHAR LIMIT=NONE] -->
    <string name="write_settings_description">This permission allows an app to modify system settings.</string>
    <!-- Summary of app allowed to write system settings [CHAR LIMIT=45] -->
    <string name="write_settings_on">Yes</string>
    <!-- Summary of app not allowed to write system settings [CHAR LIMIT=45] -->
    <string name="write_settings_off">No</string>

    <!-- Title of setting that controls gesture to open camera [CHAR LIMIT=40] -->
    <string name="camera_gesture_title">Double twist for camera</string>

    <!-- Description of setting that controls gesture to open camera [CHAR LIMIT=NONE] -->
    <string name="camera_gesture_desc">Open the camera app by twisting your wrist twice</string>

    <!-- Title of setting that controls gesture to open camera by double tapping the power button [CHAR LIMIT=40] -->
    <string name="camera_double_tap_power_gesture_title">Press power button twice for camera</string>

    <!-- Description of setting that controls gesture to open camera by double tapping the power button [CHAR LIMIT=NONE] -->
    <string name="camera_double_tap_power_gesture_desc">Quickly open camera without unlocking your screen</string>

    <!-- Name of each color mode for the display. [CHAR LIMIT=40] -->
    <string-array name="color_mode_names">
        <item>Vibrant (default)</item>
        <item>Natural</item>
        <item>Standard</item>
    </string-array>

    <!-- Description of each color mode for the display. [CHAR LIMIT=NONE] -->
    <string-array name="color_mode_descriptions">
        <item>Enhanced colors</item>
        <item>Natural colors as seen by the eye</item>
        <item>Colors optimized for digital content</item>
    </string-array>

    <!-- Name of feature to change color setting for the display [CHAR LIMIT=60] -->
    <string name="picture_color_mode">Picture color mode</string>

    <!-- Description of feature to change color setting for the display [CHAR LIMIT=NONE] -->
    <string name="picture_color_mode_desc">Use sRGB</string>
</resources>
