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

    <!-- Data Connection Enable. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="radio_info_data_connection_enable">Enable Data Connection</string>
    <!-- Data Connection Disable. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="radio_info_data_connection_disable">Disable Data Connection</string>

    <!-- VoLTE provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="volte_provisioned_switch_string">VoLTE Provisioned</string>

    <!-- Video calling provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="vt_provisioned_switch_string">Video Calling Provisioned</string>

    <!-- Wifi Calling provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="wfc_provisioned_switch_string">Wifi Calling Provisioned</string>

    <!-- Cell Radio Power. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="radio_info_radio_power">Cellular Radio Power</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>

    <!-- Content description for preview pager. [CHAR LIMIT=NONE] -->
    <string name="preview_pager_content_description">Preview</string>
    <!-- Content description for dot pager indicator for preview pager. [CHAR LIMIT=NONE] -->
    <string name="preview_page_indicator_content_description">Preview, page <xliff:g id="current_page" example="3">%1$d</xliff:g> of <xliff:g id="num_pages" example="9">%2$d</xliff:g></string>

    <!-- Summary of font size setting screen. [CHAR LIMIT=NONE] -->
    <string name="font_size_summary">Make the text on screen smaller or larger.</string>

    <!-- Description for the button that makes interface elements smaller. [CHAR_LIMIT=NONE] -->
    <string name="font_size_make_smaller_desc">Make smaller</string>
    <!-- Description for the button that makes interface elements larger. [CHAR_LIMIT=NONE] -->
    <string name="font_size_make_larger_desc">Make larger</string>

    <!-- Sample text for font size preview. -->
    <string name="font_size_preview_text">Servez à ce monsieur une bière et des kiwis.</string>
    <string name="font_size_preview_text_headline">Sample text</string>
    <string name="font_size_preview_text_title"
            translation_description="Title text in sample text used to illustrate how the currently selected font size will appear to the user. NOTE: Translate manually. No not adopt any copyrighted material for translation.">
        The Wonderful Wizard of Oz
    </string>
    <string name="font_size_preview_text_subtitle"
            translation_description="Subtitle text in sample text used to illustrate how the currently selected font size will appear to the user. NOTE: Translate manually. No not adopt any copyrighted material for translation.">
        Chapter 11: The Wonderful Emerald City of Oz</string>
    <string name="font_size_preview_text_body"
            translation_description="Text in sample text used to illustrate how the currently selected font size will appear to the user. NOTE: Translate manually. No not adopt any copyrighted material for translation.">
        Even with eyes protected by the green spectacles Dorothy and her friends were at first dazzled by the brilliancy of the wonderful City.
        The streets were lined with beautiful houses all built of green marble and studded everywhere with sparkling emeralds.
        They walked over a pavement of the same green marble, and where the blocks were joined together were rows of emeralds, set closely, and glittering in the brighness of the sun.
        The window panes were of green glass; even the sky above the City had a green tint, and the rays of the sun were green.
        \n\nThere were many people, men, women and children, walking about, and these were all dressed in green clothes and had greenish skins.
        They looked at Dorothy and her strangely assorted company with wondering eyes, and the children all ran away and hid behind their mothers when they saw the Lion; but no one spoke to them.
        Many shops stood in the street, and Dorothy saw that everything in them was green.
        Green candy and green pop-corn were offered for sale, as well as green shoes, green hats and green clothes of all sorts.
        At one place a man was selling green lemonade, and when the children bought it Dorothy could see that they paid for it with green pennies.
        \n\nThere seemed to be no horses nor animals of any kind; the men carried things around in little green carts, which they pushed before them.
        Everyone seeemed happy and contented and prosperous.
    </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>

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

    <!-- This string asks the user whether or not to allow an app to enable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_enablement"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth</string>
    <!-- This string asks the user whether or not to allow an app to disable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_disablement"><xliff:g id="app_name">%1$s</xliff:g> wants to turn off Bluetooth</string>

    <!-- This string asks the user whether or not to allow an app to enable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_enablement_no_name">An app wants to turn on Bluetooth</string>
    <!-- This string asks the user whether or not to allow an app to disable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_disablement_no_name">An app wants to turn off Bluetooth</string>

    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to make your tablet visible to other Bluetooth devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>
    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to make your phone visible to other Bluetooth devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>

    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery_no_name" 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. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery_no_name" 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. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to make your tablet 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 enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> 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 enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet">An app wants to make your tablet 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 enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery_no_name" 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 enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your tablet visible to other devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your phone visible to other devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery_no_name" 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. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery_no_name" 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. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your tablet visible to other devices. You can change this later in Bluetooth settings.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your phone visible to other devices. You can change this later in Bluetooth settings.</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" 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>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" 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">"Tap 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>

    <!-- 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 exclusion list label. -->
    <string name="proxy_exclusionlist_label">Bypass proxy for</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. 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>

    <!-- 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">Cell Location Info (deprecated):</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">Neighbor Cell Info (deprecated):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_cell_info_refresh_rate">Cell Info Refresh Rate:</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">All Cell Measurement Info:</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">Data Connection Real-Time Info:</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">Data 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_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_ppp_received_label">Data 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">Voice 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">Voice 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">Data Sent:</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_voice_network_type_label">Voice 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_data_network_type_label">Data 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_hostname_v4">Ping Hostname(www.google.com) IPv4:</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_v6">Ping Hostname(www.google.com) IPv6:</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 Radio Band Mode</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">Languages</string>

    <!-- Title for the language selection screen [CHAR LIMIT=25] -->
    <string name="pref_title_lang_selection">Language preferences</string>

    <!-- Menu item in the locale menu. Will remove the selected locales. [CHAR LIMIT=30] -->
    <string name="locale_remove_menu">Remove</string>

    <!-- "Button" that opens a language picker. The selected language gets added to the language list. [CHAR LIMIT=30] -->
    <string name="add_a_language">Add a language</string>

    <!-- The title of the confirmation dialog shown when the user selects one / several languages and tries to remove them [CHAR LIMIT=60] -->
    <plurals name="dlg_remove_locales_title">
        <item quantity="one">Remove selected language?</item>
        <item quantity="other">Remove selected languages?</item>
    </plurals>

    <!-- The text of the confirmation dialog shown when the user selects several languages and tries to remove them [CHAR LIMIT=NONE] -->
    <string name="dlg_remove_locales_message">Text will be displayed in another language.</string>

    <!-- The title of the error dialog shown when the user selects all the languages and tries to remove them [CHAR LIMIT=60] -->
    <string name="dlg_remove_locales_error_title">Can’t remove all languages</string>
    <!-- The text of the error dialog shown when the user selects all the languages and tries to remove them [CHAR LIMIT=NONE] -->
    <string name="dlg_remove_locales_error_message">Keep at least one preferred language</string>

    <!-- This text shows in the language picker when the system is not translated into that languages [CHAR LIMIT=80] -->
    <string name="locale_not_translated">May not be available in some apps</string>

    <!-- Label for an accessibility action that moves a language up in the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_up">Move up</string>
    <!-- Label for an accessibility action that moves a language down in the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_down">Move down</string>
    <!-- Label for an accessibility action that moves a language to the top of the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_top">Move to top</string>
    <!-- Label for an accessibility action that moves a language to the bottom of the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_bottom">Move to bottom</string>
    <!-- Label for an accessibility action that removes the currently selected language from the the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_remove">Remove 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">You may incur significant 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>
    <!-- Summary for settings preference disabled by administrator [CHAR LIMIT=50] -->
    <string name="disabled_by_administrator_summary">Disabled by administrator</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 showing the current number of fingerprints set up. Shown for a 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 to introduce the fingerprint feature[CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_introduction_title">Unlock with fingerprint</string>
    <!-- Introduction title shown in fingerprint enrollment to introduce the fingerprint feature, when fingerprint unlock is disabed by device admin [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled">Use your 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. Even one added print can do any of these things.\n\nNote: Your fingerprint may be less secure than a strong pattern or PIN.</string>
    <!-- Introduction detail message shown in fingerprint enrollment dialog, when fingerprint unlock is disabled by device admin [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled">Just touch the fingerprint sensor to authorize purchases, or sign in to apps. Be careful whose fingerprints you add. Even one added print can do any of these things.\n\nNote: You can\u2019t use your fingerprint to unlock this device. For more information, contact your organization\u2019s admin.</string>
    <!-- Introduction detail message shown in fingerprint enrollment screen in setup wizard. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message_setup">Just touch the fingerprint sensor to unlock your phone, authorize purchases, or sign in to apps. Be careful whose fingerprints you add. Even one added print can do any of these things.\n\nNote: Your fingerprint may be less secure than a strong pattern or PIN.</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>
    <!-- Button text to cancel enrollment from the introduction (this string variant is used while in setup wizard) [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup">Skip</string>
    <!-- Button text to continue to the next screen from the introduction (this string variant is used while in setup wizard) [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup">Add fingerprint</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so, including loss of factory reset protection. (tablet) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet">Device protection features will not be activated. You won\u2019t be able to prevent others from using this tablet if it\u2019s lost, stolen or wiped.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so, including loss of factory reset protection. (device) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device">Device protection features will not be activated. You won\u2019t be able to prevent others from using this device if it\u2019s lost, stolen or wiped.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so, including loss of factory reset protection. (phone) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default">Device protection features will not be activated. You won\u2019t be able to prevent others from using this phone if it\u2019s lost, stolen or wiped.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so. (tablet) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text" product="tablet">Device protection features will not be activated. You won\u2019t be able to prevent others from using this tablet if it\u2019s lost or stolen.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so. (device) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text" product="device">Device protection features will not be activated. You won\u2019t be able to prevent others from using this device if it\u2019s lost or stolen.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so. (phone) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text" product="default">Device protection features will not be activated. You won\u2019t be able to prevent others from using this phone if it\u2019s lost or stolen.</string>
    <!-- Button for skipping a step after having been warned of a potential concern [CHAR LIMIT=30] -->
    <string name="skip_anyway_button_label">Skip anyway</string>
    <!-- Button for going to the previous screen or step [CHAR LIMIT=20] -->
    <string name="go_back_button_label">Go back</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">Keep going</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 also authorize purchases or sign in to apps.</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. Contact your organization\'s administrator to learn more. <annotation id="admin_details">More details</annotation>\n\nYou 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=50]-->
    <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>
    <string name="fingerprint_last_delete_message_profile_challenge">You won\'t be able to use your fingerprints to unlock your work profile, authorize purchases, or sign in to work apps.</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 suggested actions for screen lock -->
    <string name="suggested_lock_settings_title">Set screen lock</string>

    <!-- Summary for suggested actions for screen lock -->
    <string name="suggested_lock_settings_summary">Protect your device</string>

    <!-- Title for suggested actions for settings up a fingerprint lock -->
    <string name="suggested_fingerprint_lock_settings_title">Use fingerprint</string>

    <!-- Summary for suggested actions for settings up a fingerprint lock -->
    <string name="suggested_fingerprint_lock_settings_summary">Unlock with your fingerprint</string>

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

    <!--  Title for security picker to choose the profile unlock method: None/Pattern/PIN/Password [CHAR LIMIT=22] -->
    <string name="lock_settings_picker_title_profile">Choose work lock</string>

    <!--  Title for security picker in setup wizard to choose the unlock method: None/Pattern/PIN/Password (tablet) [CHAR LIMIT=22] -->
    <string name="setup_lock_settings_picker_title" product="tablet">Protect your tablet</string>
    <!--  Title for security picker in setup wizard to choose the unlock method: None/Pattern/PIN/Password (device) [CHAR LIMIT=22] -->
    <string name="setup_lock_settings_picker_title" product="device">Protect your device</string>
    <!--  Title for security picker in setup wizard to choose the unlock method: None/Pattern/PIN/Password (phone) [CHAR LIMIT=22] -->
    <string name="setup_lock_settings_picker_title" product="default">Protect your phone</string>

    <!-- Title for screen in setup wizard, prompting user to choose the their backup screen lock method [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_fingerprint_message">For added security, set up a backup screen lock.</string>

    <!-- Description text for screen in setup wizard asking user to set up screen lock, explaining to the user how setting up a screen lock protect them from losing data. (tablet) [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_message" product="tablet">Prevent others from using this tablet without your permission by activating device protection features. Choose the screen lock you want to use.</string>
    <!-- Description text for screen in setup wizard asking user to set up screen lock, explaining to the user how setting up a screen lock protect them from losing data. (device) [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_message" product="device">Prevent others from using this device without your permission by activating device protection features. Choose the screen lock you want to use.</string>
    <!-- Description text for screen in setup wizard asking user to set up screen lock, explaining to the user how setting up a screen lock protect them from losing data. (phone) [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_message" product="default">Prevent others from using this phone without your permission by activating device protection features. Choose the screen lock you want to use.</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>

    <!--  Profile Security lock settings --><skip />
    <!--  Title for PreferenceScreen to launch picker for security method for the managed profile when there is none [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_launch_picker_title_profile">Work profile 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 change security 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 change security 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>

    <!-- Title for preference that allows the user to setup their lock screen preference later [CHAR LIMIT=22] -->
    <string name="unlock_set_do_later_title">Not now</string>

    <!-- Summary specifying that this is the current screen lock setting [CHAR LIMIT=45] -->
    <string name="current_screen_lock">Current screen lock</string>

    <!-- Title for preference that guides the user through creating a backup unlock pattern for fingerprint [CHAR LIMIT=45]-->
    <string name="fingerprint_unlock_set_unlock_pattern">Fingerprint + Pattern</string>

    <!-- Title for preference that guides the user through creating a backup unlock PIN for fingerprint [CHAR LIMIT=45]-->
    <string name="fingerprint_unlock_set_unlock_pin">Fingerprint + PIN</string>

    <!-- Title for preference that guides the user through creating a backup unlock password for fingerprint [CHAR LIMIT=45]-->
    <string name="fingerprint_unlock_set_unlock_password">Fingerprint + Password</string>

    <!-- Title for preference that guides the user to skip fingerprint setup [CHAR LIMIT=60]-->
    <string name="fingerprint_unlock_skip_fingerprint">Continue without fingerprint</string>

    <!-- Message shown in screen lock picker while setting up the new screen lock with fingerprint option. [CHAR LIMIT=NONE]-->
    <string name="fingerprint_unlock_title">You can unlock your phone using your fingerprint. For security, this option requires a backup 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>
    <!-- Title of the dialog shown when the user removes the profile lock [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_title_profile">Remove profile 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>

    <!-- Content of the dialog shown when the user removes the profile lock pattern [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_profile">"Profile protection features will not work without your pattern."</string>
    <!-- Content of the dialog shown when the user removes the profile lock pattern and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile">"Profile 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 profile and you won't be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the profile lock PIN [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_profile">"Profile protection features will not work without your PIN."</string>
    <!-- Content of the dialog shown when the user removes the profile lock PIN and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile">"Profile 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 profile and you won't be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the profile lock password [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_profile">"Profile protection features will not work without your password."</string>
    <!-- Content of the dialog shown when the user removes the profile lock password and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile">"Profile 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 profile and you won't be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the profile lock of unknown type [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_profile">"Profile protection features will not work without your screen lock."</string>
    <!-- Content of the dialog shown when the user removes the profile lock of unknown type and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile">"Profile 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 profile and you won't be able to unlock your profile, 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>

    <!-- Message shown when the user incorrectly enters their lock and it counts towards the max attempts before wiping the work profile. -->
    <string name="lock_profile_wipe_attempts">Try again. Attempt <xliff:g id="current_attempts">%1$d</xliff:g> of <xliff:g id="total_attempts">%2$d</xliff:g>.</string>
    <!-- Title of a dialog shown when the user only has one attempt left to provide the lock before the work profile is wiped. -->
    <string name="lock_profile_wipe_warning_title">Last try</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the work pattern before the work profile is wiped. -->
    <string name="lock_profile_wipe_warning_content_pattern">If you enter an incorrect work pattern on this attempt, your work profile and associated data will be removed from this device.</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the work PIN before the work profile is wiped. -->
    <string name="lock_profile_wipe_warning_content_pin">If you enter an incorrect work PIN on this attempt, your work profile and associated data will be removed from this device.</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the work password before the work profile is wiped. -->
    <string name="lock_profile_wipe_warning_content_password">If you enter an incorrect work password on this attempt, your work profile and associated data will be removed from this device.</string>
    <!-- Content of the dialog shown when the user has failed to provide the work lock too many times and the work profile is wiped. -->
    <string name="lock_profile_wipe_content">Too many incorrect attempts. Your work profile and associated data will be removed from this device.</string>
    <!-- Button label to dismiss the dialog telling the user the work profile has been wiped. [CHAR LIMIT=40] -->
    <string name="lock_profile_wipe_dismiss">Dismiss</string>

    <!-- Hint shown in dialog screen when password is too short -->
    <string name="lockpassword_password_too_short">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_continue_label">Continue</string>

    <!-- Error shown in popup when password is too long -->
    <string name="lockpassword_password_too_long">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">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">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">This can\'t include an invalid character</string>

    <!-- Error shown when in PASSWORD mode and password is all digits -->
    <string name="lockpassword_password_requires_alpha">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">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">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">Must contain at least 1 letter</item>
        <item quantity="other">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">Must contain at least 1 lowercase letter</item>
        <item quantity="other">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">Must contain at least 1 uppercase letter</item>
        <item quantity="other">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">Must contain at least 1 numerical digit</item>
        <item quantity="other">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">Must contain at least 1 special symbol</item>
        <item quantity="other">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">Must contain at least 1 non-letter character</item>
        <item quantity="other">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>

    <!-- This string asks the user whether or not to allow an app to enable WiFi. [CHAR LIMIT=NONE] -->
    <string name="wifi_ask_enable"><xliff:g id="requester" example="FancyApp">%s</xliff:g> wants to turn on Wi-Fi</string>
    <!-- This string asks the user whether or not to allow an app to disable WiFi. [CHAR LIMIT=NONE] -->
    <string name="wifi_ask_disable"><xliff:g id="requester" example="FancyApp">%s</xliff:g> wants to turn off Wi-Fi</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>
    <!-- Dialog title for NFC disclaimer [CHAR_LIMIT=40]-->
    <string name="nfc_disclaimer_title">Turn on NFC</string>
    <!-- Dialog content for NFC disclaimer: telling user NFC can exchange data when device is nearby other devices (for example: payment terminals, badge reader etc). [CHAR_LIMIT=NONE]-->
    <string name="nfc_disclaimer_content">NFC exchanges data between this device and other nearby devices or targets, such as payment terminals, access readers, and interactive ads or tags.</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 tap your screen. The app determines what gets beamed.</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>
    <!-- Preference title for option to automatically switch away from bad wifi networks [CHAR LIMIT=60]-->
    <string name="wifi_cellular_data_fallback_title">Switch to cellular data automatically</string>
    <!-- Preference summary for option to automatically switch away from bad wifi networks [CHAR LIMIT=None]-->
    <string name="wifi_cellular_data_fallback_summary">Use cellular data when Wi\u2011Fi has no Internet access. Data usage may apply.</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 Wi-Fi configure settings -->
    <string name="wifi_menu_configure">Configure</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>
    <!-- Message for talkback to say when Advanced Options expanded [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description_expanded">Drop down list Advanced Options. Double-tap to collapse.</string>
    <!-- Message for talkback to say when Advanced Options is collapsed [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description_collapsed">Drop down list Advanced Options. Double-tap to expand.</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>
    <!-- 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 domain name that the EAP CA certificate(s) can be used to validate. -->
    <string name="wifi_eap_domain">Domain</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>
    <!-- Label for the check box to share a network with other users on the same device -->
    <string name="wifi_shared">Share with other device users</string>
    <!-- Hint for unchanged fields -->
    <string name="wifi_unchanged">(unchanged)</string>
    <!-- Hint for unspecified fields -->
    <string name="wifi_unspecified">Please select</string>
    <!-- Hint for multiple certificates being added to the configuration -->
    <string name="wifi_multiple_cert_added">(Multiple certificates added)</string>
    <!-- Menu option for using trusted system CA certificates to validate EAP servers -->
    <string name="wifi_use_system_certs">Use system certificates</string>
    <!-- Menu option for not providing an EAP user certificate -->
    <string name="wifi_do_not_provide_eap_user_cert">Do not provide</string>
    <!-- Menu option for not validating the EAP server -->
    <string name="wifi_do_not_validate_eap_server">Do not validate</string>
    <!-- Warning message displayed if user choses not to validate the EAP server -->
    <string name="wifi_do_not_validate_eap_server_warning">No certificate specified. Your connection will not be private.</string>
    <!-- Warning message displayed if user does not specify a domain for the CA certificate.
         Only displayed if the user also chooses to use system certificates. -->
    <string name="wifi_no_domain_warning">Must specify a domain.</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>

    <!-- Dialog text to tell the user that the selected network has lost Internet access, and asking the user whether they want to avoid this network. -->
    <string name="lost_internet_access_title">Wi\u2011Fi is not connected to the Internet</string>
    <string name="lost_internet_access_text">You can switch to the cellular network whenever Wi\u2011Fi has a bad connection.  Data usage may apply.</string>
    <string name="lost_internet_access_switch">Switch to cellular</string>
    <string name="lost_internet_access_cancel">Stay on Wi\u2011Fi</string>
    <string name="lost_internet_access_persist">Never show again</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">Go back</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, configure, settings section.  This is a header shown above configure wifi settings. [CHAR LIMIT=30] -->
    <string name="wifi_configure_titlebar">Configure Wi\u2011Fi</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>
    <!-- Error message for users that aren't allowed to see or modify WiFi advanced settings [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_not_available">Wi\u2011Fi advanced settings are not available for this user</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>
    <!-- Label for the DNS (second one)-->
    <string name="wifi_dns2">DNS 2</string>
    <!-- Label for the gateway of the network -->
    <string name="wifi_gateway">Gateway</string>
    <!-- Label for the network prefix of the network [CHAR LIMIT=25]-->
    <string name="wifi_network_prefix_length">Network prefix length</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>
    <!-- Title of suggestion to turn on wifi calling [CHAR LIMIT=30] -->
    <string name="wifi_calling_suggestion_title">Turn on Wi-Fi Calling</string>
    <!-- Summary of suggestion to turn on wifi calling [CHAR LIMIT=60] -->
    <string name="wifi_calling_suggestion_summary">Use Wi-Fi instead of mobile network</string>
    <!-- Title of WFC preference item [CHAR LIMIT=30] -->
    <string name="wifi_calling_mode_title">Calling preference</string>
    <!-- Title of WFC preference selection dialog [CHAR LIMIT=30] -->
    <string name="wifi_calling_mode_dialog_title">Wi-Fi calling mode</string>
    <!-- Title of WFC roaming preference item [CHAR LIMIT=45] -->
    <string name="wifi_calling_roaming_mode_title">Roaming preference</string>
    <!-- Summary of WFC roaming preference item [CHAR LIMIT=NONE]-->
    <string name="wifi_calling_roaming_mode_summary"><xliff:g id="wfc_roaming_preference" example="Wi-Fi">%1$s</xliff:g></string>
    <!-- WFC mode dialog [CHAR LIMIT=45] -->
    <string name="wifi_calling_roaming_mode_dialog_title">Roaming preference</string>
    <string-array name="wifi_calling_mode_choices">
        <item>Wi-Fi preferred</item>
        <item>Cellular preferred</item>
        <item>Wi-Fi only</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_v2">
        <item>Wi-Fi</item>
        <item>Cellular</item>
        <item>Wi-Fi only</item>
    </string-array>
    <string-array name="wifi_calling_mode_values">
        <item>"2"</item>
        <item>"1"</item>
        <item>"0"</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_without_wifi_only">
        <item>Wi-Fi preferred</item>
        <item>Cellular preferred</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
        <item>Wi-Fi</item>
        <item>Cellular</item>
    </string-array>
    <string-array name="wifi_calling_mode_values_without_wifi_only">
        <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>
    <!-- Title of a preference for updating emergency address [CHAR LIMIT=40] -->
    <string name="emergency_address_title">Update Emergency Address</string>
    <!-- Summary of Update Emergency Address preference, explaining usage of emergency address [CHAR LIMIT=NONE] -->
    <string name="emergency_address_summary">Address used by emergency services as your location if you make a 911 call using WiFi</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">&#160;</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">Ring 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">Tap 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 tap</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 ring 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>
    <!-- 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>

    <!-- Night display screen, setting option name to enable night display (renamed "Night Light" with title caps). [CHAR LIMIT=30] -->
    <string name="night_display_title">Night Light</string>
    <!-- Night display screen, description of night display feature (renamed "Night Light" with title caps). [CHAR LIMIT=NONE] -->
    <string name="night_display_text">Night Light tints your screen amber. This makes it easier to look at your screen or read in dim light, and may help you fall asleep more easily.</string>
    <!-- Night display screen, category title for settings to schedule when night display activates automatically. [CHAR LIMIT=30] -->
    <string name="night_display_category_schedule">Schedule</string>
    <!-- Night display screen, category title for settings to manually activate night display. [CHAR LIMIT=30] -->
    <string name="night_display_category_status">Status</string>
    <!-- Night display screen, setting option name to configure whether night display turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_title">Turn on automatically</string>
    <!-- Night display screen, setting option value for night display to *never* turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_never">Never</string>
    <!-- Night display screen, setting option value for night display to turn on/off automatically according to a user defined schedule. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_custom">Custom schedule</string>
    <!-- Night display screen, setting option value for night display to turn on/off automatically at sunset/sunrise. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_twilight">Sunset to sunrise</string>
    <!-- Night display screen, setting option name to configure time to automatically turn on night display. [CHAR LIMIT=30] -->
    <string name="night_display_start_time_title">Start time</string>
    <!-- Night display screen, setting option name to configure time to automatically turn off night display. [CHAR LIMIT=30] -->
    <string name="night_display_end_time_title">End time</string>
    <!-- Display settings screen, summary format of night display when off. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off">Off. <xliff:g name="auto_mode_summary" example="Never turn on automatically">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of night display when off and will *never* turn on automatically. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off_auto_mode_never">Will never turn on automatically.</string>
    <!-- Display settings screen, summary format of night display when off and will turn on automatically at a user defined time. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off_auto_mode_custom">Will turn on automatically at <xliff:g name="time" example="6 AM">%1$s</xliff:g>.</string>
    <!-- Display settings screen, summary of night display when off and will turn on automatically at sunset. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off_auto_mode_twilight">Will turn on automatically at sunset.</string>
    <!-- Display settings screen, summary format of night display when on. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on">On. <xliff:g name="auto_mode_summary" example="Never turn off automatically">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of night display when on and will *never* turn off automatically. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on_auto_mode_never">Will never turn off automatically.</string>
    <!-- Display settings screen, summary format of night display when on and will turn off automatically at a user defined time. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on_auto_mode_custom">Will turn off automatically at <xliff:g name="time" example="10 PM">%1$s</xliff:g>.</string>
    <!-- Display settings screen, summary of night display when on and will turn off automatically at sunrise. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on_auto_mode_twilight">Will turn off automatically at sunrise.</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 suggestion title [CHAR LIMIT=30] -->
    <string name="wallpaper_suggestion_title">Change wallpaper</string>
    <!-- Wallpaper suggestion title [CHAR LIMIT=60] -->
    <string name="wallpaper_suggestion_summary">Personalize your screen</string>
    <!-- Wallpaper settings fragment title [CHAR LIMIT=30] -->
    <string name="wallpaper_settings_fragment_title">Choose wallpaper from</string>
    <!-- Display settings screen, trigger for screen saver options -->
    <string name="screensaver_settings_title">Screen saver</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 screen saver on.</string>
    <!-- Dream settings screen, action label, when to dream -->
    <string name="screensaver_settings_when_to_dream">When to start screen saver</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 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>
    <!-- Summary for Font size. Lets the user know that this will make text larger or smaller. Appears in the accessibility portion of setup wizard. [CHAR LIMIT=NONE] -->
    <string name="short_summary_font_size">Make text larger or smaller</string>
    <!-- Sound & display settings screen, setting option summary displaying the currently selected font size -->
    <string name="summary_font_size" translatable="false">%1$s</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_info">Model</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</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>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_iccid">ICCID</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. Menu option for using the deletion helper. [CHAR LIMIT=30] -->
    <string name="storage_menu_free">Free up space</string>
    <!-- Storage setting. Menu option for accessing the storage manager settings. [CHAR LIMIT=30] -->
    <string name="storage_menu_manage">Manage storage</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 describing internal storage used by the Android System [CHAR LIMIT=48]-->
    <string name="storage_detail_system">System</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 visible contents of this <xliff:g id="name" example="SD card">^1</xliff:g>, tap Explore.</string>

    <!-- Body of dialog informing user about the storage used by the Android System [CHAR LIMIT=NONE]-->
    <string name="storage_detail_dialog_system">System includes files that Android can\u2019t display individually.</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>
    <!-- Tethering controls, footer note displayed when tethering is disabled because Data Saver mode is on [CHAR LIMIT=none]-->
    <string name="tether_settings_disabled_on_data_saver">"Can\u2019t tether or use portable hotspots while Data Saver is on"</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>
    <!-- [CHAR LIMIT=30] Title for managed profile location switch  -->
    <string name="managed_profile_location_switch_title">Location for work profile</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 title for the user to go into the About phone screen -->
    <string name="about_settings" product="emulator">About emulated device</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 labels [CHAR LIMIT=25] -->
    <string name="regulatory_labels">Regulatory labels</string>
    <!-- About phone settings screen, setting option name to show the safety and regulatory manual [CHAR LIMIT=40] -->
    <string name="safety_and_regulatory_info">Safety &amp; regulatory manual</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>
    <!-- Message to be used to explain the user that he needs to enter his work pattern to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pattern_generic_profile">Use your work pattern to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his work PIN to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pin_generic_profile">Enter your work PIN to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his work password to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_password_generic_profile">Enter your work password to continue</string>

    <!-- An explanation text that the pattern needs to be solved since the device has just been restarted. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_reason_restart_device_pattern">Use your device pattern to continue. Required after device restarts.</string>
    <!-- An explanation text that the pin needs to be entered since the device has just been restarted. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_reason_restart_device_pin">Enter your device PIN to continue. Required after device restarts.</string>
    <!-- An explanation text that the password needs to be entered since the device has just been restarted. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_reason_restart_device_password">Enter your device password to continue. Required after device restarts.</string>

    <!-- An explanation text that the pattern needs to be solved since the device has just been restarted. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_reason_restart_work_pattern">Use your work pattern to continue. Required after device restarts.</string>
    <!-- An explanation text that the pin needs to be entered since the device has just been restarted. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_reason_restart_work_pin">Enter your work PIN to continue. Required after device restarts.</string>
    <!-- An explanation text that the password needs to be entered since the device has just been restarted. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_reason_restart_work_password">Enter your work password to continue. Required after device restarts.</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 a visible green line is drawn as the user moves his finger around while drawing the profile 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 profile.-->
    <string name="lockpattern_settings_enable_visible_pattern_title_profile">Make profile 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 tap</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>

    <!-- Profile Lock settings -->
    <!-- Security & location settings screen, header for profile specific section -->
    <string name="lock_settings_profile_title">Work profile security</string>
    <!-- Security & location settings screen, title when changing or confirming the work profile lock -->
    <string name="lock_settings_profile_screen_lock_title">Work profile screen lock</string>
    <!-- Security & location settings screen, setting option name to unify work and personal locks -->
    <string name="lock_settings_profile_unification_title">Use one lock</string>
    <!-- Security & location settings screen, setting option explanation to unify work and personal locks -->
    <string name="lock_settings_profile_unification_summary">Use one lock for work profile and device screen</string>
    <!-- Security & location settings screen, title of the dialog asking if the user wants to unify work and personal locks -->
    <string name="lock_settings_profile_unification_dialog_title">Use one lock?</string>
    <!-- Security & location settings screen, explanation in the dialog asking if the user wants to unify work and personal locks -->
    <string name="lock_settings_profile_unification_dialog_body">Your work profile and device screen will use the same lock. Any work lock policies will also apply to your device screen lock.</string>
    <!-- Security & location settings screen, explanation in the dialog asking if the user wants to create a new lock for personal and work as the current work lock is not enough for the device. -->
    <string name="lock_settings_profile_unification_dialog_uncompliant_body">Your work profile lock doesn\'t meet your organization\'s security requirements. You can use the same lock for your device screen and your work profile, but any work lock policies will apply.</string>
    <!-- Security & location settings screen, confirmation button of the dialog for user with compliant lock, asking to create a new lock for both personal and work profiles. -->
    <string name="lock_settings_profile_unification_dialog_confirm">Use one lock</string>
    <!-- Security & location settings screen, confirmation button of the dialog for user with uncompliant lock, asking to create a new lock for both personal and work profiles. -->
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm">Use one lock</string>
    <!-- Security & location settings screen, summary of the item that changes your work profile lock when it is unified with the personal lock -->
    <string name="lock_settings_profile_unified_summary">Same as device screen lock</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, individual application info storage screen. Describes the number of URIs (directories or files) an app has been granted access (by another apps)-->
    <plurals name="uri_permissions_text">
        <item quantity="one">1 item</item>
        <item quantity="other">%d items</item>
    </plurals>
    <!-- Manage applications, individual application info storage screen. Button below list of URIs. -->
    <string name="clear_uri_btn_text">Clear access</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, 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 together two unrelated items in a list when "and" is not an appropriate conjunction for these 2 items -->
    <string name="join_two_unrelated_items"><xliff:g id="first_item">%1$s</xliff:g>, <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>

    <!-- Text of pop up message if the request for a "migrate primary storage" operation
         (see storage_menu_migrate) is denied as another is already in progress. [CHAR LIMIT=75] -->
    <string name="another_migration_already_in_progress">Another migration is already in progress.</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>
    <!-- Error message shown when trying to move device administrators to external disks, such as SD card [CHAR_LIMIT=none] -->
    <string name="move_error_device_admin">Device Administrator 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>

    <!-- Manage applications, individual application info screen, section heading for information about the app installer [CHAR_LIMIT=25] -->
    <string name="app_install_details_group_title">Store</string>
    <!-- Manage applications, individual application info screen, title for the option which will trigger application info in it's installer [CHAR_LIMIT=25] -->
    <string name="app_install_details_title">App details</string>
    <!-- Manage applications, individual application info screen, summary for the option which will trigger application info in it's installer [CHAR_LIMIT=50] -->
    <string name="app_install_details_summary">App installed from <xliff:g id="app_store">%1$s</xliff:g></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>

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

    <!-- Languages 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">Languages&#160;&amp; input</string>
    <!-- Title of Languages & input settings screen -->
    <string name="language_keyboard_settings_title">Languages&#160;&amp; input</string>
    <!-- On Languages & input settings screen, heading. Inside the "Languages & input 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">Languages</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>

    <!-- Title for the 'keyboard and input methods' preference category. [CHAR LIMIT=45] -->
    <string name="keyboard_and_input_methods_category">Keyboard and input methods</string>
    <!-- Title for the 'virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="virtual_keyboard_category">Virtual keyboard</string>
    <!-- Title for the 'available virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="available_virtual_keyboard_category">Available virtual keyboard</string>
    <!-- Title for the button to trigger the 'Manage keyboards' preference sub-screen, where the user can turn on/off installed virtual keyboards.[CHAR LIMIT=35] -->
    <string name="add_virtual_keyboard">Manage keyboards</string>
    <!-- Title for the 'keyboard assistance' preference category. [CHAR LIMIT=35] -->
    <string name="keyboard_assistance_category">Keyboard assistance</string>
    <!-- Title for the 'physical keyboard' settings screen. [CHAR LIMIT=35] -->
    <string name="physical_keyboard_title">Physical keyboard</string>
    <!-- Title for the 'show virtual keyboard' preference switch. [CHAR LIMIT=35] -->
    <string name="show_ime">Show virtual keyboard</string>
    <!-- Summary text for the 'add virtual keyboard' preference sub-screen. [CHAR LIMIT=100] -->
    <string name="show_ime_summary">Keep it on screen while physical keyboard is active</string>
    <!-- Title for the button to trigger the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=35] -->
    <string name="keyboard_shortcuts_helper">Keyboard shortcuts helper</string>
    <!-- Summary text for the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=100] -->
    <string name="keyboard_shortcuts_helper_summary">Display available shortcuts</string>
    <!--
        Format string for a physical device in the form: InputMethodSubtype - InputMethodEditor.
        e.g. English (US) - X Keyboard -->
    <string name="physical_device_title" translatable="false"><xliff:g id="input_method_editor" example="X Keyboard">%1$s</xliff:g> - <xliff:g id="input_method_subtype" example="English (US)">%2$s</xliff:g></string>

    <!-- Summary text for keyboards when no layout has been selected. [CHAR LIMIT=35] -->
    <string name="default_keyboard_layout">Default</string>

    <!-- On Languages & input settings screen, heading. Inside the "Languages & 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 Languages & input settings screen, setting summary.  Setting for mouse pointer speed. [CHAR LIMIT=35] -->
    <string name="pointer_speed">Pointer speed</string>

    <!-- On Languages & input settings screen, heading. Inside the "Languages & 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 Languages & input settings screen, setting title.  Setting to redirect vibration to input devices. [CHAR LIMIT=35] -->
    <string name="vibrate_input_devices">Use vibrator</string>
    <!-- On Languages & 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. To add a word, tap 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 locales. (The user can select multiple system locales)
         [CHAR LIMIT=35] -->
    <string name="use_system_language_to_select_input_method_subtypes">Use system languages</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>

    <!-- 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>
    <!-- Settings title for a brief version of Vision-Related Accessibility Settings. Displayed in Setup Wizard only. [CHAR LIMIT=35] -->
    <string name="vision_settings_title">Vision Settings</string>
    <!-- Settings description for a brief version of Vision-Related Accessibility Settings. Tells the user that they can adjust these settings now to help them through the remainder of the Setup Wizard and that they can later be changed in Settings. Displayed in Setup Wizard only. [CHAR LIMIT=none] -->
    <string name="vision_settings_description">You can customize this device to fit your needs. These accessibility features can be changed later in Settings.</string>
    <!-- Title for the accessibility preference category of accessibility services. [CHAR LIMIT=25] -->
    <string name="accessibility_services_title">Services</string>
    <!-- Title for the Talkback Accessibility Service. Displayed on the Accessibility Settings screen in Setup Wizard. [CHAR_LIMIT=25] -->
    <string name="talkback_title">Talkback</string>
    <!-- Summary for the Talkback Accessibility Service. Lets the user know that Talkback is a screenreader and that it is usually most helpful to blind and low vision users and whether the service is on. [CHAR_LIMIT=none] -->
    <string name="talkback_summary">Screen reader primarily for people with blindness and low vision</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 gesture</string>
    <!-- Short summary for Magnification gesture. Tells the user that this feature allows the user to magnify the screen by tapping 3 times. Appears in accessibility portion of setup wizard -->
    <string name="accessibility_screen_magnification_short_summary">Tap 3 times to zoom</string>
    <!-- Summary for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_summary"><b>To zoom</b>, quickly tap the screen 3 times with one finger.\n<ul><li>Drag 2 or more fingers to scroll</li>\n<li>Pinch 2 or more fingers together or apart to adjust zoom</li></ul>\n\n<b>To zoom temporarily</b>, quickly tap the screen 3 times and hold down your finger on the third tap.\n<ul><li>Drag your finger to move around the screen</li>\n<li>Lift your finger to zoom out</li></ul>\n\nYou can\'t zoom in on 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 activate 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 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 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 the accessibility preference for enabling/disabling large icons for mouse/trackpad pointers. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_large_pointer_icon_title">Large mouse pointer</string>
    <!-- Title for the accessibility preference for master mono. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_master_mono_title">Mono audio</string>
    <!-- Summary for the accessibility preference for master mono. [CHAR LIMIT=50] -->
    <string name="accessibility_toggle_master_mono_summary">Combine channels when playing audio</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 accessibility preference for configuring feature that performs click action soon after mouse/trackpad pointer stops moving. [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_preference_title">Click after pointer stops moving</string>
    <!-- Title for accessibility preference for configuring amount of time that has to pass after pointer stops moving before click action can be performed (if automatic click after pointer stops moving feature is enabled). [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_delay_preference_title">Delay before click</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>

    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay">
        <item quantity="one">Extremely short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Extremely short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay">
        <item quantity="one">Very short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Very short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay">
        <item quantity="one">Short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay">
        <item quantity="one">Long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay">
        <item quantity="one">Very long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Very long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>

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

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

    <!-- Print frameworks summary in settings screen [CHAR LIMIT=50] -->
    <plurals name="print_settings_title">
        <item quantity="one">1 print job</item>
        <item quantity="other">%d print jobs</item>
    </plurals>

    <!-- Title for print service settings screen [CHAR LIMIT=25] -->
    <string name="print_settings_title">Print services</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>

    <!-- Description of printer info icon. [CHAR LIMIT=50] -->
    <string name="printer_info_desc">More information about this printer</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 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>

    <!-- On main TTS Settings screen, in default settings section, reset speech rate for synthesized voice to 1x speech rate.-->
    <string name="tts_reset_speech_rate_title">Reset speech rate</string>
    <!-- On main TTS Settings screen, summary for reset speech rate for synthesized voice -->
    <string name="tts_reset_speech_rate_summary">Reset the speed at which the text is spoken to normal.</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 to display user credentials and keys [CHAR LIMIT=30] -->
    <string name="user_credentials">User credentials</string>
    <!-- Summary of preference to display user credentials and keys [CHAR LIMIT=NONE] -->
    <string name="user_credentials_summary">View and modify stored credentials</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>
    <!-- Sub-heading for a user credential installed to be used by apps and as part of VPN configurations. [CHAR LIMIT=NONE] -->
    <string name="credential_for_vpn_and_apps">Installed for VPN and apps</string>
    <!-- Sub-heading for a user credential installed to be used as part of a Wi-Fi configuration. [CHAR LIMIT=NONE]. -->
    <string name="credential_for_wifi">Installed for Wi-Fi</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>

    <!-- 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 remote servers?</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 [CHAR LIMIT=80] -->
    <string name="remove_device_admin">Deactivate this device administrator</string>
    <!-- Label for button to uninstall the device admin application [CHAR LIMIT=80] -->
    <string name="uninstall_device_admin">Uninstall app</string>
    <!-- Label for button to deactivate and uninstall the device admin [CHAR_LIMIT=50]-->
    <string name="remove_and_uninstall_device_admin">Deactivate and Uninstall</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] -->
    <!-- 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 [CHAR_LIMIT=80] -->
    <string name="add_device_admin">Activate this device administrator</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>

    <!-- Message displayed to let the user know that some of the options are disabled by admin. [CHAR LIMIT=NONE] -->
    <string name="admin_disabled_other_options">Other options are disabled by your administrator.</string>
    <string name="admin_more_details">More details</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">Tap 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">Tap <b>Next</b> to continue with setup.\n\nTap <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>
    <!-- Account Settings. The preference title for enabling work mode -->
    <string name="work_mode_label">Work mode</string>
    <!-- Account Settings. The preference summary for enabling work mode -->
    <string name="work_mode_summary">Allow work profile to function, including apps, background sync, and related features</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">Tap 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\u2026</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>

    <!-- 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">Background data</string>
    <!-- Summary message for checkbox that restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_app_restrict_background_summary">Enable usage of cellular data in the background</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="18"><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="18"><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>
    <!-- Button label to connect a VPN profile, replacing the current one. [CHAR LIMIT=40] -->
    <string name="vpn_replace">Replace</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>
    <!-- Button label to forget a VPN profile [CHAR LIMIT=40] -->
    <string name="vpn_forget_long">Forget VPN</string>
    <!-- Dialog message title to set another VPN app to be always-on [CHAR LIMIT=40] -->
    <string name="vpn_replace_vpn_title">Replace existing VPN?</string>
    <!-- Dialog message title to set always-on VPN when another app was not already set. -->
    <string name="vpn_set_vpn_title">Set always-on VPN?</string>
    <!-- Dialog message body to explain that always-on VPN will disable network traffic while the VPN is connecting. -->
    <string name="vpn_first_always_on_vpn_message">By turning on this setting, you won\'t have an Internet connection until the VPN successfully connects</string>
    <!-- Dialog message body to explain that always-on VPN will disable network traffic while the VPN is connecting, and that this will replace the current VPN. -->
    <string name="vpn_replace_always_on_vpn_enable_message">Your existing VPN will be replaced, and you won\'t have an Internet connection until the VPN successfully connects</string>
    <!-- Dialog message body to connect a VPN app, replacing another VPN app that is already always-on [CHAR LIMIT=NONE] -->
    <string name="vpn_replace_always_on_vpn_disable_message">You\'re already connected to an always-on VPN. If you connect to a different one, your existing VPN will be replaced, and always-on mode will turn off.</string>
    <!-- Dialog message body to set another VPN app to be always-on [CHAR LIMIT=NONE] -->
    <string name="vpn_replace_vpn_message">You\'re already connected to a VPN. If you connect to a different one, your existing VPN will be replaced.</string>
    <!-- Dialog action button to turn on a VPN. -->
    <string name="vpn_turn_on">Turn on</string>
    <!-- Dialog mesage title when the user can't connect an always-on vpn [CHAR LIMIT=NONE] -->
    <string name="vpn_cant_connect_title"><xliff:g id="vpn_name" example="OpenVPN">%1$s</xliff:g> can\'t connect</string>
    <!-- Dialog message subtitle when the user can't connect an always-on vpn [CHAR LIMIT=NONE] -->
    <string name="vpn_cant_connect_message">This app doesn\'t support always-on VPN.</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>
    <!-- Placeholder when VPN settings is open but no VPNs have been created. [CHAR LIMIT=100] -->
    <string name="vpn_no_vpns_added">No VPNs added.</string>
    <!-- Preference summary for active always-on vpn [CHAR LIMIT=40] -->
    <string name="vpn_always_on_active">Always-on active</string>
    <!-- Preference summary for inactive always-on vpn [CHAR LIMIT=40] -->
    <string name="vpn_always_on_inactive">Always-on inactive</string>
    <!-- Preference summary for app not supporting always-on vpn [CHAR LIMIT=NONE] -->
    <string name="vpn_not_supported_by_this_app">Not supported by this app</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>
    <!-- Button label for trusting a user CA certificate. -->
    <string name="trusted_credentials_trust_label">Trust</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>

    <!-- Header for a list of items that a credential entry contains. For example, one private key and one certificate. [CHAR LIMIT=NONE] -->
    <string name="credential_contains">This entry contains:</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_userkey">one user key</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_usercrt">one user certificate</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_cacrt">one CA certificate</string>
    <!-- Item found in thee PKCS12 keystore being investigated [CHAR LIMIT=NONE]-->
    <string name="n_cacrts">%d CA certificates</string>
    <!-- Alert dialog when viewing a set of user credentials. -->
    <string name="user_credential_title">Credential Details</string>
    <!-- Announcement to confirm a user credential being removed. [CHAR LIMIT=NONE] -->
    <string name="user_credential_removed">Removed credential: <xliff:g id="credential_name" example="signing key">%s</xliff:g></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] -->
    <plurals name="ssl_ca_cert_dialog_title">
        <item quantity="one">Trust or remove certificate</item>
        <item quantity="other">Trust or remove certificates</item>
    </plurals>
    <!-- Text of message to show to device owner user whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <plurals name="ssl_ca_cert_info_message_device_owner">
        <item quantity="one"><xliff:g id="managing_domain">%s</xliff:g> has installed a certificate authority on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin.</item>
        <item quantity="other"><xliff:g id="managing_domain">%s</xliff:g> has installed certificate authorities on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin.</item>
    </plurals>
    <!-- Text of message to show to work profile users whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <plurals name="ssl_ca_cert_info_message">
        <item quantity="one"><xliff:g id="managing_domain">%s</xliff:g> has installed a certificate authority for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin.</item>
        <item quantity="other"><xliff:g id="managing_domain">%s</xliff:g> has installed certificate authorities for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin.</item>
    </plurals>
    <!-- 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]-->
    <plurals name="ssl_ca_cert_settings_button">
        <item quantity="one">Check certificate</item>
        <item quantity="other">Check certificates</item>
    </plurals>

    <!-- 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_admin">Admin</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 lock screen settings header[CHAR LIMIT=40] -->
    <string name="user_lockscreen_settings">Lock screen settings</string>
    <!-- User settings item to allow creating new users from locks creen [CHAR LIMIT=40] -->
    <string name="user_add_on_lockscreen_menu">Add users</string>
    <!-- User settings user_add_on_lockscreen_menu item summary [CHAR LIMIT=40] -->
    <string name="user_add_on_lockscreen_menu_summary">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>
    <!-- Title for the emergency info preference [CHAR LIMIT=40] -->
    <string name="emergency_info_title">Emergency information</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>

    <!-- 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, 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, Data saver [DO NOT TRANSLATE] -->
    <string name="help_url_data_saver" translatable="false"></string>
    <!-- Help URL, Unrestricted data access [DO NOT TRANSLATE] -->
    <string name="help_url_unrestricted_data_access" 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>
    <!-- Help URL, Gesture settings -->
    <string name="help_url_gestures" translatable="false"></string>
    <!-- Help URL, Manage Storage [DO NOT TRANSLATE]-->
    <string name="help_url_manage_storage" translatable="false"></string>
    <!-- Help URL, Android is upgrading [DO NOT TRANSLATE] -->
    <string name="help_url_upgrading" 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">Tap 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">Tap 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">Tap 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>
    <!-- Text to describe the items to be expanded as suggested settings [CHAR LIMIT=none] -->
    <plurals name="settings_suggestion_header_summary_hidden_items">
        <item quantity="one">Show %d hidden item</item>
        <item quantity="other">Show %d hidden items</item>
    </plurals>

    <!-- Title for setting tile leading to network and Internet settings [CHAR LIMIT=40]-->
    <string name="network_dashboard_title">Network &amp; Internet</string>
    <!-- Title for setting tile leading to Connected devices settings [CHAR LIMIT=40]-->
    <string name="connected_devices_dashboard_title">Connected devices</string>
    <!-- Title for setting tile leading to Apps & Notification settings [CHAR LIMIT=40]-->
    <string name="app_and_notification_dashboard_title">Apps &amp; notifications</string>
    <!-- Title for setting tile leading to User and accounts settings [CHAR LIMIT=40]-->
    <string name="account_dashboard_title">User &amp; accounts</string>
    <!-- Title for setting tile leading to setting UI which allows user set default app to
    handle actions such as open web page, making phone calls, default SMS apps [CHAR  LIMIT=40]-->
    <string name="app_default_dashboard_title">Default apps</string>
    <!-- Summary text for system preference tile, showing current display language of device [CHAR LIMIT=NONE]-->
    <string name="system_dashboard_summary">Language: <xliff:g id="language">%1$s</xliff:g></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>
    <string name="keywords_display_night_display">dim screen, night, tint</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, screen 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">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>
    <string name="keywords_color_temperature">color temperature D65 D73 white yellow blue warm cool</string>
    <string name="keywords_lockscreen">slide to unlock, password, pattern, PIN</string>
    <string name="keywords_profile_challenge">work challenge, work, profile</string>
    <string name="keywords_unification">work profile, managed profile, unify, unification, work, profile</string>
    <string name="keywords_gesture">gesture</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: Dashboard summary indicating the volume of ringtone. example: Ring volume at 20%.
    [CHAR LIMIT=100] -->
    <string name="sound_settings_summary">Ring volume at <xliff:g id="percentage" example="2%">%1$s</xliff:g></string>

    <!-- Sound: Dashboard summary indicating the volume of ringtone when at 0% with vibrate enabled. [CHAR LIMIT=100] -->
    <string name="sound_settings_summary_vibrate">Ringer set to vibrate</string>

    <!-- Sound: Dashboard summary indicating the volume of ringtone when at 0% with vibrate disabled [CHAR LIMIT=100] -->
    <string name="sound_settings_summary_silent">Ringer set to silent</string>

    <!-- Sound: Dashboard summary example used in Setup Wizard preview screen. [CHAR LIMIT=100] -->
    <string name="sound_settings_example_summary">Ring volume at 80%</string>

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

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

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

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

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

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

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

    <!-- Sound: 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: Title for the other sounds option and associated settings page. [CHAR LIMIT=30] -->
    <string name="other_sound_settings">Other sounds</string>

    <!-- Sound: 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: 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: Other sounds: Title for the option enabling charging sounds. [CHAR LIMIT=30] -->
    <string name="charging_sounds_title">Charging sounds</string>

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

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

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

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

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

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

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

    <!-- Sound: Other sounds: Title for the option enabling boot sounds. [CHAR LIMIT=30] -->
    <string name="boot_sounds_title">Power on sounds</string>

    <!-- Sound: Title for the Do not Disturb option and associated settings page. [CHAR LIMIT=30] -->
    <string name="zen_mode_settings_title">Do not disturb</string>

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

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

    <!--  Do not disturb: Title for the zen mode automation option Suggestion. [CHAR LIMIT=30] -->
    <string name="zen_mode_automation_suggestion_title">Set Do Not Disturb schedule</string>

    <!--  Do not disturb: Summary for the zen mode automation option Suggestion. [CHAR LIMIT=30] -->
    <string name="zen_mode_automation_suggestion_summary">Silence your device at certain times</string>

    <!--  Do not disturb: Zen mode option: Important interruptions [CHAR LIMIT=60] -->
    <string name="zen_mode_option_important_interruptions">Priority only</string>

    <!--  Do not disturb: Zen mode option: Alarms only [CHAR LIMIT=60] -->
    <string name="zen_mode_option_alarms">Alarms only</string>

    <!--  Do not disturb: Zen mode option: No interruptions [CHAR LIMIT=60] -->
    <string name="zen_mode_option_no_interruptions">Total silence</string>

    <!--  Do not disturb: 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>

    <!--  Do not disturb: Title for the Visual interruptions option and associated settings page. [CHAR LIMIT=30] -->
    <string name="zen_mode_visual_interruptions_settings_title">Block visual disturbances</string>

    <!-- Work Sounds: Work sound settings section header.  [CHAR LIMIT=50] -->
    <string name="sound_work_settings">Work profile sounds</string>

    <!-- Work Sounds: Title for the switch that enables syncing of personal ringtones to work profile. [CHAR LIMIT=60] -->
    <string name="work_use_personal_sounds_title">Use personal profile sounds</string>

    <!--  Work Sound: Summary for the switch that enables syncing of personal ringtones to work profile. [CHAR LIMIT=160] -->
    <string name="work_use_personal_sounds_summary">Work profile sounds are the same as personal profile</string>

    <!-- Work Sounds: Title for the option defining the work phone ringtone. [CHAR LIMIT=60] -->
    <string name="work_ringtone_title">Work phone ringtone</string>

    <!-- Work Sounds: Title for the option defining the default work notification ringtone. [CHAR LIMIT=60] -->
    <string name="work_notification_ringtone_title">Default work notification tone</string>

    <!-- Work Sound: Title for the option defining the default work alarm ringtone. [CHAR LIMIT=60] -->
    <string name="work_alarm_ringtone_title">Default work alarm ringtone</string>

    <!--  Work Sound: Summary for sounds when sync with personal sounds is active [CHAR LIMIT=60] -->
    <string name="work_sound_same_as_personal">Same as personal profile</string>

    <!-- Work Sound: Title for dialog shown when enabling sync with personal sounds. [CHAR LIMIT=60] -->
    <string name="work_sync_dialog_title">Replace work profile sounds?</string>

    <!-- Work Sound: Confirm action text for dialog shown when enabling sync with personal sounds. [CHAR LIMIT=30] -->
    <string name="work_sync_dialog_yes">Replace</string>

    <!-- Work Sound: Message for dialog shown when enabling sync with personal sounds. [CHAR LIMIT=none] -->
    <string name="work_sync_dialog_message">Your current work profile sounds will be replaced with your personal profile sounds</string>


    <!-- Configure Notifications Settings title. [CHAR LIMIT=30] -->
    <string name="configure_notification_settings">Notification preferences</string>

    <!-- Configure Notifications: Advanced section header [CHAR LIMIT=30] -->
    <string name="advanced_section_header">Advanced</string>

    <!-- Configure Notifications: Work profile section header [CHAR LIMIT=30] -->
    <string name="profile_section_header">Work notifications</string>

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

    <!-- Configure Notifications: Title for the option controlling notifications on the lockscreen. [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_title">On the lock screen</string>

    <!-- Configure Notifications: 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>

    <!-- Configure Notifications: 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>

    <!-- Configure Notifications: 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>

    <!-- Configure Notifications: Value for lockscreen notifications:  all information will be
         shown in work notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_show_profile">Show all work notification content</string>

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

    <!-- Configure Notifications: Value for lockscreen notifications: work notifications will not appear on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_disable_profile">Don\u2019t show work notifications at all</string>

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

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

    <!-- Notification Settings: Title for the option managing notifications per application. [CHAR LIMIT=30] -->
    <string name="app_notifications_title">Notifications</string>

    <!-- [CHAR LIMIT=100] Notification importance slider title -->
    <string name="notification_importance_title">Importance</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: unset importance level description -->
    <string name="notification_importance_none">Not set</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: blocked importance level description -->
    <string name="notification_importance_blocked">Never show notifications from this app</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: min importance level description -->
    <string name="notification_importance_min">No full screen interruption, peeking, sound, or vibration. Show at the bottom of the notification list. Hide from lock screen and status bar.</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: low importance level description -->
    <string name="notification_importance_low">No full screen interruption, peeking, sound, or vibration.</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: normal importance level description -->
    <string name="notification_importance_default">No full screen interruption or peeking.</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: high importance level description -->
    <string name="notification_importance_high">Always peek. No full screen interruption.</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: max importance level description -->
    <string name="notification_importance_max">Always peek, and allow full screen interruption. Show at the top of the notification list.</string>

    <!-- [CHAR LIMIT=100] Notification Importance slider: max importance level description -->
    <string name="notification_importance_unspecified">App determines importance for each notification</string>

    <!-- [CHAR LIMIT=60] Notification importance reset button -->
    <string name="importance_reset">Reset</string>

    <!-- [CHAR LIMIT=40] Notification importance title -->
    <string name="show_silently">Show silently</string>

    <!-- [CHAR LIMIT=180] Notification importance summary -->
    <string name="show_silently_summary">Don\'t make sound, vibrate, or peek these notifications into view on the current screen.</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.
        \n\nThis will also give the app the ability to turn Do Not Disturb on or off and change related settings.
    </string>
    <string name="notification_listener_disable_warning_summary">
        If you turn off notification access for <xliff:g id="notification_listener_name">%1$s</xliff:g>, Do Not Disturb access may also be turned off.
    </string>
    <string name="notification_listener_disable_warning_confirm">Turn off</string>
    <string name="notification_listener_disable_warning_cancel">Cancel</string>

    <!-- Title for managing VR (virtual reality) helper services. [CHAR LIMIT=50] -->
    <string name="vr_listeners_title">VR helper services</string>

    <!-- String to show in the list of vr listeners, when none is installed -->
    <string name="no_vr_listeners">No installed apps have requested to be run as VR helper services.</string>

    <!-- Title for a warning message about security implications of enabling a VR
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="vr_listener_security_warning_title">Allow VR service access for
         <xliff:g id="service" example="VrCore">%1$s</xliff:g>?</string>
    <!-- Summary for a warning message about security implications of enabling a VR
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="vr_listener_security_warning_summary">
        <xliff:g id="vr_listener_name">%1$s</xliff:g> will be able to run when you are using
        applications in virtual reality mode.
    </string>

    <!-- Title for what display preferences are applied when device is in VR mode -->
    <string name="display_vr_pref_title">When device is in VR</string>

    <!-- [CHAR LIMIT=70] Put display into low-persistence mode, this decreases motion blur. -->
    <string name="display_vr_pref_low_persistence">Reduce blur (recommended)</string>

    <!-- [CHAR LIMIT=70] Do not change default display settings, this may reduce perceived screen
         flicker while in VR mode. -->
    <string name="display_vr_pref_off">Reduce flicker</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: channels title -->
    <string name="notification_channels">Channels</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] Channel notification settings: Block option title -->
    <string name="channel_notification_block_title">Block all</string>

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

    <!-- [CHAR LIMIT=NONE] App notification settings: Override DND option title -->
    <string name="app_notification_override_dnd_title">Override Do Not Disturb</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Override DND option description-->
    <string name="app_notification_override_dnd_summary">Let these notifications continue to interrupt when Do Not Disturb is set to Priority Only</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Visibility override option title -->
    <string name="app_notification_visibility_override_title">On the lock screen</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=150] App notification settings: App notifications Importance title -->
    <string name="app_notification_importance_title">Importance</string>

    <!-- [CHAR LIMIT=180] Notification settings: lights -->
    <string name="notification_show_lights_title">Always pulse notification light</string>

    <!-- [CHAR LIMIT=180] Notification settings: vibration -->
    <string name="notification_vibrate_title">Always vibrate</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=60] Zen mode settings: Choose rule type dialog title -->
    <string name="zen_mode_choose_rule_type">Choose rule type</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_enabled_combination">On / <xliff:g id="mode" example="Alarms only">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Third party Rule summary template -->
    <string name="zen_mode_rule_summary_provider_combination"><xliff:g id="package" example="Condition Provider App">%1$s</xliff:g>\n<xliff:g id="summary" example="On / 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=60] Zen mode settings: Downtime rule setting -->
    <string name="zen_mode_schedule_alarm_title">Alarm can override end time</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Downtime rule setting -->
    <string name="zen_mode_schedule_alarm_summary">Stop at the end time or next alarm, whichever comes first</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: All messages summary -->
    <string name="zen_mode_all_messages">All 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: All callers summary -->
    <string name="zen_mode_all_callers">All callers</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=40] Zen mode settings: visual interruptions: screen is on: title -->
    <string name="zen_mode_screen_on">Block when screen is on</string>

    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is on: summary -->
    <string name="zen_mode_screen_on_summary">Prevent notifications silenced by Do Not Disturb from peeking or popping on screen</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: visual interruptions: screen is off: title -->
    <string name="zen_mode_screen_off">Block when screen is off</string>

    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is off: summary -->
    <string name="zen_mode_screen_off_summary">Prevent notifications silenced by Do Not Disturb from turning on the screen or pulsing the notification light</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is off: summary -->
    <string name="zen_mode_screen_off_summary_no_led">Prevent notifications silenced by Do Not Disturb from turning on the screen</string>

    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions summary -->
    <string name="zen_mode_all_visual_interruptions">Off</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions summary -->
    <string name="zen_mode_screen_on_visual_interruptions">When screen is on</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions summary -->
    <string name="zen_mode_screen_off_visual_interruptions">When screen is off</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions summary -->
    <string name="zen_mode_no_visual_interruptions">When screen is on or off</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. Tap Overview.\n\n4. Swipe up and then tap 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>

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

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

   <!-- [CHAR LIMIT=NONE] Dialog body explaining that the app just selected by the user will not work after a reboot until until after the user enters their credentials, such as a PIN or password. -->
   <string name="direct_boot_unaware_dialog_message">Note: After a reboot, this app can\'t start until you unlock your phone</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>

   <!-- Category name for App Launch -->
   <string name="app_launch_domain_links_title">Opening 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>
   <!-- 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">Blocked</string>
    <!-- App notification summary with notifications silenced [CHAR LIMIT=40] -->
    <string name="notifications_silenced">Silenced</string>
    <!-- App notification summary with notifications redacted [CHAR LIMIT=70] -->
    <string name="notifications_redacted">Sensitive content not on lock screen</string>
    <!-- App notification summary with notifications hidden [CHAR LIMIT=40] -->
    <string name="notifications_hidden">Not on lock screen</string>
    <!-- App notification summary with notifications bypassing DND [CHAR LIMIT=40] -->
    <string name="notifications_priority">Do Not Disturb overridden</string>
    <!-- App notification summary divider [CHAR LIMIT=40] -->
    <string name="notifications_summary_divider">\u00A0/\u00A0</string>
    <!-- App notification summary for advanced controls -->
    <string name="notification_summary_level">Level %d</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>

    <!-- 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 domain URLs (data URI with http or https) in list [CHAR LIMIT=30] -->
    <string name="filter_with_domain_urls_apps">With domain URLs</string>
    <!-- Label for showing apps with priority notifications in list [CHAR LIMIT=50] -->
    <string name="filter_notif_priority_apps">Overrides Do Not Disturb</string>
    <!-- Label for showing apps redacting sensitive notifications in list [CHAR LIMIT=50] -->
    <string name="filter_notif_sensitive_apps">No sensitive content on lock screen</string>
    <!-- Label for showing apps hiding notifications from lockscreen [CHAR LIMIT=50] -->
    <string name="filter_notif_hide_notifications_apps">Never shown on lock screen</string>
    <!-- Filter label for apps that the user has silenced [CHAR LIMIT=40] -->
    <string name="filter_notif_silent">Shown silently</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>

   <!-- 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">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$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">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$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>

    <!-- Title of a preference item that will show the user's preferences for this app's priority for opening links to websites that it claims to support [CHAR LIMIT=30] -->
    <string name="domain_urls_title">Opening links</string>

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

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

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

    <!-- Description of settings item that leads to list of all apps that can open web links [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</string>

    <!-- Title for Default Apps settings for work [CHAR LIMIT=30] -->
    <string name="default_for_work">Default for work</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>

    <!-- Label of system app for current setting -->
    <string name="system_app">(System)</string>

    <!-- Label of system and default app for current setting -->
    <string name="system_default_app">(System 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">Not optimized</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>

    <!-- 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 dialog shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator. -->
    <string name="share_remote_bugreport_dialog_title">Share bug report?</string>
    <!-- Message of a dialog shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator. -->
    <string name="share_remote_bugreport_dialog_message_finished">Your IT admin requested a bug report to help troubleshoot this device. Apps and data may be shared.</string>
    <!-- Message of a dialog shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator and it's still being taken. -->
    <string name="share_remote_bugreport_dialog_message">Your IT admin requested a bug report to help troubleshoot this device. Apps and data may be shared, and your device may temporarily slow down.</string>
    <!-- Message of a dialog shown to inform that the remote bugreport that was requested remotely by the IT administrator is still being taken and will be shared when finished. -->
    <string name="sharing_remote_bugreport_dialog_message">This bug report is being shared with your IT admin. Contact them for more details.</string>
    <!-- Acceptance label of dialog shown to ask for user consent for sharing the remote bugreport. -->
    <string name="share_remote_bugreport_action">Share</string>
    <!-- Decline label of dialog shown to ask for user consent for sharing the remote bugreport. -->
    <string name="decline_remote_bugreport_action">Decline</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">Charge this device</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">Supply power</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. -->
    <string name="usb_use_power_only_desc">Supply power to 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">Transfer files</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 another 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 photos via PTP. -->
    <string name="usb_use_photo_transfers">Transfer photos (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">Use device as 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 this device as MIDI</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 to</string>

    <!-- Settings item title for USB preference [CHAR LIMIT=35] -->
    <string name="usb_pref">USB</string>
    <!-- Summary for the USB preference when nothing is connected through the usb port.  [CHAR LIMIT=40] -->
    <string name="usb_nothing_connected">Nothing connected</string>

    <!-- Settings item title for background check prefs [CHAR LIMIT=35] -->
    <string name="background_check_pref">Background check</string>

    <!-- Settings screen title for background check prefs [CHAR LIMIT=35] -->
    <string name="background_check_title">Full background access</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>

    <!-- Title for the "flash" preference to determine whether a flash is shown on screen when an assistant accesses the contents of the screeen. [CHAR LIMIT=40] -->
    <string name="assist_flash_title">Flash screen</string>

    <!-- Summary for the "flash" preference to determine whether a flash is shown on screen when an assistant accesses the contents of the screeen. [CHAR LIMIT=NONE] -->
    <string name="assist_flash_summary">Flash edges of screen when assist app accesses text from screen or screenshot</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>

    <string name="zen_access_disabled_package_warning">Must stay turned on because notification access is on</string>

    <!-- Zen mode access settings - title for warning dialog when revoking access [CHAR LIMIT=NONE] -->
    <string name="zen_access_revoke_warning_dialog_title">Revoke 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 revoking access [CHAR LIMIT=NONE] -->
    <string name="zen_access_revoke_warning_dialog_summary">All Do Not Disturb rules created by this app will be removed.</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 VR setting -->
    <string name="keywords_vr_listener">vr virtual reality listener stereo helper service</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">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$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">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$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>

    <!-- Title of setting that controls screen zoom (e.g. how large interface elements appear). [CHAR LIMIT=40] -->
    <string name="screen_zoom_title">Display size</string>
    <!-- Short summary for Magnification gesture. Lets the user know that this makes items on screen larger or smaller. Appears in the accessibility portion of Setup Wizard. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_short_summary">Make items on screen larger or smaller</string>
    <!-- Keywords for setting that controls screen zoom (e.g. how large interface elements appear). [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_keywords">display density, screen zoom, scale, scaling</string>
    <!-- Summary of screen zoom setting screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_summary">Make the items on your screen smaller or larger. Some apps on your screen may change position.</string>
    <!-- Title of the screen zoom preview activity. -->
    <string name="screen_zoom_preview_title">Preview</string>
    <!-- Description for the button that makes interface elements smaller. [CHAR_LIMIT=NONE] -->
    <string name="screen_zoom_make_smaller_desc">Make smaller</string>
    <!-- Description for the button that makes interface elements larger. [CHAR_LIMIT=NONE] -->
    <string name="screen_zoom_make_larger_desc">Make larger</string>

    <!-- Name Initial shown in the conversation message icon. [CHAR LIMIT=1] -->
    <string name="screen_zoom_conversation_icon_alex">A</string>
    <!-- Name Initial shown in the conversation message icon. [CHAR LIMIT=1] -->
    <string name="screen_zoom_conversation_icon_pete">P</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_1">Hi Pete!</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_2">Hey, want to grab coffee and catch up today?</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_3">Sounds great. I know of a good place not too far from here.</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_4">Perfect!</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_1">Tue 6:00PM</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_2">Tue 6:01PM</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_3">Tue 6:02PM</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_4">Tue 6:03PM</string>

    <!-- Wi-Fi state - Disconnected [CHAR LIMIT=NONE] -->
    <string name="disconnected">Disconnected</string>

    <!-- Summary of data usage [CHAR LIMIT=NONE] -->
    <string name="data_usage_summary_format"><xliff:g id="amount" example="50%">%1$s</xliff:g> of data used</string>

    <!-- Summary of notifications [CHAR LIMIT=NONE] -->
    <plurals name="notification_summary">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> app blocked from sending</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> apps blocked from sending</item>
    </plurals>

    <!-- Summary of notifications when no apps are blocked [CHAR LIMIT=NONE] -->
    <string name="notification_summary_none">All apps allowed to send</string>

    <!-- Summary of apps [CHAR LIMIT=NONE] -->
    <string name="apps_summary"><xliff:g id="count" example="24">%1$d</xliff:g> apps installed</string>
    <!-- Example summary of apps used in Setup Wizard preview screen [CHAR LIMIT=NONE] -->
    <string name="apps_summary_example">24 apps installed</string>

    <!-- Summary of storage usage [CHAR LIMIT=NONE] -->
    <string name="storage_summary"><xliff:g id="size1" example="8GB">%1$s</xliff:g> of <xliff:g id="size2" example="32GB">%2$s</xliff:g> used</string>

    <!-- Summary of display with screen sleep timeout [CHAR LIMIT=NONE] -->
    <string name="display_summary">Sleep after <xliff:g id="timeout_description" example="10 minutes">%1$s</xliff:g> of inactivity</string>
    <!-- Example summary of display used in Setup Wizard preview screen [CHAR LIMIT=NONE] -->
    <string name="display_summary_example">Sleep after 10 minutes of inactivity</string>

    <!-- Summary of memory screen [CHAR LIMIT=NONE] -->
    <string name="memory_summary">Avg <xliff:g id="used_memory" example="1.7GB">%1$s</xliff:g> of <xliff:g id="total_memory" example="2GB">%2$s</xliff:g> memory used</string>

    <!-- Summary of user screen [CHAR LIMIT=NONE] -->
    <string name="user_summary">Signed in as <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>

    <!-- Summary of payment screen [CHAR LIMIT=NONE] -->
    <string name="payment_summary"><xliff:g id="app_name" example="Payment App">%1$s</xliff:g> is default</string>

    <!-- Summary of location screen [CHAR LIMIT=NONE] -->
    <string name="location_on_summary">ON / <xliff:g id="location_mode" example="High accuracy">%1$s</xliff:g></string>

    <!-- Location off [CHAR LIMIT=NONE] -->
    <string name="location_off_summary">OFF</string>

    <!-- Backup disabled summary [CHAR LIMIT=NONE] -->
    <string name="backup_disabled">Back up disabled</string>

    <!-- Summary of device info page [CHAR LIMIT=NONE] -->
    <string name="about_summary">Android <xliff:g id="version" example="6.0">%1$s</xliff:g></string>

    <!-- TODO: Update these strings with the finalized ones. -->
    <!-- Title for dialog displayed when user clicks on a setting locked by an admin [CHAR LIMIT=30] -->
    <string name="disabled_by_policy_title">Action not allowed</string>
    <!-- Shown when the user tries to change a settings locked by an admin [CHAR LIMIT=200] -->
    <string name="default_admin_support_msg">This action is disabled. Contact your organization\'s administrator to learn more.</string>
    <!-- Shown in dialog to allow user to see more information about the device admin [CHAR LIMIT=30] -->
    <string name="admin_support_more_info">More details</string>
    <!-- Shown in admin details page to warn user about policies the admin can set in a work profile. [CHAR LIMIT=NONE] -->
    <string name="admin_profile_owner_message">Your administrator can monitor and manage apps and data associated with your work profile, including settings, permissions, corporate access, network activity, and the device\'s location information.</string>
    <!-- Shown in admin details page to warn user about policies the admin can set on a user. [CHAR LIMIT=NONE] -->
    <string name="admin_profile_owner_user_message">Your administrator can monitor and manage apps and data associated with this user, including settings, permissions, corporate access, network activity, and the device\'s location information.</string>
    <!-- Shown in admin details page to warn user about policies the admin can set on a device. [CHAR LIMIT=NONE] -->
    <string name="admin_device_owner_message">Your administrator can monitor and manage apps and data associated with this device, including settings, permissions, corporate access, network activity, and the device\'s location information.</string>

    <!-- Turn off a conditional state of the device (e.g. airplane mode, or hotspot) [CHAR LIMIT=30] -->
    <string name="condition_turn_off">Turn off</string>

    <!-- Turn on a conditional state of the device (e.g. cellular data) [CHAR LIMIT=30] -->
    <string name="condition_turn_on">Turn on</string>

    <!-- Content description used when expanding a condition item to see more details -->
    <string name="condition_expand_show">Show</string>

    <!-- Content description used when collapsing a condition item to see less details -->
    <string name="condition_expand_hide">Hide</string>

    <!-- Title of condition that hotspot is on [CHAR LIMIT=30] -->
    <string name="condition_hotspot_title">Hotspot is on</string>

    <!-- Summary of condition that hotspot is on [CHAR LIMIT=NONE] -->
    <string name="condition_hotspot_summary">Portable Wi-Fi hotspot <xliff:g name="ap_name" example="AndroidAP">%1$s</xliff:g> is active, Wi-Fi for this device is turned off.</string>

    <!-- Title of condition that airplane mode is on [CHAR LIMIT=30] -->
    <string name="condition_airplane_title">Airplane mode is on</string>

    <!-- Summary of condition that airplane mode is on [CHAR LIMIT=NONE] -->
    <string name="condition_airplane_summary">Wi-Fi, Bluetooth, and cellular network are turned off. You can\'t make phone calls or connect to the Internet.</string>

    <!-- Title of condition that do not disturb is on [CHAR LIMIT=30] -->
    <string name="condition_zen_title">Do not disturb is on (<xliff:g name="zen_mode_type" example="Alarms only">%1$s</xliff:g>)</string>

    <!-- Title of condition that battery saver is on [CHAR LIMIT=30] -->
    <string name="condition_battery_title">Battery Saver is on</string>

    <!-- Summary of condition that battery saver is on [CHAR LIMIT=NONE] -->
    <string name="condition_battery_summary">Performance is reduced. Location services and background data are turned off.</string>

    <!-- Title of condition that cellular data is off [CHAR LIMIT=30] -->
    <string name="condition_cellular_title">Cellular data is off</string>

    <!-- Summary of condition that cellular data is off [CHAR LIMIT=NONE] -->
    <string name="condition_cellular_summary">Internet is available only via Wi-Fi</string>

    <!-- Title of condition that background data is off [CHAR LIMIT=30] -->
    <string name="condition_bg_data_title">Data Saver is on</string>

    <!-- Summary of condition that background data is off [CHAR LIMIT=NONE] -->
    <string name="condition_bg_data_summary">Background data is only available via Wi-Fi. This may affect some apps or services when Wi-Fi is not available.</string>

    <!-- Title of condition that work mode is off [CHAR LIMIT=30] -->
    <string name="condition_work_title">Work profile is off</string>

    <!-- Summary of condition that work mode is off [CHAR LIMIT=NONE] -->
    <string name="condition_work_summary">Apps, background sync, and other features related to your work profile are turned off.</string>

    <!-- Title of condition that night display is on (renamed "Night Light" with title caps) [CHAR LIMIT=30] -->
    <string name="condition_night_display_title">Night Light is on</string>

    <!-- Summary of condition that night display is on (renamed "Night Light" with title caps) [CHAR LIMIT=NONE] -->
    <string name="condition_night_display_summary">Screen is tinted amber. This may help you fall asleep.</string>

    <!-- Title for the suggestions section on the dashboard [CHAR LIMIT=30] -->
    <string name="suggestions_title">Suggestions</string>

    <!-- Summary for the suggestions section on the dashboard, representing number of suggestions. [CHAR LIMIT=10] -->
    <string name="suggestions_summary">+<xliff:g name="count" example="3">%1$d</xliff:g></string>

    <!-- Name of option to remove a suggestion from the list [CHAR LIMIT=30] -->
    <string name="suggestion_remove">Remove</string>

    <!-- Name of the setting to change the display's color temperature -->
    <string name="color_temperature">Cool color temperature</string>

    <!-- Description of the setting to change the display's color temperature -->
    <string name="color_temperature_desc">Use cooler display colors</string>

    <!-- Toast message letting the user know the color temperature setting is not immediate -->
    <string name="color_temperature_toast">To apply color change, turn off screen</string>

    <!-- Name of the setting to disable the automatic update -->
    <string name="ota_disable_automatic_update">Automatic system updates</string>

    <!-- Label for category for data usage [CHAR LIMIT=30] -->
    <string name="usage">Usage</string>

    <!-- Label for cellular data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="cellular_data_usage">Cellular data usage</string>

    <!-- Label for wifi data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="wifi_data_usage">Wi-Fi data usage</string>

    <!-- Label for ethernet data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="ethernet_data_usage">Ethernet data usage</string>

    <!-- Label for section about wifi in data usage screen [CHAR LIMIT=60] -->
    <string name="wifi">Wi-Fi</string>

    <!-- Label for section about ethernet in data usage screen [CHAR LIMIT=60] -->
    <string name="ethernet">Ethernet</string>

    <!-- Format string for amount of cellular data used [CHAR LIMIT=30] -->
    <string name="cell_data_template"><xliff:g id="amount" example="1 GB">^1</xliff:g> cellular data</string>

    <!-- Format string for amount of wifi data used [CHAR LIMIT=30] -->
    <string name="wifi_data_template"><xliff:g id="amount" example="1 GB">^1</xliff:g> Wi-Fi data</string>

    <!-- Format string for amount of ethernet data used [CHAR LIMIT=30] -->
    <string name="ethernet_data_template"><xliff:g id="amount" example="1 GB">^1</xliff:g> ethernet data</string>

    <!-- Format for a summary describing the amount of data before the user is warned [CHAR LIMIT=NONE] -->
    <string name="cell_warning_only"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> Data warning</string>

    <!-- Format for a summary describing the amount of data before the user is warned or limited [CHAR LIMIT=NONE] -->
    <string name="cell_warning_and_limit"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> Data warning / <xliff:g name="amount" example="2 GB">%2$s</xliff:g> Data limit</string>

    <!-- Title of button and screen for billing cycle preferences [CHAR LIMIT=30 -->
    <string name="billing_cycle">Billing cycle</string>

    <!-- Summary describing when the billing cycle for their phone carrier starts [CHAR LIMIT=NONE] -->
    <string name="billing_cycle_summary">Monthly cycle starts on the <xliff:g name="day" example="1st">%1$s</xliff:g> of every month</string>

    <!-- Summary describing when the billing cycle for their phone carrier starts [CHAR LIMIT=NONE] -->
    <string name="billing_cycle_fragment_summary">Monthly starting <xliff:g name="day_of_month" example="1st">%1$s</xliff:g></string>

    <!-- Title of button and screen for which wifi networks have data restrictions [CHAR LIMIT=30 -->
    <string name="network_restrictions">Network restrictions</string>

    <!-- A summary shown on data usage screens to indicate inaccuracy of data tracking [CHAR LIMIT=NONE] -->
    <string name="operator_warning">Carrier data accounting may differ from device accounting</string>

    <!-- Format string describing how much data has been used [CHAR LIMIT=20] -->
    <string name="data_used_template"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> used</string>

    <!-- Label for switch about whether to warn user about usage [CHAR LIMIT=30] -->
    <string name="set_data_warning">Set data warning</string>

    <!-- Label for button to set the amount of data before user is warned about usage [CHAR LIMIT=30] -->
    <string name="data_warning">Data warning</string>

    <!-- Label for switch about whether to limit how much data can be used [CHAR LIMIT=30] -->
    <string name="set_data_limit">Set data limit</string>

    <!-- Label for button to set the amount of data before user is limited [CHAR LIMIT=30] -->
    <string name="data_limit">Data limit</string>

    <!-- Summary about how much data has been used in a date range [CHAR LIMIT=NONE] -->
    <string name="data_usage_template"><xliff:g name="amount" example="200 MB">%1$s</xliff:g> used between <xliff:g name="date_range" example="Jan 1 -- Feb 2">%2$s</xliff:g></string>

    <!-- Accessibility label for button that leads to screen with more configuration options [CHAR LIMIT=NONE] -->
    <string name="configure">Configure</string>

    <!-- List of app names included in data usage on app data usage screen
         [CHAR LIMIT=50] -->
    <string name="data_usage_other_apps">Other apps included in usage</string>

    <!-- Description of number of apps allowed to ignore Data Saver [CHAR LIMIT=NONE] -->
    <plurals name="data_saver_unrestricted_summary">
        <item quantity="one">1 app allowed to use unrestricted data when Data Saver is on</item>
        <item quantity="other"><xliff:g id="count" example="10">%1$d</xliff:g> apps allowed to use unrestricted data when Data Saver is on</item>
    </plurals>

    <!-- Name of Data Saver screens [CHAR LIMIT=30] -->
    <string name="data_saver_title">Data saver</string>

    <!-- Button that leads to list of apps with unrestricted data access [CHAR LIMIT=60] -->
    <string name="unrestricted_data_saver">Unrestricted data access</string>

    <!-- Description of message shown when app is blacklisted for background data access [CHAR LIMIT=NONE] -->
    <string name="restrict_background_blacklisted">Background data is turned off</string>

    <!-- Summary for the Data Saver feature being on [CHAR LIMIT=NONE] -->
    <string name="data_saver_on">On</string>

    <!-- Summary for the Data Saver feature being off [CHAR LIMIT=NONE] -->
    <string name="data_saver_off">Off</string>

    <!-- Title for switch to allow app unrestricted data usage [CHAR LIMIT=30] -->
    <string name="unrestricted_app_title">Unrestricted data usage</string>

    <!-- Title for switch to allow app unrestricted data usage [CHAR LIMIT=30] -->
    <string name="unrestricted_app_summary">Allow unrestricted data access when Data Saver is on</string>

    <!-- Button to switch the default home app [CHAR LIMIT=60] -->
    <string name="home_app">Home app</string>

    <!-- No default home set summary [CHAR LIMIT=NONE] -->
    <string name="no_default_home">No default Home</string>

    <!-- Title of the preference controlling whether the device encryption password/PIN/Pattern must be entered before being able to start the device. [CHAR LIMIT=60]-->
    <string name="lockpattern_settings_require_cred_before_startup">Secure start-up</string>

    <!-- Summary of the preference controlling whether the device encryption *pattern* must be entered before being able to start the device. [CHAR LIMIT=NONE]-->
    <string name="lockpattern_settings_require_pattern_before_startup_summary">Require pattern to start up your device. While off, this device can\'t receive calls, messages, notifications, or alarms.</string>

    <!-- Summary of the preference controlling whether the device encryption *PIN* must be entered before being able to start the device. [CHAR LIMIT=NONE]-->
    <string name="lockpattern_settings_require_pin_before_startup_summary">Require PIN to start up your device. While off, this device can\'t receive calls, messages, notifications, or alarms.</string>

    <!-- Summary of the preference controlling whether the device encryption *password* must be entered before being able to start the device. [CHAR LIMIT=NONE]-->
    <string name="lockpattern_settings_require_password_before_startup_summary">Require password to start up your device. While off, this device can\'t receive calls, messages, notifications, or alarms.</string>

    <!-- Title for suggestion adding more fingerprints [CHAR LIMIT=30] -->
    <string name="suggestion_additional_fingerprints">Add another fingerprint</string>

    <!-- Summary for suggestion adding more fingerprints [CHAR LIMIT=60] -->
    <string name="suggestion_additional_fingerprints_summary">Unlock with a different finger</string>

    <!-- Summary of battery saver when on [CHAR LIMIT=NONE] -->
    <string name="battery_saver_on_summary">On / <xliff:g name="automatic_state" example="Never turn on automatically">%1$s</xliff:g></string>

    <!-- Summary of battery saver when off [CHAR LIMIT=NONE] -->
    <string name="battery_saver_off_summary">Off / <xliff:g name="automatic_state" example="Never turn on automatically">%1$s</xliff:g></string>

    <!-- [CHAR_LIMIT=NONE] Battery saver: Description for automatic entry option: Never -->
    <string name="battery_saver_desc_turn_on_auto_never">Never turn on automatically</string>

    <!-- [CHAR_LIMIT=NONE] Battery saver: Description for automatic entry option: pct% battery -->
    <string name="battery_saver_desc_turn_on_auto_pct">Turn on automatically at %1$s battery</string>

    <!-- [CHAR_LIMIT=NONE] Label for when app is ignoring battery optimizations -->
    <string name="not_battery_optimizing">Not using battery optimization</string>

    <!-- Text for the setting on whether you can type text into notifications without unlocking the device. -->
    <string name="lockscreen_remote_input">If device is locked, prevent typing replies or other text in notifications</string>

    <string-array name="bytes_picker_sizes" translatable="false">
        <item>@*android:string/megabyteShort</item>
        <item>@*android:string/gigabyteShort</item>
    </string-array>

    <!-- [CHAR LIMIT=30] Label for setting to control the default spell checker -->
    <string name="default_spell_checker">Default spell checker</string>

    <!-- [CHAR LIMIT=30] Title for dialog for setting to control the default spell checker -->
    <string name="choose_spell_checker">Choose spell checker</string>

    <!-- [CHAR LIMIT=30] Label for the placeholder of the current spell checker name.  Used when no spell checker is currently selected. -->
    <string name="spell_checker_not_selected">Not selected</string>

    <!-- Notification log debug tool: missing title -->
    <string name="notification_log_no_title">(none)</string>
    <!-- Notification log debug tool: delimiter between header and field data -->
    <string name="notification_log_details_delimiter">": "</string>
    <!-- Notification log debug tool: header: package name -->
    <string name="notification_log_details_package">pkg</string>
    <!-- Notification log debug tool: header: notification key -->
    <string name="notification_log_details_key">key</string>
    <!-- Notification log debug tool: header: notification group -->
    <string name="notification_log_details_group">group</string>
    <!-- Notification log debug tool: header: notification group summary suffix -->
    <string name="notification_log_details_group_summary"> (summary)</string>
    <!-- Notification log debug tool: header: notification visibility -->
    <string name="notification_log_details_visibility">visibility</string>
    <!-- Notification log debug tool: header: notification public version -->
    <string name="notification_log_details_public_version">publicVersion</string>
    <!-- Notification log debug tool: header: notification priority -->
    <string name="notification_log_details_priority">priority</string>
    <!-- Notification log debug tool: header: notification importance -->
    <string name="notification_log_details_importance">importance</string>
    <!-- Notification log debug tool: header: notification importance explanation -->
    <string name="notification_log_details_explanation">explanation</string>
    <!-- Notification log debug tool: header: notification contentIntent field -->
    <string name="notification_log_details_content_intent">intent</string>
    <!-- Notification log debug tool: header: notification deleteIntent field -->
    <string name="notification_log_details_delete_intent">delete intent</string>
    <!-- Notification log debug tool: header: notification fullScreenIntent field -->
    <string name="notification_log_details_full_screen_intent">full screen intent</string>
    <!-- Notification log debug tool: header: notification actions list -->
    <string name="notification_log_details_actions">actions</string>
    <!-- Notification log debug tool: header: title -->
    <string name="notification_log_details_title">title</string>
    <!-- Notification log debug tool: header: notification action remoteinput -->
    <string name="notification_log_details_remoteinput">remote inputs</string>
    <!-- Notification log debug tool: header: notification contentView -->
    <string name="notification_log_details_content_view">custom view</string>
    <!-- Notification log debug tool: header: notification extras -->
    <string name="notification_log_details_extras">extras</string>
    <!-- Notification log debug tool: header: notification icon -->
    <string name="notification_log_details_icon">icon</string>
    <!-- Notification log debug tool: header: notification size -->
    <string name="notification_log_details_parcel">parcel size</string>
    <!-- Notification log debug tool: notification ashmem size -->
    <string name="notification_log_details_ashmem">ashmem</string>
    <!-- Notification log debug tool: header: notification sound info -->
    <string name="notification_log_details_sound">sound</string>
    <!-- Notification log debug tool: header: notification vibration info -->
    <string name="notification_log_details_vibrate">vibrate</string>
    <!-- Notification log debug tool: the word 'default' -->
    <string name="notification_log_details_default">default</string>
    <!-- Notification log debug tool: the word 'none' -->
    <string name="notification_log_details_none">none</string>
    <!-- Notification log debug tool: missing ranking information -->
    <string name="notification_log_details_ranking_null">Ranking object is missing.</string>
    <!-- Notification log debug tool: the word 'none' -->
    <string name="notification_log_details_ranking_none">Ranking object doesn\'t contain this key.</string>

    <!-- [CHAR_LIMIT=60] Label for special access screen -->
    <string name="special_access">Special access</string>

    <!-- Developer option to convert to file encryption - final warning -->
    <string name="confirm_convert_to_fbe_warning">Really wipe user data and convert to file encryption?</string>
    <!-- Developer option to convert to file encryption - final button -->
    <string name="button_confirm_convert_fbe">Wipe and convert</string>

    <!-- Reset rate-limiting in the system service ShortcutManager.  "ShortcutManager" is the name of a system service and not translatable.
    If the word "rate-limit" is hard to translate, use "Reset ShortcutManager API call limit" as the source text, which means
    the same thing in this context.
     [CHAR_LIMIT=none] -->
    <string name="reset_shortcut_manager_throttling">Reset ShortcutManager rate-limiting</string>

    <!-- Toast message shown when "Reset ShortcutManager rate-limiting" has been performed. [CHAR_LIMIT=none] -->
    <string name="reset_shortcut_manager_throttling_complete">ShortcutManager rate-limiting has been reset</string>

    <!-- Title of notification suggestion during optional steps of setup. [CHAR_LIMIT=60] -->
    <string name="notification_suggestion_title">Control lock screen notifications</string>
    <!-- Summary of notification suggestion during optional steps of setup. [CHAR_LIMIT=80] -->
    <string name="notification_suggestion_summary">Show or hide notification content</string>
    <!-- Setting tab title for all setting options. [CHAR LIMIT=20] -->
    <string name="page_tab_title_summary">All</string>
    <!-- Setting tab title for support setting options. [CHAR LIMIT=20] -->
    <string name="page_tab_title_support">Support</string>

    <!-- Summary of developer options to set the smallest width of the screen [CHAR LIMIT=60]-->
    <string name="developer_density_summary"><xliff:g name="count" example="320">%d</xliff:g> dp</string>

    <!-- Title of developer options to set the smallest width of the screen [CHAR LIMIT=60]-->
    <string name="developer_smallest_width">Smallest width</string>

    <!-- Message shown when there are no premium SMS apps [CHAR LIMIT=NONE] -->
    <string name="premium_sms_none">No installed apps have requested Premium SMS access</string>

    <!-- Warning message shown between options to enable Premium SMS for an app [CHAR LIMIT=NONE] -->
    <string name="premium_sms_warning">Premium SMS may cost you money and will add up to your carrier bills. If you enable permission for an app, you will be able to send premium SMS using that app.</string>

    <!-- Title of screen controlling which apps have access to send premium SMS messages [CHAR LIMIT=60] -->
    <string name="premium_sms_access">Premium SMS access</string>

    <!-- [CHAR LIMIT=25] Bluetooth is disabled. -->
    <string name="bluetooth_disabled">Disabled</string>

    <!-- [CHAR LIMIT=60] Name of dev option called demo mode -->
    <string name="demo_mode">Demo mode</string>

    <!-- Title text for connecting to customer support [CHAR LIMIT=80]-->
    <string name="support_escalation_title">We\'re here to help</string>

    <!-- Title text for connecting to 24/7 available customer support [CHAR LIMIT=80]-->
    <string name="support_escalation_24_7_title">We\'re here for you 24/7</string>

    <!-- Content description for connecting customer support. The "24 7" part indicates
    support is available 24 hours a day, 7 days a week. It's used by screenreaders so it
    cannot contain any symbol other that space. [CHAR LIMIT=80]-->
    <string name="support_escalation_24_7_content_description">We\'re here for you 24 7</string>

    <!-- Summary text for connecting to customer support [CHAR LIMIT=NONE]-->
    <string name="support_escalation_summary">Our support team is here to help address any issue</string>

    <!-- Summary text for connecting to 24/7 customer support [CHAR LIMIT=NONE]-->
    <string name="support_escalation_24_7_summary">Our support team is available all day, every day</string>

    <!-- Summary text when customer support is closed. [CHAR LIMIT=NONE]-->
    <string name="support_escalation_closed_summary">Search help or come back during support hours (local time):&lt;br&gt;&lt;b&gt;<xliff:g id="operation_hours">%s</xliff:g>&lt;/b&gt;</string>

    <!-- Summary text to call customer support when there is no internet. [CHAR LIMIT=NONE]-->
    <string name="support_escalation_no_internet_summary">Phone support hours (local time)&lt;br&gt;&lt;b&gt;<xliff:g id="operation_hours">%s</xliff:g>&lt;/b&gt;</string>

    <!-- Summary text when customer support is unavailable in the region. [CHAR LIMIT=NONE]-->
    <string name="support_escalation_unavailable_summary">Search help or explore tips &amp; tricks</string>

    <!-- Template for formatting support hours eg Mon - Fri, 8:00 AM - 19:30 PM. [CHAR LIMIT=NONE]-->
    <string name="support_hour_format" translatable="false">
        <xliff:g id="start_day">%1$s</xliff:g> - <xliff:g id="end_day">%2$s</xliff:g>, <xliff:g id="start_time">%3$s</xliff:g> - <xliff:g id="end_time">%4$s</xliff:g>&lt;br&gt;
    </string>

    <!-- Button label for choosing country for phone support. [CHAR LIMIT=40]-->
    <string name="support_country_list_title">Support for:</string>

    <!-- Template for formatting country and language. eg Canada - French [CHAR LIMIT=NONE]-->
    <string name="support_country_format"><xliff:g id="country" example="Canada">%1$s</xliff:g> - <xliff:g id="language" example="French">%2$s</xliff:g></string>

    <!-- Template for formatting phone number and language. eg English (800-000-0000) [CHAR LIMIT=NONE]-->
    <string name ="support_phone_international_format">
        <xliff:g id="language" example="English">%1$s</xliff:g> (<xliff:g id="phone" example="800-000-0000">%2$s</xliff:g>)
    </string>

    <!-- Title text for a list of international support phone numbers. [CHAR LIMIT=60]-->
    <string name="support_international_phone_title">Traveling abroad?</string>

    <!-- Description text warning international phone charge may apply when dialing support numbers. [CHAR LIMIT=NONE]-->
    <string name="support_international_phone_summary">International charges may apply</string>

    <!-- Button label for contacting customer support by phone [CHAR LIMIT=20]-->
    <string name="support_escalation_by_phone">Phone</string>

    <!-- Button label for contacting customer support by chat [CHAR LIMIT=20]-->
    <string name="support_escalation_by_chat">Chat</string>

    <!-- Button label for visiting the tips & tricks site [CHAR LIMIT=60]-->
    <string name="support_tips_and_tricks_title">Explore tips &amp; tricks</string>

    <!-- Button label for visiting help and/or send feedback [CHAR LIMIT=60]-->
    <string name="support_help_feedback_title">Search help &amp; send feedback</string>

    <!-- Title text that indicates user needs to sign in to get customer support. [CHAR LIMIT=80]-->
    <string name="support_sign_in_required_title">Contact support</string>

    <!-- Summary text that indicates user needs to sign-in to get real time customer support. [CHAR LIMIT=NONE]-->
    <string name="support_sign_in_required_summary" translatable="false"></string>

    <!-- Button label for signing in an account [CHAR LIMIT=40]-->
    <string name="support_sign_in_button_text">Sign in</string>

    <!-- Button label that redirects user who needs help for signin to help screen [CHAR LIMIT=NONE]-->
    <string name="support_sign_in_required_help">Can\'t sign in?</string>

    <!-- Dialog title displayed before initiating real time support [CHAR LIMIT=80]-->
    <string name="support_disclaimer_title">Send system information</string>

    <!-- Checkbox text, when checked dialog will not show again [CHAR LIMIT=80] -->
    <string name="support_disclaimer_do_not_show">Do not show again</string>

    <!-- [CHAR LIMIT=60] Title of work profile setting page -->
    <string name="managed_profile_settings_title">Work profile settings</string>
    <!-- [CHAR LIMIT=60] The preference title for enabling cross-profile remote contact search -->
    <string name="managed_profile_contact_search_title">Contact search</string>
    <!-- [CHAR LIMIT=NONE] The preference summary for enabling cross-profile remote contact search -->
    <string name="managed_profile_contact_search_summary">Allow contact searches by your organization to identify callers and contacts</string>

    <!-- Time in hours -->
    <plurals name="hours">
        <item quantity="one">1 hour</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> hours</item>
    </plurals>

    <!-- Time in minutes -->
    <plurals name="minutes">
        <item quantity="one">1 minute</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> minutes</item>
    </plurals>

    <!-- Time in seconds -->
    <plurals name="seconds">
        <item quantity="one">1 second</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> seconds</item>
    </plurals>

    <!-- Estimated wait time range for real time supports -->
    <string name="support_estimated_wait_time">~<xliff:g id="ESTIMATE" example="2 minutes">%1$s</xliff:g> wait</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_computer">Computer</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_headset">Headset</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_phone">Phone</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_imaging">Imaging</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_headphone">Headphone</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_input_peripheral">Input Peripheral</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. -->
    <string name="bluetooth_talkback_bluetooth">Bluetooth</string>

    <!-- Used as title on the automatic storage manager settings. [CHAR LIMIT=60] -->
    <string name="automatic_storage_manager_settings">Manage storage</string>

    <!-- Used as wall of text to describe the feature. [CHAR LIMIT=NONE] -->
    <string name="automatic_storage_manager_text">To help free up storage space, storage manager removes backed up photos and videos from your device.</string>

    <!-- Dropdown preference title for dropdown describing how many days of data to retain.-->
    <string name="automatic_storage_manager_days_title">Remove photos &amp; videos</string>

    <!-- Preference title for the automatic storage manager toggle. [CHAR LIMIT=60]-->
    <string name="automatic_storage_manager_preference_title">Storage manager</string>

    <!-- Category title for the automatic settings in the storage manager settings. [CHAR LIMIT=40] -->
    <string name="deletion_helper_automatic_title">Automatic</string>

    <!-- Category title for the manual settings in the storage manager settings. [CHAR LIMIT=40] -->
    <string name="deletion_helper_manual_title">Manual</string>

    <!-- Preference menu title for accessing the deletion helper from the storage manager settings. [CHAR LIMIT=30]-->
    <string name="deletion_helper_preference_title">Free up space now</string>

    <!-- Preference title for gesture settings [CHAR LIMIT=25]-->
    <string name="gesture_preference_title">Gestures</string>

    <!-- Preference summary for gesture settings (phone) [CHAR LIMIT=NONE]-->
    <string name="gesture_preference_summary" product="default">Quick gestures to control your phone</string>
    <!-- Preference summary for gesture settings (tablet) [CHAR LIMIT=NONE]-->
    <string name="gesture_preference_summary" product="tablet">Quick gestures to control your tablet</string>
    <!-- Preference summary for gesture settings (device) [CHAR LIMIT=NONE]-->
    <string name="gesture_preference_summary" product="device">Quick gestures to control your device</string>

    <!-- Title text for double tap power for camera [CHAR LIMIT=60]-->
    <string name="double_tap_power_for_camera_title">Jump to Camera</string>

    <!-- Summary text for double tap power for camera [CHAR LIMIT=160]-->
    <string name="double_tap_power_for_camera_summary">To quickly open camera, press the power button twice. Works from any screen</string>

    <!-- Title text for double twist for camera mode [CHAR LIMIT=60]-->
    <string name="double_twist_for_camera_mode_title">Flip camera</string>

    <!-- Summary text for double twist for camera mode  [CHAR LIMIT=160]-->
    <string name="double_twist_for_camera_mode_summary"></string>

    <!-- Title text for ambient display double tap (phone) [CHAR LIMIT=60]-->
    <string name="ambient_display_title" product="default">Double-tap to check phone</string>
    <!-- Title text for ambient display double tap (tablet) [CHAR LIMIT=60]-->
    <string name="ambient_display_title" product="tablet">Double-tap to check tablet</string>
    <!-- Title text for ambient display double tap (device) [CHAR LIMIT=60]-->
    <string name="ambient_display_title" product="device">Double-tap to check device</string>

    <!-- Summary text for ambient display double tap [CHAR LIMIT=160]-->
    <string name="ambient_display_summary">To quickly check your notifications, double-tap your screen</string>

    <!-- Title text for ambient display pick up (phone) [CHAR LIMIT=60]-->
    <string name="ambient_display_pickup_title" product="default">Lift to check phone</string>
    <!-- Title text for ambient display pick up (tablet) [CHAR LIMIT=60]-->
    <string name="ambient_display_pickup_title" product="tablet">Lift to check tablet</string>
    <!-- Title text for ambient display pick up (device) [CHAR LIMIT=60]-->
    <string name="ambient_display_pickup_title" product="device">Lift to check device</string>

    <!-- Summary text for ambient display (phone) [CHAR LIMIT=160]-->
    <string name="ambient_display_pickup_summary" product="default">To quickly check your notifications, pick up your phone</string>
    <!-- Summary text for ambient display (tablet) [CHAR LIMIT=160]-->
    <string name="ambient_display_pickup_summary" product="tablet">To quickly check your notifications, pick up your tablet</string>
    <!-- Summary text for ambient display (device) [CHAR LIMIT=160]-->
    <string name="ambient_display_pickup_summary" product="device">To quickly check your notifications, pick up your device</string>

    <!-- Title text for fingerprint swipe for notifications [CHAR LIMIT=60]-->
    <string name="fingerprint_swipe_for_notifications_title">Swipe for notifications</string>

    <!-- Summary text for fingerprint swipe for notifications (phone) [CHAR LIMIT=160]-->
    <string name="fingerprint_swipe_for_notifications_summary" product="default">To check your notifications, swipe down on the fingerprint sensor on the back of your phone</string>
    <!-- Summary text for fingerprint swipe for notifications (tablet) [CHAR LIMIT=160]-->
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet">To check your notifications, swipe down on the fingerprint sensor on the back of your tablet</string>
    <!-- Summary text for fingerprint swipe for notifications (device) [CHAR LIMIT=160]-->
    <string name="fingerprint_swipe_for_notifications_summary" product="device">To check your notifications, swipe down on the fingerprint sensor on the back of your device</string>

    <!-- Switch text for each gesture setting state -->
    <string name="gesture_setting_on">On</string>
    <string name="gesture_setting_off">Off</string>

    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because the bootloader has been unlocked [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked">Bootloader is already unlocked</string>
    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because there is no connectivity. [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_connectivity">Connect to the Internet first</string>
    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because there is no connectivity or the device is locked by the carrier [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked">Connect to the Internet or contact your carrier</string>
    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because this setting is unavailable on sim-locked devices. [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device">Unavailable on carrier-locked devices</string>

    <string name="automatic_storage_manager_freed_bytes"><xliff:g id="size" example="3.25MB">%1$s</xliff:g> total made available\n\nLast ran on <xliff:g id="date" example="Jan 12">%2$s</xliff:g></string>

    <!-- Dropdown preference title for dropdown describing how many days of downloads to retain.-->
    <string name="automatic_storage_manager_downloads_days_title">Remove downloads</string>

    <!-- Preference title for downloads backup toggle. [CHAR LIMIT=60]-->
    <string name="downloads_backup_preference_title">Downloads backup</string>

    <!-- Used as wall of text to describe the feature. [CHAR LIMIT=NONE] -->
    <string name="downloads_backup_text"></string>

    <!-- Title text for enabling web actions. [CHAR_LIMIT=60] -->
    <string name="web_action_enable_title">Open links in apps</string>

    <!-- Summary text for enabling web actions. [CHAR_LIMIT=250] -->
    <string name="web_action_enable_summary">Open links in supported apps, even if the
      apps aren’t installed on your device</string>

    <!-- Section title for the Web Action preference [CHAR LIMIT=60] -->
    <string name="web_action_section_title">Apps not installed</string>

    <!-- Section title for the Domain URL app preference list [CHAR LIMIT=60]-->
    <string name="domain_url_section_title">Installed apps</string>

    <!-- Warning when activating the automatic storage manager on legacy devices. [CHAR LIMIT=NONE] -->
    <string name="automatic_storage_manager_activation_warning">Your storage is now being managed by the storage manager</string>

    <!-- Accounts for section header [CHAR LIMIT=30] -->
    <string name="account_for_section_header">Accounts</string>

    <!-- Configure section header [CHAR LIMIT=30] -->
    <string name="configure_section_header">Configure</string>

    <!-- Switch label to enable auto sync account [CHAR LIMIT=30] -->
    <string name="auto_sync_account_title">Auto sync account data</string>
    <!-- Switch label to enable auto sync personal account [CHAR LIMIT=30] -->
    <string name="auto_sync_personal_account_title">Auto sync personal account data</string>
    <!-- Switch label to enable auto sync work account [CHAR LIMIT=30] -->
    <string name="auto_sync_work_account_title">Auto sync work account data</string>

</resources>
