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

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

    <!-- [CHAR LIMIT=NONE] Toast message when user attemps to launch developer otions before enabling it. -->
    <string name="dev_settings_disabled_warning">Please enable developer options first.</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. System (Updates, data, accessibility, about phone). [CHAR LIMIT=40] -->
    <string name="header_category_system">System</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_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>

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

    <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 brightness 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. [CHAR LIMIT=NONE] -->
    <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 device?</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles" product="default">Your phone will disconnect from "<xliff:g id="device_name">%1$s</xliff:g>."</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles" product="tablet">Your tablet will disconnect from "<xliff:g id="device_name">%1$s</xliff:g>."</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles" product="device">Your device will disconnect from "<xliff:g id="device_name">%1$s</xliff:g>."</string>
    <!-- dialog ok button for disconnect dialog [CHAR LIMIT=20] -->
    <string name="bluetooth_disconnect_dialog_ok">Disconnect</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>
    <!-- Title for bluetooth pairing item [CHAR LIMIT=60] -->
    <string name="bluetooth_pairing_pref_title">Pair new device</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 mac address message.  This message shows the bluetooth mac address for this device.  [CHAR LIMIT=120] -->
    <string name="bluetooth_footer_mac_message" product="default">Phone\'s Bluetooth address: <xliff:g id="bluetooth_mac_address">%1$s</xliff:g></string>
    <!-- Bluetooth mac address message.  This message shows the bluetooth mac address for this device.  [CHAR LIMIT=120] -->
    <string name="bluetooth_footer_mac_message" product="tablet">Tablet\'s Bluetooth address: <xliff:g id="bluetooth_mac_address">%1$s</xliff:g></string>
    <!-- Bluetooth mac address message.  This message shows the bluetooth mac address for this device.  [CHAR LIMIT=120] -->
    <string name="bluetooth_footer_mac_message" product="device">Device\'s Bluetooth address: <xliff:g id="bluetooth_mac_address">%1$s</xliff:g></string>

    <!-- Bluetooth Visibility disconnect 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 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>
    <!-- Item in bluetooth settings screen, used to show the list of received files [CHAR LIMIT=30] -->
    <string name="bluetooth_show_received_files">Received files</string>
    <!-- Item in bluetooth settings screen, used to show the list of Files received via Bluetooth [CHAR LIMIT=NONE] -->
    <string name="bluetooth_show_files_received_via_bluetooth">Files received via Bluetooth</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>

    <!-- 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">
        <xliff:g id="device_name">%1$s</xliff:g> wants to access your contacts and call history. Give access to <xliff:g id="device_name">%2$s</xliff:g>?
    </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>

    <!-- Description for bluetooth device name summary [CHAR LIMIT=none] -->
    <string name="bluetooth_device_name_summary">Visible as \u201C<xliff:g id="device_name">^1</xliff:g>\u201D to other devices</string>
    <!-- Footer description for discoverable mode in bluetooth off state [CHAR LIMIT=none] -->
    <string name="bluetooth_off_footer">Turn on Bluetooth to connect to other devices.</string>

    <!-- Title for paired device group [CHAR LIMIT=none] -->
    <string name="bluetooth_paired_device_title">Your devices</string>
    <!-- Title for pairing bluetooth device page [CHAR LIMIT=none] -->
    <string name="bluetooth_pairing_page_title">Pair new device</string>
    <!-- Summary for bluetooth item in connection detail page. (tablet)-->
    <string name="bluetooth_pref_summary" product="tablet">Allow your tablet to communicate with nearby Bluetooth devices</string>
    <!-- Summary for bluetooth item in connection detail page. (device)-->
    <string name="bluetooth_pref_summary" product="device">Allow your device to communicate with nearby Bluetooth devices</string>
    <!-- Summary for bluetooth item in connection detail page. (phone)-->
    <string name="bluetooth_pref_summary" product="default">Allow your phone to communicate with nearby Bluetooth devices</string>

    <!-- UI debug setting: Disable Bluetooth A2DP hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_a2dp_hw_offload">Disable Bluetooth A2DP hardware offload</string>
    <!-- UI debug setting: Disable Bluetooth A2DP hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title">Restart Device?</string>
    <!-- UI debug setting: Disable Bluetooth A2DP hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message">You need to restart your device to change this setting.</string>
    <!-- UI debug setting: Disable Bluetooth A2DP hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm">Restart</string>
    <!-- UI debug setting: Disable Bluetooth A2DP hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel">Cancel</string>

    <!-- Title for Bluetooth device group with media capability group [CHAR LIMIT=none]-->
    <string name="connected_device_media_device_title">Media devices</string>
    <!-- Title for Bluetooth device group with media capability group [CHAR LIMIT=none]-->
    <string name="connected_device_call_device_title">Call devices</string>
    <!-- Title for connected device group [CHAR LIMIT=none]-->
    <string name="connected_device_other_device_title">Other devices</string>
    <!-- Title for connected device group [CHAR LIMIT=none]-->
    <string name="connected_device_saved_title">Saved devices</string>
    <!-- Summary for preference to add a device [CHAR LIMIT=none]-->
    <string name="connected_device_add_device_summary">Bluetooth will turn on to pair</string>
    <!-- Title for other connection preferences [CHAR LIMIT=none]-->
    <string name="connected_device_connections_title">Connection preferences</string>
    <!-- Title for Bluetooth preference to open paired but no connection list [CHAR LIMIT=none]-->
    <string name="connected_device_previously_connected_title">Previously connected devices</string>
    <!-- Preference screen title for Bluetooth preference to open paired but no connection list [CHAR LIMIT=none]-->
    <string name="connected_device_previously_connected_screen_title">Previously connected</string>
    <!-- Toast text for hint user bluetooth is turned on [CHAR LIMIT=none]-->
    <string name="connected_device_bluetooth_turned_on_toast">Bluetooth turned on</string>

    <!-- Title to see all the previous connected devices [CHAR LIMIT=50] -->
    <string name="previous_connected_see_all">See all</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_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>

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

    <!-- 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 adjust display settings -->
    <string name="display_label">Screen</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>

    <!-- 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>
    <!-- Button label for generic apply action [CHAR LIMIT=20] -->
    <string name="apply">Apply</string>
    <!-- Button label for generic share action [CHAR LIMIT=20] -->
    <string name="share">Share</string>
    <!-- Button label for generic add action [CHAR LIMIT=20] -->
    <string name="add">Add</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>
    <!-- Wireless Settings screen title for things like Wi-Fi, bluetooth, airplane mode. -->
    <string name="wireless_networks_settings_title">Wireless &amp; networks</string>
    <!-- Main Settings screen settings summary text for the "Wireless controls" setting -->
    <string name="radio_controls_summary">Manage Wi\u2011Fi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</string>

    <!-- check box cellular data summary [CHAR LIMIT=85] -->
    <string name="cellular_data_summary">Allow data usage over mobile 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">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">Roaming charges may apply.</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, roaming charges may apply.\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, roaming charges may apply.\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>

    <!-- 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=100] -->
    <string name="date_time_auto">Use network-provided time</string>
    <!-- Date & time setting screen setting option 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_title">Use network-provided time zone</string>
    <!-- Date & time setting screen setting option summary text for the automatic 24 hour setting checkbox [CHAR LIMIT=100] -->
    <string name="date_time_24hour_auto">Use locale default</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 title for setting time format (allowing user to set device display in 12-hour format or 24-hour format) [CHAR LIMIT=30] -->
    <string name="time_format_category_title">Time format</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>
    <!-- Text hint to search region in time zone setting screen -->
    <string name="date_time_search_region">Search region</string>
    <!-- Setting option title to select region in time zone setting screen [CHAR LIMIT=30] -->
    <string name="date_time_select_region">Region</string>
    <!-- Setting option title in time zone setting screen [CHAR LIMIT=30] -->
    <string name="date_time_select_fixed_offset_time_zones">Select UTC offset</string>
    <!-- Label describing when a given time zone changes to DST or standard time -->
    <string name="zone_change_to_from_dst"><xliff:g id="time_type" example="Pacific Summer Time">%1$s</xliff:g> starts on <xliff:g id="transition_date" example="Mar 11 2018">%2$s</xliff:g>.</string>
    <!-- Label describing a exemplar location and time zone offset[CHAR LIMIT=NONE] -->
    <string name="zone_info_exemplar_location_and_offset"><xliff:g id="exemplar_location" example="Los Angeles">%1$s</xliff:g> (<xliff:g id="offset" example="GMT-08:00">%2$s</xliff:g>)</string>
    <!-- Label describing a time zone offset and name[CHAR LIMIT=NONE] -->
    <string name="zone_info_offset_and_name"><xliff:g id="time_type" example="Pacific Time">%2$s</xliff:g> (<xliff:g id="offset" example="GMT-08:00">%1$s</xliff:g>)</string>
    <!-- Label describing a time zone and changes to DST or standard time [CHAR LIMIT=NONE] -->
    <string name="zone_info_footer">Uses <xliff:g id="offset_and_name" example="Pacific Time (GMT-08:00)">%1$s</xliff:g>. <xliff:g id="dst_time_type" example="Pacific Daylight Time">%2$s</xliff:g> starts on <xliff:g id="transition_date" example="Mar 11 2018">%3$s</xliff:g>.</string>
    <!-- Label describing a time zone without DST [CHAR LIMIT=NONE] -->
    <string name="zone_info_footer_no_dst">Uses <xliff:g id="offset_and_name" example="GMT-08:00 Pacific Time">%1$s</xliff:g>. No daylight savings time.</string>
    <!-- Describes the time type "daylight savings time" (used in zone_change_to_from_dst, when no zone specific name is available) -->
    <string name="zone_time_type_dst">Daylight savings time</string>
    <!-- Describes the time type "standard time" (used in zone_change_to_from_dst, when no zone specific name is available) -->
    <string name="zone_time_type_standard">Standard time</string>
    <!-- The menu item to switch to selecting a time zone by region (default) [CHAR LIMIT=30] -->
    <string name="zone_menu_by_region">Select by region</string>
    <!-- The menu item to switch to selecting a time zone with a fixed offset (such as UTC or GMT+0200) [CHAR LIMIT=30] -->
    <string name="zone_menu_by_offset">Select by UTC offset</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">Lock after screen timeout</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 timeout</string>
    <!-- Security settings screen, setting option summary to change screen timeout, with additional explanation-->
    <string name="lock_immediately_summary_with_exception">Immediately after timeout, 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 timeout, 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 admin</string>
    <!-- Text shown for the title of the lockdown option -->
    <string name="lockdown_settings_title">Show lockdown option</string>
    <!-- Text shown for the description of the lockdown option -->
    <string name="lockdown_settings_summary">Display power button option that turns off Smart Lock, biometric unlocking, and notifications on the lock screen</string>

    <!-- Text shown for the title of the lock when trust lost option [CHAR LIMIT=40] -->
    <string name="trust_lost_locks_screen_title">Lock screen when trust is lost</string>
    <!-- Text shown for the description of the lock when trust lost option [CHAR LIMIT=NONE -->
    <string name="trust_lost_locks_screen_summary">If enabled, the device will lock when the last trust agent loses trust</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>
    <!-- Used in the location settings to control turning on/off the feature entirely -->
    <string name="location_settings_master_switch_title">Use location</string>
    <!-- Summary for Location settings when location is off [CHAR LIMIT=NONE] -->
    <string name="location_settings_summary_location_off">Off</string>
    <!-- Summary for Location settings when location is on, explaining how many apps have location permission [CHAR LIMIT=NONE]-->
    <plurals name="location_settings_summary_location_on">
        <item quantity="one">On - <xliff:g id="count">%1$d</xliff:g> app has access to location</item>
        <item quantity="other">On - <xliff:g id="count">%1$d</xliff:g> apps have access to location</item>
    </plurals>
    <!-- Location settings, loading the number of apps which have location permission [CHAR LIMIT=30] -->
    <string name="location_settings_loading_app_permission_stats">Loading\u2026</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>
    <!-- Security Settings screen setting option title for the item to take you to the encryption and credential screen -->
    <string name="encryption_and_credential_settings_title">Encryption &amp; credentials</string>
    <!-- Security Settings screen Encryption and crendential summary -->
    <string name="encryption_and_credential_settings_summary" product="default">Phone encrypted</string>
    <string name="decryption_settings_summary" product="default">Phone not encrypted</string>
    <!-- Security Settings screen Encryption and crendential summary -->
    <string name="encryption_and_credential_settings_summary" product="tablet">Device encrypted</string>
    <string name="decryption_settings_summary" product="tablet">Device not encrypted</string>
    <!-- Screen title for a list of settings controlling what to show on user's lockscreen [CHAR LIMIT=60] -->
    <string name="lockscreen_settings_title">Lock screen display</string>
    <!-- Category title for the settings that control what lockscreen shows. [CHAR LIMIT=30] -->
    <string name="lockscreen_settings_what_to_show_category">What to show</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">Privacy</string>
    <!-- Summary for settings preference disabled by administrator [CHAR LIMIT=50] -->
    <string name="disabled_by_administrator_summary">Not available</string>
    <!-- In the security screen, the header title for security statuses -->
    <string name="security_status_title">Security status</string>
    <!-- Summary for Security settings, explaining a few important settings under it [CHAR LIMIT=NONE] -->
    <string name="security_dashboard_summary_face">Screen lock, face unlock</string>
    <!-- Summary for Security settings, explaining a few important settings under it [CHAR LIMIT=NONE] -->
    <string name="security_dashboard_summary">Screen lock, fingerprint</string>
    <!-- Summary for Security settings when fingerprint is not supported [CHAR LIMIT=NONE]-->
    <string name="security_dashboard_summary_no_fingerprint">Screen lock</string>

    <!-- Face enrollment and settings --><skip />
    <!-- Message shown in summary field when face unlock is set up. [CHAR LIMIT=40] -->
    <string name="security_settings_face_preference_summary">Face added</string>
    <!-- Message shown in summary field when face unlock is not set up. [CHAR LIMIT=54] -->
    <string name="security_settings_face_preference_summary_none">Set up face unlock</string>
    <!-- Title shown for menu item that launches face settings or enrollment. [CHAR LIMIT=32] -->
    <string name="security_settings_face_preference_title">Face unlock</string>
    <!-- Title shown for menu item that launches face settings or enrollment, for work profile [CHAR LIMIT=50] -->
    <string name="security_settings_face_profile_preference_title">Face unlock for work</string>
    <!-- Introduction title shown in face enrollment education screen [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_education_title">How to set up face unlock</string>
    <!-- Introduction title shown in face enrollment education screen for accessibility [CHAR LIMI=40]-->
    <string name="security_settings_face_enroll_education_title_accessibility">Set up face unlock</string>
    <!-- Introduction title shown in face enrollment education screen to show the face unlock feature, when face unlock is disabled by device admin [CHAR LIMIT=60] -->
    <string name="security_settings_face_enroll_education_title_unlock_disabled">Use your face to authenticate</string>
    <!-- Introduction detail message shown in face education [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_education_message"></string>
    <!-- Button that takes the user to the enrollment activity [CHAR LIMIT=20] -->
    <string name="security_settings_face_enroll_education_start">Start</string>
    <!-- Button shown which shows accessibility toggles for face enrollment when clicked. [CHAR LIMIT=32] -->
    <string name="security_settings_face_enroll_introduction_accessibility">Use accessibility setup</string>
    <!-- Additional details shown when the accessibility toggle is expanded. [CHAR LIMIT=NONE]-->
    <string name="security_settings_face_enroll_introduction_accessibility_expanded"></string>
    <!-- Message shown for a toggle which when enabled, allows the user to enroll using a simpler flow for accessibility [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_accessibility_diversity"></string>
    <!-- Message shown for a toggle which when enabled, allows the user to enroll using a simpler flow for accessibility [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_accessibility_vision"></string>
    <!-- Button text to cancel enrollment from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_face_enroll_introduction_cancel">Cancel</string>
    <!-- Button text to cancel enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_face_enroll_introduction_no_thanks">No thanks</string>
    <!-- Button text to start enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_face_enroll_introduction_agree">Agree</string>
    <!-- Button text to scroll to the end of a scrollview. [CHAR LIMIT=30] -->
    <string name="security_settings_face_enroll_introduction_more">More</string>
    <!-- Introduction title shown in face enrollment to introduce the face unlock feature [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_introduction_title">Unlock with your face</string>
    <!-- Introduction title shown in face enrollment to introduce the face unlock feature, when face unlock is disabled by device admin [CHAR LIMIT=60] -->
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled">Use your face to authenticate</string>
    <!-- Introduction detail message shown in face enrollment dialog [CHAR LIMIT=NONE]-->
    <string name="security_settings_face_enroll_introduction_message">Use your face to unlock your phone, authorize purchases, or sign in to apps.</string>
    <!-- Introduction detail message shown in face enrollment dialog, when face unlock is disabled by device admin [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled">Use your face to unlock your phone or approve purchases.\n\nNote: You can\u2019t use your face to unlock this device. For more information, contact your organization\u2019s admin.</string>
    <!-- Introduction detail message shown in face enrollment screen in setup wizard. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_message_setup">Use your face to unlock your phone, authorize purchases, or sign in to apps</string>
    <!-- Introduction message shown in face enrollment that provides extra detail. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_footer_part_0"></string>
    <!-- Introduction message shown in face enrollment that provides extra detail. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_footer_part_1"></string>
    <!-- Introduction message shown in face enrollment that provides extra detail. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_footer_part_2"></string>
    <!-- Introduction message shown in face enrollment that provides extra detail. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_footer_part_3"></string>
    <!-- Title shown in face enrollment dialog [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_repeat_title">Center your face in the circle</string>
    <!-- Button text to skip enrollment of face [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_enrolling_skip">Skip</string>
    <!-- Text shown when "Add face" button is disabled -->
    <string name="face_add_max">You can add up to <xliff:g id="count" example="5">%d</xliff:g> faces</string>
    <!-- Text shown when users has enrolled a maximum number of faces [CHAR LIMIT=NONE] -->
    <string name="face_intro_error_max">You\u2019ve added the maximum number of faces</string>
    <!-- Text shown when an unknown error caused the device to be unable to add faces [CHAR LIMIT=NONE] -->
    <string name="face_intro_error_unknown">Can\u2019t add more faces</string>
    <!-- Dialog message for dialog which shows when face cannot be enrolled. [CHAR LIMIT=45] -->
    <string name="security_settings_face_enroll_error_dialog_title">Enrollment was not completed</string>
    <!-- Button text shown in face dialog shown when an error occurs during enrollment [CHAR LIMIT=22] -->
    <string name="security_settings_face_enroll_dialog_ok">OK</string>
    <!-- Dialog message for dialog which shows when face cannot be enrolled due to being idle too long. -->
    <string name="security_settings_face_enroll_error_timeout_dialog_message">Face enrollment time limit reached. Try again.</string>
    <!-- Dialog message for dialog which shows when face cannot be enrolled due to an internal error or face can't be read. -->
    <string name="security_settings_face_enroll_error_generic_dialog_message">Face enrollment didn\'t work.</string>
    <!-- Message shown in face enrollment dialog once enrollment is completed -->
    <string name="security_settings_face_enroll_finish_title">All set. Looking good.</string>
    <!-- Button text to exit face wizard after everything is done [CHAR LIMIT=15] -->
    <string name="security_settings_face_enroll_done">Done</string>
    <!-- Settings suggestion title text for re-enrolling a face. [CHAR LIMIT=50] -->
    <string name="security_settings_face_enroll_should_re_enroll_title">Improve face unlock performance</string>
    <!-- Settings suggestion subtitle text for re-enrolling a face. [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_should_re_enroll_subtitle">Set up face unlock again</string>
    <!-- Settings suggestion title text for mandatory re-enrolling of a face. [CHAR LIMIT=50] -->
    <string name="security_settings_face_enroll_must_re_enroll_title">Set up face unlock again</string>
    <!-- Settings suggestion subtitle text for mandatory re-enrolling of a face. [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_must_re_enroll_subtitle">Improve security and performance</string>
    <!-- Settings suggestion alert body title for re-enrolling a face. [CHAR LIMIT=60] -->
    <string name="security_settings_face_enroll_improve_face_alert_title">Set up face unlock</string>
    <!-- Settings suggestion alert body text for re-enrolling a face. [CHAR LIMIT=300] -->
    <string name="security_settings_face_enroll_improve_face_alert_body">Delete your current face data to set up face unlock again.\n\nThe face data used by face unlock will be permanently and securely deleted. After removal, you will need your PIN, pattern, or password to unlock your phone, sign in to apps, and confirm payments.</string>
    <!-- Title for a category shown for the face settings page. [CHAR LIMIT=20] -->
    <string name="security_settings_face_settings_use_face_category">Use face unlock for</string>
    <!-- Text shown on a toggle which allows or disallows the device to use face for unlocking the device. [CHAR LIMIT=20] -->
    <string name="security_settings_face_settings_use_face_unlock_phone">Unlocking your phone</string>
    <!-- Text shown on a toggle which allows or disallows the device to use face unlock for apps. This will be presented to the user together with the context of security_settings_face_settings_use_face_category. [CHAR LIMIT=30] -->
    <string name="security_settings_face_settings_use_face_for_apps">App sign-in \u0026 payments</string>
    <!-- Title for a category shown for the face settings page, followed by items that the user can toggle on/off to require/disable. -->
    <string name="security_settings_face_settings_require_category">Requirements for face unlock</string>
    <!-- Text shown on a toggle which disables/enables face unlock, depending if the user's eyes are open. [CHAR LIMIT=30] -->
    <string name="security_settings_face_settings_require_attention">Require eyes to be open</string>
    <!-- Text shown on the details of a toggle which disables/enables face unlock, depending if the user's eyes are open. [CHAR LIMIT=70] -->
    <string name="security_settings_face_settings_require_attention_details">To unlock the phone, your eyes must be open</string>
    <!-- When authenticating in apps, always require confirmation (e.g. confirm button) after a face is authenticated. [CHAR LIMIT=50] -->
    <string name="security_settings_face_settings_require_confirmation">Always require confirmation</string>
    <!-- When authenticating in apps, always require confirmation (e.g. confirm button) after a face is authenticated. [CHAR LIMIT=70] -->
    <string name="security_settings_face_settings_require_confirmation_details">When using face unlock in apps, always require confirmation step</string>
    <!-- Button text in face settings which removes the user's faces from the device [CHAR LIMIT=20] -->
    <string name="security_settings_face_settings_remove_face_data">Delete face data</string>
    <!-- Button text in face settings which lets the user enroll their face [CHAR LIMIT=40] -->
    <string name="security_settings_face_settings_enroll">Set up face unlock</string>
    <!-- Text shown in face settings explaining what your face can be used for. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_footer">Use face unlock to unlock your device, sign in to apps, and confirm payments.\n\nKeep in mind:\nLooking at the phone can unlock it when you don\u2019t intend to.\n\nYour phone can be unlocked by someone else if it\u2019s held up to your face.\n\nYour phone can be unlocked by someone who looks a lot like you, say, an identical sibling.</string>
    <!-- Text shown in face settings explaining what your face can be used for. Used when attention checking is not supported. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_footer_attention_not_supported">Use face unlock to unlock your device, sign in to apps, and confirm payments.\n\nKeep in mind:\nLooking at the phone can unlock it when you don\u2019t intend to.\n\nYour phone can be unlocked by someone else if it\u2019s held up to your face, even if your eyes are closed.\n\nYour phone can be unlocked by someone who looks a lot like you, say, an identical sibling.</string>
    <!-- Dialog title shown when the user removes an enrollment [CHAR LIMIT=35] -->
    <string name="security_settings_face_settings_remove_dialog_title">Delete face data?</string>
    <!-- Dialog contents shown when the user removes an enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_remove_dialog_details">The face data used by face unlock will be permanently and securely deleted. After removal, you will need your PIN, pattern, or password to unlock your phone, sign in to apps, and confirm payments.</string>
    <!-- Subtitle shown for contextual setting face enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_context_subtitle">Use face unlock to unlock your phone</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=40] -->
    <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">Use your fingerprint to unlock your phone or approve purchases.\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">Use your fingerprint to unlock your phone or approve purchases.\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">Next</string>
    <!-- Title of dialog shown when the user tries to skip setting up fingerprint after adding lock screen during initial setup. [CHAR LIMIT=30] -->
    <string name="setup_fingerprint_enroll_skip_title">Skip fingerprint?</string>
    <!-- Body text of dialog shown when the user tries to skip setting up fingerprint after adding lock screen during initial setup [CHAR LIMIT=NONE] -->
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text">Fingerprint setup only takes a minute or two. If you skip this, you can add your fingerprint later in settings.</string>
    <!-- Title of dialog shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so [CHAR LIMIT=30]-->
    <string name="lock_screen_intro_skip_title">Skip screen lock?</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 won\u2019t be turned on. You won\u2019t be able to prevent others from using this tablet if it\u2019s lost, stolen or reset.</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 won\u2019t be turned on. You won\u2019t be able to prevent others from using this device if it\u2019s lost, stolen or reset.</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 won\u2019t be turned on. You won\u2019t be able to prevent others from using this phone if it\u2019s lost, stolen or reset.</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 won\u2019t be turned on. 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 won\u2019t be turned on. 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 won\u2019t be turned on. 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>
    <!-- Button text to skip lock screen setup [CHAR LIMIT=20] -->
    <string name="skip_lock_screen_dialog_button_label">Skip</string>
    <!-- Button text to cancel lock screen skip dialog [CHAR LIMIT=20] -->
    <string name="cancel_lock_screen_dialog_button_label">Cancel</string>
    <!-- Introduction title shown in fingerprint enrollment dialog to locate the sensor [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_find_sensor_title">Touch the sensor</string>
    <!-- Message shown in fingerprint enrollment dialog to locate the sensor -->
    <string name="security_settings_fingerprint_enroll_find_sensor_message">It\u2019s on the back of your phone. Use your index finger.</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">Touch the sensor</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=40] -->
    <string name="security_settings_fingerprint_enroll_repeat_title">Lift, then touch again</string>
    <!-- Message shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_repeat_message">Keep lifting your finger to add 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">When you see this icon, use your fingerprint for identification or to approve purchases</string>
    <!-- Button text to skip enrollment of fingerprint [CHAR LIMIT=40] -->
    <string name="security_settings_fingerprint_enroll_enrolling_skip">Do it later</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>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning that they can't continue to set fingerprint. (tablet) [CHAR LIMIT=NONE] -->
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet">Protect your tablet with a screen lock option so no one will be able to use it if it is lost or stolen. You also need a screen lock option to set up fingerprint. Tap Cancel, then set a PIN, pattern, or password.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning that they can't continue to set fingerprint. (device) [CHAR LIMIT=NONE] -->
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device">Protect your device with a screen lock option so no one will be able to use it if it is lost or stolen. You also need a screen lock option to set up fingerprint. Tap Cancel, then set a PIN, pattern, or password.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning that they can't continue to set fingerprint. (default) [CHAR LIMIT=NONE] -->
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default">Protect your phone with a screen lock option so no one will be able to use it if it is lost or stolen. You also need a screen lock option to set up fingerprint. Tap Cancel, then set a PIN, pattern, or password.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning that they can't continue to set face unlock. (tablet) [CHAR LIMIT=NONE] -->
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet">By protecting your tablet with a screen lock option, no one will be able to use it if it is lost or stolen. You also need a screen lock option to set up face unlock. To go back, tap Cancel. </string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning that they can't continue to set face unlock. (device) [CHAR LIMIT=NONE] -->
    <string name="face_lock_screen_setup_skip_dialog_text" product="device">By protecting your device with a screen lock option, no one will be able to use it if it is lost or stolen. You also need a screen lock option to set up face unlock. To go back, tap Cancel. </string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning that they can't continue to set face unlock. (default) [CHAR LIMIT=NONE] -->
    <string name="face_lock_screen_setup_skip_dialog_text" product="default">By protecting your phone with a screen lock option, no one will be able to use it if it is lost or stolen. You also need a screen lock option to set up face unlock. To go back, tap Cancel.</string>
    <!-- Title of dialog shown when the user tries to skip setting up a PIN, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pin_skip_title">Skip PIN setup?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a password, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_password_skip_title">Skip password setup?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a pattern, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pattern_skip_title">Skip pattern setup?</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=NONE] -->
    <string name="security_settings_fingerprint_enroll_touch_dialog_message">Touch the sensor on the back of your phone. Use your index finger.</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">
        The screen lock option is disabled. To learn more, contact your organization\'s admin.
        <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>
    <!-- Text shown when users has enrolled a maximum number of fingerprints [CHAR LIMIT=NONE] -->
    <string name="fingerprint_intro_error_max">You\u2019ve added the maximum number of fingerprints</string>
    <!-- Text shown when an unknown error caused the device to be unable to add fingerprints [CHAR LIMIT=NONE] -->
    <string name="fingerprint_intro_error_unknown">Can\u2019t add more 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>

    <!-- Title shown in a dialog which asks the user to confirm when a single fingerprint gets deleted. [CHAR LIMIT=50]-->
    <string name="fingerprint_delete_title">Remove \'<xliff:g id="fingerprint_id" example="Fingerprint 2">%1$s</xliff:g>\'</string>

    <!-- Message shown in a dialog which asks the user to confirm when a single fingerprint gets deleted. [CHAR LIMIT=NONE]-->
    <string name="fingerprint_delete_message">Do you want to delete this fingerprint?</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>

    <!-- 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 [CHAR LIMIT=46] -->
    <string name="suggested_lock_settings_title">Secure your phone</string>

    <!-- Summary for suggested actions for screen lock (tablet) [CHAR LIMIT=55] -->
    <string name="suggested_lock_settings_summary" product="tablet">Set screen lock to protect tablet</string>
    <!-- Summary for suggested actions for screen lock (device) [CHAR LIMIT=55] -->
    <string name="suggested_lock_settings_summary" product="device">Set screen lock to protect device</string>
    <!-- Summary for suggested actions for screen lock (phone) [CHAR LIMIT=55] -->
    <string name="suggested_lock_settings_summary" product="default">Set screen lock to protect phone</string>

    <!-- Title for suggested actions for settings up a fingerprint lock [CHAR LIMIT=46] -->
    <string name="suggested_fingerprint_lock_settings_title">Add fingerprint to unlock</string>

    <!-- Summary for suggested actions for settings up a fingerprint lock (tablet) [CHAR LIMIT=55] -->
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet"></string>
    <!-- Summary for suggested actions for settings up a fingerprint lock (device) [CHAR LIMIT=55] -->
    <string name="suggested_fingerprint_lock_settings_summary" product="device"></string>
    <!-- Summary for suggested actions for settings up a fingerprint lock (phone) [CHAR LIMIT=55] -->
    <string name="suggested_fingerprint_lock_settings_summary" product="default"></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>

    <!-- Message shown when setting up screen lock, prompting user to choose the their backup screen lock method [CHAR LIMIT=NONE] -->
    <string name="lock_settings_picker_biometrics_added_security_message">For added security, set 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>

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

    <!-- Label for button in screen lock settings, allowing users to choose other types of screen locks. [CHAR LIMIT=40] -->
    <string name="setup_lock_settings_options_button_label">Screen lock options</string>

    <!-- Title for dialog in screen lock settings, allowing users to choose other types of screen locks. [CHAR LIMIT=40] -->
    <string name="setup_lock_settings_options_dialog_title">Screen lock options</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>

    <!--  Summary for PreferenceScreen to launch picker for security method when there is none [CHAR LIMIT=NONE] -->
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately"><xliff:g id="unlock_method" example="PIN">%1$s</xliff:g> / Immediately after sleep</string>

    <!--  Summary for PreferenceScreen to launch picker for security method when there is none [CHAR LIMIT=NONE] -->
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout"><xliff:g id="unlock_method" example="PIN">%1$s</xliff:g> / <xliff:g id="timeout_string">%2$s</xliff:g> after sleep</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>

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

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

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

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

    <!-- Message shown in screen lock picker while setting up the new screen lock with face unlock option. [CHAR LIMIT=NONE] -->
    <string name="face_unlock_title">You can unlock your phone using your face. 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 admin, 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>

    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock and that it requests for a strong PIN or password  [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_high_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a strong PIN or password and may not work as expected without one</string>
    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock and that it requests for a medium strength PIN or password [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_medium_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a new PIN or password and may not work as expected without one</string>
    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock and it requests for any screen lock [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_low_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a new pattern, PIN, or password and may not work as expected without one</string>
    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_none_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a new screen lock</string>


    <!-- Message shown on the lock screen when the user incorrectly enters their lock and it counts towards the max attempts before their data on the device is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_failed_attempts_before_wipe">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 device, one of its users, or a work profile is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_last_attempt_before_wipe_warning_title">Your data will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the device lock pattern before the device is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_last_pattern_attempt_before_wipe_device">If you enter an incorrect pattern on the next attempt, this device\'s data will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the device lock PIN before the device is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_last_pin_attempt_before_wipe_device">If you enter an incorrect PIN on the next attempt, this device\'s data will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the device lock password before the device is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_last_password_attempt_before_wipe_device">If you enter an incorrect password on the next attempt, this device\'s data will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the user lock pattern before the user is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_last_pattern_attempt_before_wipe_user">If you enter an incorrect pattern on the next attempt, this user will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the user lock PIN before the user is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_last_pin_attempt_before_wipe_user">If you enter an incorrect PIN on the next attempt, this user will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the user lock password before the user is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_last_password_attempt_before_wipe_user">If you enter an incorrect password on the next attempt, this user will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the work lock pattern before the work profile is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_last_pattern_attempt_before_wipe_profile">If you enter an incorrect pattern on the next attempt, your work profile and its data will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the work lock PIN before the work profile is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_last_pin_attempt_before_wipe_profile">If you enter an incorrect PIN on the next attempt, your work profile and its data will be deleted</string>
    <!-- Content of the dialog shown when the user only has one attempt left to provide the work lock password before the work profile is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_last_password_attempt_before_wipe_profile">If you enter an incorrect password on the next attempt, your work profile and its data will be deleted</string>

    <!-- Content of the dialog shown when the user has failed to provide the device lock too many times and the device is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_failed_attempts_now_wiping_device">Too many incorrect attempts. This device\'s data will be deleted.</string>
    <!-- Content of the dialog shown when the user has failed to provide the user lock too many times and the user is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_failed_attempts_now_wiping_user">Too many incorrect attempts. This user will be deleted.</string>
    <!-- Content of the dialog shown when the user has failed to provide the work lock too many times and the work profile is removed. [CHAR LIMIT=NONE] -->
    <string name="lock_failed_attempts_now_wiping_profile">Too many incorrect attempts. This work profile and its data will be deleted.</string>
    <!-- Button label to dismiss the dialog telling the user the work profile has been wiped. [CHAR LIMIT=40] -->
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss">Dismiss</string>

    <!-- Hint shown in dialog screen when password is too short -->
    <plurals name="lockpassword_password_too_short">
        <item quantity="one">Must contain at least <xliff:g id="count" example="1">%d</xliff:g> character</item>
        <item quantity="other">Must be at least <xliff:g id="count" example="3">%d</xliff:g> characters</item>
    </plurals>
    <!-- Hint shown in dialog screen when PIN is too short -->
    <plurals name="lockpassword_pin_too_short">
        <item quantity="one">PIN must contain at least <xliff:g id="count" example="1">%d</xliff:g> digit</item>
        <item quantity="other">PIN must be at least <xliff:g id="count" example="3">%d</xliff:g> digits</item>
    </plurals>

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

    <!-- Error shown in popup when password is too long -->
    <plurals name="lockpassword_password_too_long">
        <item quantity="one">Must be fewer than <xliff:g id="number" example="1">%d</xliff:g> character</item>
        <item quantity="other">Must be fewer than <xliff:g id="number" example="17">%d</xliff:g> characters</item>
    </plurals>
    <!-- Error shown in popup when PIN is too long -->
    <plurals name="lockpassword_pin_too_long">
        <item quantity="one">Must be fewer than <xliff:g id="number" example="1">%d</xliff:g> digit</item>
        <item quantity="other">Must be fewer than <xliff:g id="number" example="17">%d</xliff:g> digits</item>
    </plurals>

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

    <!-- Error shown when a user is choosing a PIN for their work phone, but what they suggest is blocked by their company's IT administrator. The user should try another PIN that's less common and more complicated. -->
    <string name="lockpassword_pin_blacklisted_by_admin">Common PINs are blocked by your IT admin. Try a different 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 <xliff:g id="count" example="3">%d</xliff:g> 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 <xliff:g id="count" example="3">%d</xliff:g> 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 <xliff:g id="count" example="3">%d</xliff:g> 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 <xliff:g id="count" example="3">%d</xliff:g> 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 <xliff:g id="count" example="3">%d</xliff:g> 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 <xliff:g id="count" example="3">%d</xliff:g> non-letter characters</item>
    </plurals>

    <plurals name="lockpassword_password_requires_nonnumerical">
        <item quantity="one">Must contain at least 1 non-numerical character</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> non-numerical 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 admin doesn\'t allow using a recent
        password</string>

    <!-- Error shown when a user is choosing a PASSWORD for their work phone, but what they suggest is blocked by their company's IT administrator. The user should try another PASSWORD that's less common and more complicated. -->
    <string name="lockpassword_password_blacklisted_by_admin">Common passwords are blocked by your IT admin. Try a different 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">Ascending, descending, or repeated sequence
        of digits isn\'t allowed</string>

    <!-- Label for Confirm button when entering PIN / password the second time. [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_label">Confirm</string>

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

    <!-- Label for ChoosePassword/PIN Clear button that clears all text entered by the user so far. -->
    <string name="lockpassword_clear_label">Clear</string>

    <!-- Toast for a failed password change attempt when the old credential has been changed. [CHAR LIMIT=120]-->
    <string name="lockpassword_credential_changed">Screen lock was already changed. Try again with the new screen lock.</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>

    <!-- Title of preference to manage device admin apps, which are used by IT admins to manage devices -->
    <string name="manage_device_admin">Device admin apps</string>

    <!-- Summary of preference to manage device admin apps, informing the user that currently no device admin apps are installed and active -->
    <string name="number_of_device_admins_none">No active apps</string>

    <!-- Summary of preference to manage device admin apps, informing the user how many device admin apps are installed and active -->
    <plurals name="number_of_device_admins">
        <item quantity="one"><xliff:g id="count">%d</xliff:g> active app</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> active apps</item>
    </plurals>

    <!-- 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 when there is no trust agents-->
    <string name="manage_trust_agents_summary">None</string>

    <!-- Summary of preference to manage device policies when there is trust agent-->
    <plurals name="manage_trust_agents_summary_on">
        <item quantity="one">1 active trust agent</item>
        <item quantity="other"><xliff:g id="count" example="3">%d</xliff:g> active trust agents</item>
    </plurals>

    <!-- 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 access to 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: 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 available devices during and after scanning. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_found_media_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>
    <!-- Bluetooth settings. Text displayed when Bluetooth is off and bluetooth scanning is turned on [CHAR LIMIT=NONE] -->
    <string name="bluetooth_scanning_on_info_message">When Bluetooth is turned on, your device can communicate with other nearby Bluetooth devices.\n\nTo improve device experience, apps and services can still scan for nearby devices at any time, even when Bluetooth is off. This can be used, for example, to improve location-based features and services. you can change this in <annotation id="link">scanning settings</annotation>.</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 connecting error message [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connect_failed">Couldn\'t connect. Try again.</string>

    <!-- Title of device details screen [CHAR LIMIT=28]-->
    <string name="device_details_title">Device details</string>
    <!-- Title of the item to show device MAC address -->
    <string name="bluetooth_device_mac_address">Device\'s Bluetooth address: <xliff:g id="address">%1$s</xliff:g></string>
    <!-- Bluetooth device details. The title of a confirmation dialog for unpairing a paired device. [CHAR LIMIT=60] -->
    <string name="bluetooth_unpair_dialog_title">Forget device?</string>

    <!--  Bluetooth device details. The body of a confirmation dialog for unpairing a paired device. -->
    <string name="bluetooth_unpair_dialog_body" product="default">Your phone will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g></string>
    <!--  Bluetooth device details. The body of a confirmation dialog for unpairing a paired device. -->
    <string name="bluetooth_unpair_dialog_body" product="tablet">Your tablet will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g></string>
    <!--  Bluetooth device details. The body of a confirmation dialog for unpairing a paired device. -->
    <string name="bluetooth_unpair_dialog_body" product="device">Your device will no longer be paired with <xliff:g id="device_name">%1$s</xliff:g></string>

    <!--  Bluetooth device details. The body of a confirmation dialog for unpairing a paired device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_untethered_unpair_dialog_body"><xliff:g id="device_name" example="Jack's headphone">%1$s</xliff:g> will no longer be paired with any device linked to this account</string>

    <!--  Bluetooth device details. In the confirmation dialog for unpairing a paired device, this is the label on the button that will complete the unpairing action. -->
    <string name="bluetooth_unpair_dialog_forget_confirm_button">Forget device</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>

    <!-- Bluetooth developer settings: Maximum number of connected audio devices -->
    <string name="bluetooth_max_connected_audio_devices_string">Maximum connected Bluetooth audio devices</string>
    <!-- Bluetooth developer settings: Maximum number of connected audio devices -->
    <string name="bluetooth_max_connected_audio_devices_dialog_title">Select maximum number of connected Bluetooth audio devices</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>
    <!-- Wifi Sign in text for button [CHAR LIMIT = 40]-->
    <string name="wifi_sign_in_button_text">Sign in</string>
    <!-- Text for button to go to Wifi venue information webpage when Wifi is a captive portal [CHAR LIMIT=40]-->
    <string name="wifi_venue_website_button_text">Open site</string>
    <!-- Text shown in wifi settings indicating how much time is left on an internet access point that has a time limit for the session [CHAR LIMIT=40] -->
    <string name="wifi_time_remaining"><xliff:g id="Remaining time" example="1 day, 2 hours, 3 minutes">%1$s</xliff:g> left</string>
    <!-- Text shown in wifi settings indicating at what time the connection will expire on an internet access point that has a time limit for the session [CHAR LIMIT=40] -->
    <string name="wifi_expiry_time">Expires on <xliff:g id="Expiry time" example="2020/01/02 12:34PM">%1$s</xliff:g></string>
    <!-- Wifi Sign in CTA for wifi settings when captive portal auth is required [CHAR LIMIT = 50] -->
    <string name="wifi_tap_to_sign_in">Tap here to sign in to network</string>
    <!-- Transmit Link speed on Wifi Status screen [CHAR LIMIT=32] -->
    <string name="tx_link_speed"><xliff:g id="Transmit link speed" example="150 Mbps">%1$d</xliff:g> Mbps</string>
    <!-- Receive Link speed on Wifi Status screen [CHAR LIMIT=32] -->
    <string name="rx_link_speed"><xliff:g id="Receive link speed" example="54 Mbps">%1$d</xliff:g> Mbps</string>
    <!-- Link speed on Wifi Status screen [CHAR LIMIT=32] -->
    <string name="link_speed"><xliff:g id="Link speed" example="54 Mbps">%1$d</xliff:g> 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>

    <!-- Debugging developer settings: Enable ART verifier for Debuggable Apps [CHAR LIMIT=67] -->
    <string name="art_verifier_for_debuggable_title">Verify bytecode of debuggable apps</string>
    <!-- Debugging developer settings: Enable ART verifier for Debuggable Apps [CHAR LIMIT=NONE] -->
    <string name="art_verifier_for_debuggable_summary">Allow ART to verify bytecode for debuggable apps</string>

    <!-- Debugging developer settings: show refresh rate? [CHAR LIMIT=36] -->
    <string name="show_refresh_rate">Show refresh rate</string>
    <!-- Debugging developer settings: show refresh rate summary [CHAR LIMIT=58] -->
    <string name="show_refresh_rate_summary">Show the current display refresh rate</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 an NFC 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 an NFC 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 in the settings screen to secure NFC [CHAR LIMIT=NONE] -->
    <string name="nfc_secure_settings_title">Require device unlock for NFC</string>
    <!-- Description of Secure NFC in the 1st level settings screen. [CHAR LIMIT=NONE] -->
    <string name="nfc_secure_toggle_summary" product="default">Allow NFC Payment and Transit use only when screen is unlocked</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="nfc_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 web pages, YouTube videos, 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>

    <!-- Used in the Wi-Fi settings screen to control turning on/off Wi-Fi entirely [CHAR LIMIT=30]-->
    <string name="wifi_settings_master_switch_title">Use 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 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">Open network notification</string>
    <!-- Checkbox summary for option to notify user when open networks are nearby-->
    <string name="wifi_notify_open_networks_summary">Notify when a high\u2011quality public network is available</string>
    <!-- Checkbox title for option to enable Wi-Fi when saved networks are nearby -->
    <string name="wifi_wakeup">Turn on Wi\u2011Fi automatically</string>
    <!-- Checkbox summary for option to enable Wi-Fi when high quality saved networks are nearby-->
    <string name="wifi_wakeup_summary">Wi\u2011Fi will turn back on near high\u2011quality saved networks, like your home network</string>
    <!-- Checkbox summary for auto-wifi when user needs to enable location scanning to toggle it -->
    <string name="wifi_wakeup_summary_no_location">Unavailable because location is turned off. Turn on <annotation id="link">location</annotation>.</string>
    <!-- Checkbox summary for Wi-Fi wakeup option to explain that Wi-Fi wakeup is disabled because Wi-Fi scanning is turned off -->
    <string name="wifi_wakeup_summary_scanning_disabled">Unavailable because Wi\u2011Fi scanning is turned off</string>
    <!-- Checkbox summary for Wi-Fi wakeup option to explain that a network rating provider needs to be selected to use the feature. -->
    <string name="wifi_wakeup_summary_scoring_disabled">To use, select a network rating provider</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="use_open_wifi_automatically_title">Connect to open networks</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically  [CHAR LIMIT=100] -->
    <string name="use_open_wifi_automatically_summary">Automatically connect to high\u2011quality public networks</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically, to explain that a network rating provider needs to be selected to use the feature. -->
    <string name="use_open_wifi_automatically_summary_scoring_disabled">To use, select a network rating provider</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically, to explain that a compatible network rating provider needs to be selected to use the feature. -->
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled">To use, select a compatible network rating provider</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 and Wi-Fi
      scanning is on. 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, apps and services can still scan for Wi\u2011Fi networks at any time, even when Wi\u2011Fi is off. This can be used, for example, to improve location-based features and services. 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>
    <!-- Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off and Wi-Fi
      scanning is also 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_scanning_off">To improve location accuracy,
        turn on Wi-Fi scanning 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 mobile 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 mobile data automatically</string>
    <!-- Preference summary to automatically switch away from bad wifi networks [CHAR LIMIT=None]-->
    <string name="wifi_cellular_data_fallback_summary">Use mobile data when Wi\u2011Fi has no internet access. Data usage charges may apply.</string>
    <!-- Action bar text message to manually add a wifi network [CHAR LIMIT=20]-->
    <string name="wifi_add_network">Add network</string>
    <!-- Action bar title to open additional Wi-Fi settings-->
    <string name="wifi_configure_settings_preference_title">Wi\u2011Fi preferences</string>
    <!-- Summary for Wi-Fi Preferences that explains that Wi-Fi will be enabled when high quality saved networks are nearby-->
    <string name="wifi_configure_settings_preference_summary_wakeup_on">Wi\u2011Fi turns back on automatically</string>
    <!-- Summary for Wi-Fi Preferences that explains that Wi-Fi will not automatically be enabled when high quality saved networks are nearby-->
    <string name="wifi_configure_settings_preference_summary_wakeup_off">Wi\u2011Fi doesn\u0027t turn back on automatically</string>
    <!-- Header for the list of wifi networks-->
    <string name="wifi_access_points">Wi\u2011Fi networks</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 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>
    <!-- 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. 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>
    <!-- Wi-Fi settings dialog. Title of dialog displayed asking user to enable Wi-Fi Scanning [CHAR LIMIT=60]-->
    <string name="wifi_settings_scanning_required_title">Turn on Wi\u2011Fi scanning?</string>
    <!-- Wi-Fi settings dialog. Summary text describing why we need Wi-Fi scanning on. [CHAR LIMIT=NONE]-->
    <string name="wifi_settings_scanning_required_summary">To turn on Wi\u2011Fi automatically, you first need to turn on Wi\u2011Fi scanning.</string>
    <!-- Wi-Fi settings dialog. Informational text describing what Wi-Fi scanning does. [CHAR LIMIT=NONE]-->
    <string name="wifi_settings_scanning_required_info">Wi\u2011Fi scanning allows apps and services to scan for Wi\u2011Fi networks at any time, even when Wi\u2011Fi is off. This can be used, for example, to improve location\u2011based features and services.</string>
    <!-- Wi-Fi settings dialog. Text for the button that takes users to a help article about Wi-Fi scanning. [CHAR LIMIT = 20]-->
    <string name="wifi_settings_scanning_required_turn_on">Turn on</string>
    <!-- Wi-Fi settings dialog. Text to show in toast for when user turns on wifi scanning. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_scanning_required_enabled">Wi\u2011Fi scanning turned on</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 focus on Advanced Options[CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description">Drop down list Advanced Options</string>
    <!-- Extended message for talkback to say when Advanced Options is collapsed. (e.g., Double-tap to expand) [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description_collapsed">expand</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 hidden network status of this network -->
    <string name="wifi_hidden_network">Hidden network</string>
    <!-- Label for the warning shown to users if they try to connect to a network as "hidden" -->
    <string name="wifi_hidden_network_warning">If your router is not broadcasting a network ID but you would like to connect to it in the future, you can set the network as hidden.\n\nThis may create a security risk because your phone will regularly broadcast its signal to find the network.\n\nSetting the network as hidden will not change your router settings.</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 transmit link speed of the connection. [CHAR LIMIT=32] -->
    <string name="tx_wifi_speed">Transmit link speed</string>
    <!-- Label for the receive link speed of the connection. [CHAR LIMIT=32] -->
    <string name="rx_wifi_speed">Receive link speed</string>
    <!-- Label for the link speed of the connection. [CHAR LIMIT=32] -->
    <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 OCSP type of the network. [CHAR LIMIT=32] -->
    <string name="wifi_eap_ocsp">Online Certificate Status</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 channel automatically-->
    <string name="wifi_ap_choose_auto">Auto</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 only choose wifi ap 5GHz band -->
    <string name="wifi_ap_choose_5G">5.0 GHz Band</string>
    <!-- Label for the radio button to prefer 5GHz wifi ap band  [CHAR LIMIT=80]-->
    <string name="wifi_ap_prefer_5G">5.0 GHz Band preferred</string>
    <!-- Label for adding to the list of selected bands when 2.4 GHz is selected -->
    <string name="wifi_ap_2G">2.4 GHz</string>
    <!-- Label for adding to the list of selected bands when 5.0 GHz is selected -->
    <string name="wifi_ap_5G">5.0 GHz</string>
    <!-- Label that is shown as a dialog summary informing users they must pick at LEAST one band for their hotspot [CHAR LIMIT=NONE]-->
    <string name="wifi_ap_band_select_one">Choose at least one band for Wi\u2011Fi hotspot:</string>
    <!-- Label for the spinner to show ip settings [CHAR LIMIT=25] -->
    <string name="wifi_ip_settings">IP settings</string>
    <!-- Label for the spinner to show Wifi MAC randomization [CHAR LIMIT=25] -->
    <string name="wifi_privacy_settings">Privacy</string>
    <!-- Label for the subscription preference. [CHAR LIMIT=32] -->
    <string name="wifi_subscription">Subscription</string>
    <!-- Summary text for the subscription preference. [CHAR LIMIT=NONE] -->
    <string name="wifi_subscription_summary">View or change subscription</string>
    <!-- Summary for Wifi MAC randomization option when it is ephemeral network [CHAR LIMIT=50] -->
    <string name="wifi_privacy_settings_ephemeral_summary">Randomized MAC</string>
    <!-- Title for the fragment to add a device into the wifi network [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_add_device_to_network">Add a device</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=120] -->
    <string name="wifi_dpp_center_qr_code">Center the QR code below to add the device to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Title for the fragment to scan QR code [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_scan_qr_code">Scan QR code</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_qr_code_join_network">Center the QR code below to connect to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_qr_code_join_unknown_network">Join Wi\u2011Fi by scanning a QR code</string>
    <!-- Title for the fragment to share Wi-Fi [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_share_wifi">Share Wi\u2011Fi</string>
    <!-- Hint for the user to use another device to scan QR code on screen to join Wi-Fi [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_qr_code_with_another_device">Scan this QR code to connect to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d and share the password</string>
    <!-- Hint for the user to use another device to scan QR code on screen to join a open Wi-Fi [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device">Scan this QR code to connect to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_authentication_or_configuration">Try again. If the issue continues, contact the device manufacturer</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_not_compatible">Something went wrong</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_timeout">Make sure the device has been plugged in, charged, and turned on</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_generic">Make sure the device has been plugged in, charged, and turned on. If the issue continues, contact the device manufacturer</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_not_supported">Adding \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d isn\u2019t supported by this device</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_cannot_find_network">Try moving the device closer to your Wi\u2011Fi access point/router</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_enrollee_authentication">Check the password and try again</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_enrollee_rejected_configuration">Contact the device manufacturer</string>
    <!-- Hint for Wi-Fi connection fail [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_check_connection_try_again">Check connection and try again</string>
    <!-- Title for the fragment choose network [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_choose_network">Choose network</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_choose_network_to_connect_device">To connect your device, choose a network</string>
    <!-- Hint for the user to add the device to a Wi-Fi network [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_add_device_to_wifi">Add this device to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d?</string>
    <!-- Title for the fragment to tell the user that Wi-Fi shared with device successfully [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_wifi_shared_with_device">Wi\u2011Fi shared with device</string>
    <!-- Button label to add another device to Wi-Fi [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_add_another_device">Add another device</string>
    <!-- Button label to choose different Wi-Fi network [CHAR LIMIT=80]  -->
    <string name="wifi_dpp_choose_different_network">Choose different network</string>
    <!-- Hint for QR code detection [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_could_not_add_device">Couldn\u2019t add device</string>
    <!-- Title for the fragment to show that device found but naming known [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_device_found">Device found</string>
    <!-- Hint for Wi-Fi DPP handshake running [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_sharing_wifi_with_this_device">Sharing Wi\u2011Fi with this device\u2026</string>
    <!-- Hint for Wi-Fi DPP handshake running [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_connecting">Connecting\u2026</string>
    <!-- Title for the fragment to show that the QR code is for sharing Wi-Fi hotspot network [CHAR LIMIT=50] -->
    <string name="wifi_dpp_share_hotspot">Share hotspot</string>
    <!-- Title for Wi-Fi DPP lockscreen title [CHAR LIMIT=50] -->
    <string name="wifi_dpp_lockscreen_title">Verify that it\u0027s you</string>
    <!-- Hint for Wi-Fi password [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_wifi_password">Wi\u2011Fi password: <xliff:g id="password" example="my password">%1$s</xliff:g></string>
    <!-- Hint for Wi-Fi hotspot password [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_hotspot_password">Hotspot password: <xliff:g id="password" example="my password">%1$s</xliff:g></string>
    <!-- Label for a Wi-Fi network to specify if the device will auto connect to the Wi-Fi network
         when signal of the Wi-Fi network is reachable [CHAR LIMIT=50]  -->
    <string name="wifi_auto_connect_title">Auto\u2011connect</string>
    <!-- Hint for Wi-Fi Auto-connect [CHAR LIMIT=NONE]  -->
    <string name="wifi_auto_connect_summary" product="default">Allow phone to automatically connect near this network</string>
    <!-- Hint for Wi-Fi Auto-connect [CHAR LIMIT=NONE]  -->
    <string name="wifi_auto_connect_summary" product="tablet">Allow tablet to automatically connect near this network</string>
    <!-- Label for "Use a QR code to add a device to this network" [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_add_device">Add device</string>
    <!-- Hint for "Add device" [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_connect_network_using_qr_code">Use a QR code to add a device to this network</string>
    <!-- Hint for QR code process failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_qr_code_is_not_valid_format">QR code isn\u0027t a valid format</string>
     <!-- Label for the try again button [CHAR LIMIT=20]-->
    <string name="retry">Retry</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 network name (ssid) is too long -->
    <string name="wifi_ssid_too_long">Network name is too long.</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>
    <!-- Warning message displayed if user does not specify a user certification for
         WPA3-Enterprise 192-bit. Only displayed if the user does not specify user certificate
         for WPA3-Enterprise 192-bit [CHAR LIMIT=80]-->
    <string name="wifi_no_user_cert_warning">Certificate required.</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 dialog when the user tries to connect to a carrier network[CHAR_LIMIT=40] -->
    <string name="wifi_carrier_connect">Carrier Wi\u2011Fi network</string>
    <!-- Message in dialog when the user tries to connect to a carrier network[CHAR_LIMIT=60] -->
    <string name="wifi_carrier_content">Connect via <xliff:g id="name">%1$s</xliff:g></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 to inform user, an unknown app want to enable network scanning.  [CHAR LIMIT=250] -->
    <string name="wifi_scan_always_turn_on_message_unknown">To improve location accuracy and for other purposes, an unknown app wants to turn on network scanning, even when Wi\u2011Fi 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>
    <!-- Dialog text to tell the user that the selected network has incomplete Internet access. [CHAR LIMIT=100] -->
    <string name="partial_connectivity_text">Some apps and services may not work due to limited connectivity. Use anyway?</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 mobile network whenever Wi\u2011Fi has a bad connection. Data usage charges may apply.</string>
    <!-- Button text to let user switch to mobile data -->
    <string name="lost_internet_access_switch">Switch to mobile</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>
    <!-- Turned on notification for Wi-Fi [CHAR LIMIT=40] -->
    <string name="wifi_turned_on_message">Wi\u2011Fi turned on</string>
    <!-- Connected to notification for Wi-Fi [CHAR LIMIT=NONE] -->
    <string name="wifi_connected_to_message">@string/bluetooth_connected_summary</string>
    <!-- Button label to connecting progress to a Wi-Fi network [CHAR LIMIT=20] -->
    <string name="wifi_connecting">Connecting\u2026</string>
    <!-- Button label to disconnect to a Wi-Fi network [CHAR LIMIT=NONE] -->
    <string name="wifi_disconnect">@string/bluetooth_device_context_disconnect</string>
    <!-- Failured notification for connect -->
    <string name="wifi_failed_connect_message">Failed to connect to network</string>
    <!-- Not in range notification for connect [CHAR LIMIT=40] -->
    <string name="wifi_not_in_range_message">Network not in range</string>
    <!-- Button label to delete a Wi-Fi network -->
    <string name="wifi_forget">Forget</string>
    <!-- Button label to modify a Wi-Fi network -->
    <string name="wifi_modify">Modify</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>
    <!-- Dialog title for forget confirmation dialog -->
    <string name="wifi_forget_dialog_title">Forget network?</string>
    <!-- Dialog message for forget confirmation dialog -->
    <string name="wifi_forget_dialog_message">All passwords for this network will be deleted</string>

    <!-- Wi-Fi Advanced Settings --> <skip />
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates the number of networks, not including passpoint network, a user has saved. [CHAR LIMIT=30] -->
    <plurals name="wifi_saved_access_points_summary">
        <item quantity="one">1 network</item>
        <item quantity="other">%d networks</item>
    </plurals>
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates the number of passpoint networks a user has saved. [CHAR LIMIT=30] -->
    <plurals name="wifi_saved_passpoint_access_points_summary">
        <item quantity="one">1 subscription</item>
        <item quantity="other">%d subscriptions</item>
    </plurals>
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates number of whole kinds networks, if there are both normal saved networks and saved passpoint networks. The number will be at least 2, so the one case is only to prevent lint error. [CHAR LIMIT=60] -->
    <plurals name="wifi_saved_all_access_points_summary">
        <item quantity="one">1 network &amp; subscription</item>
        <item quantity="other">%d networks &amp; subscriptions</item>
    </plurals>
    <!-- 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, advanced, title of the item to show the Wi-Fi device's SSID. [CHAR LIMIT=20] -->
    <string name="wifi_advanced_ssid_title">SSID</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the device's Wi-Fi MAC address. [CHAR LIMIT=50] -->
    <string name="wifi_advanced_device_mac_address_title">Device MAC address</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the randomized Wi-Fi MAC address. [CHAR LIMIT=50] -->
    <string name="wifi_advanced_randomized_mac_address_title">Randomized 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 Network Details -->
    <!-- Wifi details title-->
    <string name="wifi_details_title">Network details</string>
    <!-- Wifi details preference title to display router IP subnet mask -->
    <string name="wifi_details_subnet_mask">Subnet mask</string>
    <!-- Wifi details preference title to display router DNS info -->
    <string name="wifi_details_dns">DNS</string>
    <!-- Wifi details preference category title for IPv6 information -->
    <string name="wifi_details_ipv6_address_header">IPv6 addresses</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>
    <!-- Tab title for showing subscribed WiFi access points. [CHAR LIMIT=20] -->
    <string name="wifi_subscribed_access_points_tab">Subscriptions</string>
    <!-- Tab title for showing saved WiFi access points. -->
    <string name="wifi_saved_access_points_tab">@string/wifi_access_points</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  [CHAR LIMIT=30] -->
    <string name="wifi_hotspot_checkbox_text">Wi\u2011Fi hotspot</string>
    <!-- Summary text when turning hotspot off -->
    <string name="wifi_hotspot_off_subtext">Not sharing internet or content with other devices</string>
    <!-- Summary text when tethering is on -->
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet">Sharing this tablet\u2019s internet connection via hotspot</string>
    <!-- Summary text when tethering is on -->
    <string name="wifi_hotspot_tethering_on_subtext" product="default">Sharing this phone\u2019s internet connection via hotspot</string>
    <!-- Summary text when hotspot is on for local-only -->
    <string name="wifi_hotspot_on_local_only_subtext">App is sharing content. To share internet connection, turn hotspot off, then on</string>
    <!-- Summary text when no password is set [CHAR LIMIT=60] -->
    <string name="wifi_hotspot_no_password_subtext">No password set</string>

    <!-- Wifi hotspot settings -->
    <!-- Label for Wifi hotspot name. -->
    <string name="wifi_hotspot_name_title">Hotspot name</string>
    <!-- Summary for Wifi hotspot name when connection is in progress. -->
    <string name="wifi_hotspot_name_summary_connecting">Turning on <xliff:g id="wifi_hotspot_name">%1$s</xliff:g>...</string>
    <!-- Summary for Wifi hotspot name when connected. -->
    <string name="wifi_hotspot_name_summary_connected">Other devices can connect to <xliff:g id="wifi_hotspot_name">%1$s</xliff:g></string>
    <!-- Label for Wifi hotspot password. -->
    <string name="wifi_hotspot_password_title">Hotspot password</string>
    <!-- Label for Wifi hotspot AP Band. -->
    <string name="wifi_hotspot_ap_band_title">AP Band</string>
    <!-- Wifi hotspot footer info for regular hotspot [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_footer_info_regular">Use hotspot to create a Wi\u2011Fi network for your other devices. Hotspot provides internet using your mobile data connection. Additional mobile data charges may apply.</string>
    <!-- Wifi hotspot footer info [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_footer_info_local_only">Apps can create a hotspot to share content with nearby devices.</string>

    <!-- Title for the toggle to turn off hotspot automatically [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_auto_off_title">Turn off hotspot automatically</string>
    <!-- Summary for the toggle to turn off hotspot automatically [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_auto_off_summary">When no devices are connected</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"><xliff:g id="network_ssid">%1$s</xliff:g> is 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 hotspot</string>
    <!-- Default access point SSID used for tethering -->
    <string name="wifi_tether_configure_ssid_default">AndroidHotspot</string>
    <!-- Title for the panel of add Wi-Fi network from APP [CHAR LIMIT=50] -->
    <string name="wifi_add_app_single_network_title">Save this network?</string>
    <!-- Summary for the panel of add Wi-Fi network from APP [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_single_network_summary" product="default"><xliff:g id="appName" example="ThirdPartyAppName">%1$s</xliff:g> wants to save a network to your phone</string>
    <!-- Summary for the panel of add Wi-Fi network from APP [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_single_network_summary" product="tablet"><xliff:g id="appName" example="ThirdPartyAppName">%1$s</xliff:g> wants to save a network to your tablet</string>
    <!-- Summary for saving status when saving single network [CHAR LIMIT=30] -->
    <string name="wifi_add_app_single_network_saving_summary">Saving\u2026</string>
    <!-- Summary for saved status when saving single network   [CHAR LIMIT=30] -->
    <string name="wifi_add_app_single_network_saved_summary">Saved</string>
    <!-- Summary for save failed status when saving single network [CHAR LIMIT=50] -->
    <string name="wifi_add_app_network_save_failed_summary">Can\u2019t save. Try again.</string>
    <!--  Title for the panel of add multiple Wi-Fi networks from APP [CHAR LIMIT=50] -->
    <string name="wifi_add_app_networks_title">Save networks?</string>
    <!-- Summary for the panel of add multiple Wi-Fi networks from APP [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_networks_summary" product="default"><xliff:g id="appName" example="ThirdPartyAppName">%1$s</xliff:g> wants to save these networks to your phone</string>
    <!-- Summary for the panel of add multiple Wi-Fi networks from APP [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_networks_summary" product="tablet"><xliff:g id="appName" example="ThirdPartyAppName">%1$s</xliff:g> wants to save these networks to your tablet</string>
    <!-- Summary for the panel of add Wi-Fi networks from APP [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_networks_saving_summary">Saving <xliff:g id="number" example="3">%d</xliff:g> networks\u2026</string>
    <!-- Summary for saved status when saving multiple networks   [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_networks_saved_summary">Networks saved</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="tx_link_speed_label" translatable="false">Transmit link speed:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="rx_link_speed_label" translatable="false">Receive 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=46] -->
    <string name="wifi_calling_suggestion_title">Extend calls with Wi\u2011Fi</string>
    <!-- Summary of suggestion to turn on wifi calling [CHAR LIMIT=55] -->
    <string name="wifi_calling_suggestion_summary">Turn on Wi\u2011Fi calling to extend coverage</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">Calling preference</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" translatable="false">
        <item>@*android:string/wfc_mode_wifi_preferred_summary</item>
        <item>@*android:string/wfc_mode_cellular_preferred_summary</item>
        <item>@*android:string/wfc_mode_wifi_only_summary</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_v2">
        <item>Wi-Fi</item>
        <item>Mobile</item>
        <item>Wi-Fi only</item>
    </string-array>
    <string-array name="wifi_calling_mode_values" translatable="false">
        <item>"2"</item>
        <item>"1"</item>
        <item>"0"</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_without_wifi_only" translatable="false">
        <item>@*android:string/wfc_mode_wifi_preferred_summary</item>
        <item>@*android:string/wfc_mode_cellular_preferred_summary</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
        <item>Wi-Fi</item>
        <item>Mobile</item>
    </string-array>
    <string-array name="wifi_calling_mode_values_without_wifi_only" translatable="false">
        <item>"2"</item>
        <item>"1"</item>
    </string-array>

    <!-- Summary of WFC preference item on the WFC preference selection dialog. [CHAR LIMIT=70]-->
    <string name="wifi_calling_mode_wifi_preferred_summary">If Wi\u2011Fi is unavailable, use mobile network</string>
    <!-- Summary of WFC preference item on the WFC preference selection dialog. [CHAR LIMIT=70]-->
    <string name="wifi_calling_mode_cellular_preferred_summary">If mobile network is unavailable, use Wi\u2011Fi</string>
    <!-- Summary of WFC preference item on the WFC preference selection dialog. [CHAR LIMIT=70]-->
    <string name="wifi_calling_mode_wifi_only_summary">Call over Wi\u2011Fi. If Wi\u2011Fi is lost, call will end.</string>

    <!-- 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.<xliff:g id="additional_text" example="Learn More">%1$s</xliff:g></string>
    <!-- Wi-Fi Calling settings. Additional text displayed when Wi-Fi Calling is off. Default empty. [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_off_explanation_2"></string>
    <!-- Title of a preference for updating emergency address [CHAR LIMIT=40] -->
    <string name="emergency_address_title">Emergency Address</string>
    <!-- Summary of Update Emergency Address preference, explaining usage of emergency address [CHAR LIMIT=NONE] -->
    <string name="emergency_address_summary">Used as your location when you make an emergency call over Wi\u2011Fi</string>
    <!-- Message of private dns that provides a help link. [CHAR LIMIT=NONE] -->
    <string name="private_dns_help_message"><annotation id="url">Learn more</annotation> about Private DNS features</string>
    <!-- Message to display when private dns is on. [CHAR LIMIT=10] -->
    <string name="private_dns_mode_on">On</string>

    <!-- Message to display when setting wifi calling are not editable [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_pref_managed_by_carrier">Setting managed by carrier</string>
    <!-- Message to display when wifi calling needs activation [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_settings_activation_instructions">Activate Wi\u2011Fi Calling</string>
    <!-- Message to display when wifi calling should be on [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_turn_on">Turn on Wi\u2011Fi calling</string>
    <!-- Message to display when carrier does not support wifi calling or doesn't want the user
         to modify the settings [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_not_supported">Wi\u2011Fi calling is not supported for %1$s</string>
    <!-- Hint for a Wi-Fi network is disconnected successfully [CHAR LIMIT=NONE] -->
    <string name="wifi_disconnected_from">Disconnected from <xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g></string>
    <!-- Carrier string to use in other messages -->
    <string name="carrier">Carrier</string>
    <!-- Sound and alerts settings -->
    <skip/>
    <string name="display_settings_title">Display</string>
    <!-- Sound settings screen heading -->
    <string name="sound_settings">Sound</string>
    <!-- DO NOT TRANSLATE Summary placeholder -->
    <string name="summary_placeholder" translatable="false">&#160;</string>
    <!-- DO NOT TRANSLATE Summary placeholder reserving 2 lines -->
    <string name="summary_two_lines_placeholder" translatable="false">&#160;\n&#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 &amp; notification 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 launcher does not support work profiles [CHAR LIMIT=100] -->
    <string name="home_work_profile_not_supported">Doesn\'t 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 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>

    <!-- 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>
    <!-- Display settings screen, Color mode settings title [CHAR LIMIT=30] -->
    <string name="color_mode_title">Colors</string>
    <!-- Display settings screen, Color mode option for "natural(sRGB) color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_natural">Natural</string>
    <!-- Display settings screen, Color mode option for "Boosted(sRGB + 10%) color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_boosted">Boosted</string>
    <!-- Display settings screen, Color mode option for "Saturated color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_saturated">Saturated</string>
    <!-- Display settings screen, Color mode option for "Adaptive color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_automatic">Adaptive</string>
    <!-- Display settings screen, "natural(sRGB) color" setting option summary [CHAR LIMIT=NONE] -->
    <string name="color_mode_summary_natural">Use accurate colors only</string>
    <!-- Display settings screen, "Adaptive color" setting option summary [CHAR LIMIT=NONE] -->
    <string name="color_mode_summary_automatic">Adjust between vivid and accurate colors</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>
    <!-- Summary about the feature adaptive brightness [CHAR LIMIT=NONE] -->
    <string name="auto_brightness_summary">Screen brightness adjusts to environment</string>
    <!-- Setting option summary when adaptive brightness is on [CHAR LIMIT=NONE] -->
    <string name="auto_brightness_summary_on">On</string>
    <!-- Setting option summary when adaptive brightness is off [CHAR LIMIT=NONE] -->
    <string name="auto_brightness_summary_off">Off</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is very low [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_very_low">Preferred brightness is very low</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is low [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_low">Preferred brightness is low</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is the default [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_default">Preferred brightness is default</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is high [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_high">Preferred brightness is high</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is very high [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_very_high">Preferred brightness is very high</string>
    <!-- Adaptive brightness settings screen, setting option to disable adaptive brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_off_title">Off</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers very low brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_very_low_title">Very low</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers low brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_low_title">Low</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers default brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_default_title">Default</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers high brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_high_title">High</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers very high brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_very_high_title">Very high</string>
    <!-- Adaptive brightness settings screen, subtitle [CHAR LIMIT=100] -->
    <string name="auto_brightness_subtitle">Your preferred brightness level</string>
    <!-- Adaptive brightness settings screen, setting option summary to disable adaptive brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_off_summary">Don\'t adjust for available light</string>
    <!-- Adaptive brightness settings screen, setting option summary to enable adaptive brightness when user prefers very high brightness.
         Meant to make it clear that preferring very high brightness uses more battery. [CHAR LIMIT=100] -->
    <string name="auto_brightness_very_high_summary">Increased battery usage</string>
    <!-- Adaptive brightness settings screen, disclaimer that explains in more detail about how adaptive brightness works [CHAR LIMIT=150] -->
    <string name="auto_brightness_disclaimer">Optimize brightness level for available light. When this feature is on, you can still adjust brightness temporarily.</string>
    <!-- Description about the feature adaptive brightness -->
    <string name="auto_brightness_description">Your screen brightness will automatically adjust to your environment and activities. You can move the slider manually to help adaptive brightness learn your preferences.</string>

    <!-- Display settings screen, display white balance settings title [CHAR LIMIT=30] -->
    <string name="display_white_balance_title">Display white balance</string>
    <!-- Display settings screen, display white balance settings summary [CHAR LIMIT=NONE] -->
    <string name="display_white_balance_summary"></string>
    <!-- Display settings screen, setting option name to enable adaptive sleep [CHAR LIMIT=30] -->
    <string name="adaptive_sleep_title">Screen attention</string>
    <!-- Setting option summary when adaptive sleep is on [CHAR LIMIT=NONE] -->
    <string name="adaptive_sleep_summary_on">On / Screen won\u2019t turn off if you\u2019re looking at it</string>
    <!-- Setting option summary when adaptive sleep is off [CHAR LIMIT=NONE] -->
    <string name="adaptive_sleep_summary_off">Off</string>
    <!-- adaptive_sleep settings screen, title about the required permission is missing [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_title_no_permission">Camera access needed</string>
    <!-- adaptive_sleep settings screen, subtitle when permission is missing [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_summary_no_permission">Tap to manage permissions for Device Personalization Services</string>
    <!-- Description about the feature adaptive sleep [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_description">Prevents your screen from turning off if you\u2019re looking at it</string>
    <!-- Description feature's privacy sensitive details to make sure users understand what feature users, what it saves/sends etc [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_privacy">Screen attention uses the front camera to see if someone is looking at the screen. It works on device, and images are never stored or sent to Google.</string>
    <!-- Description about the contextual adaptive sleep card [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_contextual_slice_summary">Keep screen on when viewing it</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, setting option name to configure whether night display turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_title">Schedule</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">None</string>
    <!-- Night display screen, setting option value for night display to turn on/off automatically according to a user defined schedule. [CHAR LIMIT=32] -->
    <string name="night_display_auto_mode_custom">Turns on at custom time</string>
    <!-- Night display screen, setting option value for night display to turn on/off automatically at sunset/sunrise. [CHAR LIMIT=32] -->
    <string name="night_display_auto_mode_twilight">Turns on from 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>
    <!-- Night display screen, setting option name controlling the current activation status. [CHAR LIMIT=30] -->
    <string name="night_display_status_title">Status</string>
    <!-- Night display screen, setting the color temperature of the display. [CHAR LIMIT=30] -->
    <string name="night_display_temperature_title">Intensity</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>
    <!-- Display settings screen, activation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="night_display_activation_on_manual">Turn on now</string>
    <!-- Display settings screen, deactivation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="night_display_activation_off_manual">Turn off now</string>
    <!-- Display settings screen, activation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_on_twilight">Turn on until sunrise</string>
    <!-- Display settings screen, deactivation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_off_twilight">Turn off until sunset</string>
    <!-- Display settings screen, activation button action for custom schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_on_custom">Turn on until <xliff:g name="time" example="6 AM">%1$s</xliff:g></string>
    <!-- Display settings screen, deactivation button action for custom schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_off_custom">Turn off until <xliff:g name="time" example="10 PM">%1$s</xliff:g></string>
    <!-- Night display slice screen, subtitle of intensity setting when night light is off. [CHAR LIMIT=30] -->
    <string name="night_display_not_currently_on">Night Light not currently on</string>

    <!--    Dark ui screen-->
    <!-- Display settings screen, activation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_on_manual">Turn on now</string>
    <!-- Display settings screen, deactivation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_off_manual">Turn off now</string>
    <!-- Display settings screen, activation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_on_auto">Turn on until sunrise</string>
    <!-- Display settings screen, deactivation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_off_auto">Turn off until sunset</string>
    <!-- Dark UI screen, setting option name to enable Dark UI [CHAR LIMIT=30] -->
    <string name="dark_ui_title">Dark Mode</string>
    <!-- Dark UI screen, setting option name to configure whether Dark UI turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="dark_ui_auto_mode_title">Schedule</string>
    <!-- Dark UI screen, setting option value for Dark UI to *never* turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="dark_ui_auto_mode_never">None</string>
    <!-- Dark UI screen, setting option value for Dark UI to turn on/off automatically at sunset/sunrise. [CHAR LIMIT=32] -->
    <string name="dark_ui_auto_mode_auto">Turns on from sunset to sunrise</string>
    <!-- Dark UI screen, setting option value for Dark theme to turn on/off automatically according to a user defined schedule. [CHAR LIMIT=32] -->
    <string name="dark_ui_auto_mode_custom">Turns on at custom time</string>
    <!-- Dark UI screen, setting option name controlling the current activation status. [CHAR LIMIT=30] -->
    <string name="dark_ui_status_title">Status</string>
    <!-- Display settings screen, summary format of Dark UI when off. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_off">Off / <xliff:g name="auto_mode_summary" example="Never turn on automatically">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of Dark UI when off and will *never* turn on automatically. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_off_auto_mode_never">Will never turn on automatically</string>
    <!-- Display settings screen, summary of Dark UI when off and will turn on automatically at sunset. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_off_auto_mode_auto">Will turn on automatically at sunset</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="dark_ui_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 format of Dark UI when on. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_on">On / <xliff:g name="auto_mode_summary" example="Never turn off automatically">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of Dark UI when on and will *never* turn off automatically. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_on_auto_mode_never">Will never turn off automatically</string>
    <!-- Display settings screen, summary of Dark UI when on and will turn off automatically at sunrise. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_on_auto_mode_auto">Will turn off automatically at sunrise</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="dark_ui_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, activation button action for custom schedule [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_on_custom">Turn on until <xliff:g name="time" example="6 AM">%1$s</xliff:g></string>
    <!-- Display settings screen, deactivation button action for custom schedule [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_off_custom">Turn off until <xliff:g name="time" example="10 PM">%1$s</xliff:g></string>
    <!-- Dark theme screen, description of Dark theme feature. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_text">Dark theme uses a black background to help keep battery alive longer on some screens. Dark theme schedules wait to turn on until your screen is off.</string>

    <!-- Sound & display settings screen, setting option name to change screen timeout -->
    <string name="screen_timeout">Screen timeout</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>
    <!-- Styles & Wallpapers settings title [CHAR LIMIT=30] -->
    <string name="style_and_wallpaper_settings_title">Styles &amp; wallpapers</string>
    <!-- Wallpaper settings summary when default wallpaper is used [CHAR LIMIT=NONE] -->
    <string name="wallpaper_settings_summary_default">Default</string>
    <!-- Wallpaper settings summary when wallpaper has been updated [CHAR LIMIT=NONE] -->
    <string name="wallpaper_settings_summary_custom">Custom</string>
    <!-- Wallpaper suggestion title [CHAR LIMIT=46] -->
    <string name="wallpaper_suggestion_title">Change wallpaper</string>
    <!-- Wallpaper suggestion summary [CHAR LIMIT=55] -->
    <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>
    <!-- Styles and Wallpaper settings title [CHAR_LIMIT=46] -->
    <string name="style_suggestion_title">Customize your phone</string>
    <!-- Styles and Wallpapers summary [CHAR_LIMIT=70] -->
    <string name="style_suggestion_summary">Try different styles, wallpapers, and more</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">While charging or docked</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 fragment for screen saver options, activated never  -->
    <string name="screensaver_settings_summary_never">Never</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</string>
    <!-- Dream settings screen, action label, current selected screen saver -->
    <string name="screensaver_settings_current">Current 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] Title of the preference that opens the Ambient display settings screen. -->
    <string name="ambient_display_screen_title">Ambient display</string>

    <!-- [CHAR LIMIT=30] Category title for the settings that control when Ambient display shows. -->
    <string name="ambient_display_category_triggers">When to show</string>
    <!-- [CHAR LIMIT=30] Ambient display screen, title for setting to change whether the ambient display feature is triggered for new incoming notifications. -->
    <string name="doze_title">New notifications</string>
    <!-- [CHAR LIMIT=NONE] Ambient display screen, summary for setting to change whether the ambient display feature is triggered for new incoming notifications. -->
    <string name="doze_summary">Wake screen when you receive notifications</string>
    <!-- [CHAR LIMIT=30] Display settings screen, setting option name to change whether the always-on ambient display feature is enabled. -->
    <string name="doze_always_on_title">Always on</string>
    <!-- [CHAR LIMIT=NONE] Display settings screen, setting description for the always-on ambient display feature. -->
    <string name="doze_always_on_summary">Show time, notification icons, and other info. Increased battery usage.</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 & screen lock settings screen, SIM card lock setting option name  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings_category">SIM card lock</string>
    <!-- Security & screen lock settings screen, SIM card lock setting summary when off [CHAR LIMIT=NONE] -->
    <string name="sim_lock_settings_summary_off">Off</string>
    <!-- Security & screen lock settings screen, SIM card lock setting summary when on [CHAR LIMIT=NONE] -->
    <string name="sim_lock_settings_summary_on">Locked</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, toast after disabling PIN failed from modem -->
    <string name="sim_pin_disable_failed">Can\'t disable PIN.</string>
    <!-- SIM card lock settings screen, toast after enabling PIN failed from modem -->
    <string name="sim_pin_enable_failed">Can\'t enable 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 mobile data.</string>
    <!-- Title asking user if they wish to change the default sim for cellular data.  [CHAR LIMIT=40] -->
    <string name="sim_change_data_title">
        Use <xliff:g id="carrier" example="Verizon">%1$s</xliff:g> for mobile data?
    </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">
        You\u0027re using <xliff:g id="carrier2" example="T-mobile">%2$s</xliff:g> for mobile data.
        If you switch to <xliff:g id="carrier1" example="Verizon">%1$s</xliff:g>,
        <xliff:g id="carrier2" example="T-mobile">%2$s</xliff:g> will no longer be used for mobile
        data.
    </string>
    <!-- Ok button label confirming the user wishes to change the default data SIM from one to
         another. [CHAR LIMIT=25] -->
    <string name="sim_change_data_ok">
        Use <xliff:g id="carrier" example="Verizon">%1$s</xliff:g>
    </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 mobile 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>

    <!-- 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, status item summary  [CHAR LIMIT=40] -->
    <string name="model_summary">Model&#58; %1$s</string>
    <!-- About phone screen, dialog title for showing hardware information such as model, serial number, etc.[CHAR LIMIT=60] -->
    <string name="hardware_info">Model &amp; hardware</string>
    <!-- Label for device's hardware revision value [CHAR LIMIT=40] -->
    <string name="hardware_revision">Hardware version</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, tapping this button will take user to a seperate UI to check Google Play system update [CHAR LIMIT=60] -->
    <string name="module_version">Google Play system update</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>
    <!-- Settings title that shows user how much storage and cache space an App is taking [CHAR LIMIT=50] -->
    <string name="storage_settings_for_app" >Storage &amp; cache</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>
    <!-- About phone screen, title for IMEI for multi-sim devices -->
    <string name="imei_multi_sim">IMEI (sim slot %1$d)</string>
    <!-- About phone screen, summary of the MAC address [CHAR LIMIT=80] -->
    <string name="view_saved_network">To view, choose saved network</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=40] -->
    <string name="status_number" product="tablet">MDN</string>
    <!-- About phone, status item title.  The phone number of the current device [CHAR LIMIT=40] -->
    <string name="status_number" product="default">Phone number</string>
    <!-- About tablet, status item title for multi-sim devices.  The Mobile Directory Number [CHAR LIMIT=40] -->
    <string name="status_number_sim_slot" product="tablet">MDN (sim slot %1$d)</string>
    <!-- About phone, status item title for multi-sim devices.  The phone number of the current device [CHAR LIMIT=40] -->
    <string name="status_number_sim_slot" product="default">Phone number (sim slot %1$d)</string>
    <!-- About tablet, status item title.  The Mobile Directory Number [CHAR LIMIT=30] -->
    <string name="status_number_sim_status" product="tablet">MDN on SIM</string>
    <!-- About phone, status item title.  The phone number of the current device [CHAR LIMIT=30] -->
    <string name="status_number_sim_status" product="default">Phone number on SIM</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 screen, title for MEID for multi-sim devices -->
    <string name="meid_multi_sim">MEID (sim slot %1$d)</string>
    <!-- The status text when both Wi-Fi scanning and Bluetooth scanning are on. [CHAR LIMIT=100] -->
    <string name="scanning_status_text_wifi_on_ble_on">Both Wi\u2011Fi and Bluetooth scanning are on</string>
    <!-- The status text when Wi-Fi scanning is on and Bluetooth scanning are off. [CHAR LIMIT=100] -->
    <string name="scanning_status_text_wifi_on_ble_off">Wi\u2011Fi scanning is on, Bluetooth scanning is off</string>
    <!-- The status text when Wi-Fi scanning is off and Bluetooth scanning are on. [CHAR LIMIT=100] -->
    <string name="scanning_status_text_wifi_off_ble_on">Bluetooth scanning is on, Wi\u2011Fi scanning is off</string>
    <!-- The status text when both Wi-Fi scanning and Bluetooth scanning are off. [CHAR LIMIT=100] -->
    <string name="scanning_status_text_wifi_off_ble_off">Both Wi\u2011Fi and Bluetooth scanning are off</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_data_network_type">Mobile data network type</string>
    <!-- About phone, status item title for the type of voice phone network we're connected to, for example 3G or Edge or GPRS -->
    <string name="status_voice_network_type">Mobile voice network type</string>
    <!-- About phone, status item title for the latest area info cell broadcast received (Brazil only). -->
    <string name="status_latest_area_info">Operator info</string>
    <!-- About phone, status item title. The status of data access.  For example, the value may be "Connected" -->
    <string name="status_data_state">Mobile network state</string>
    <!-- About phone, status item title. The ID of embedded SIM card. -->
    <string name="status_esim_id">EID</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 device's MAC address of the Wi-Fi network adapter. [CHAR LIMIT=50] -->
    <string name="status_device_wifi_mac_address">Device 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 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 used to run Android version <xliff:g id="version" example="8.0">%s</xliff:g></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, apps, or other data, using <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>

    <!-- In-progress title. This string lets the user know the SD card is being formatted. The user won't be able to proceed with setup until this step is finished. The placeholder is for the name of the device (e.g. brand name of the SD card). [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_progress_title">Formatting <xliff:g id="name" example="SD card">^1</xliff:g>\u2026</string>
    <!-- Subtext for a full-screen title. This string lets the user know that the SD card can't be removed during this process. The user won't be able to proceed with setup until this step is finished. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [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 being formatted.</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 a full-screen message. This string lets the user know that their storage device is ready to use. They can tap a button at the bottom of the screen to complete the setup process. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=32] -->
    <string name="storage_wizard_ready_title">Your <xliff:g id="name" example="SD card">^1</xliff:g> is ready to use</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>

    <!-- Body of lock screen challenge message explaining that the given user must be unlocked before data can be moved [CHAR LIMIT=64] -->
    <string name="storage_wizard_move_unlock">To move data you need to unlock user <xliff:g id="app" example="Joey">^1</xliff:g>.</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>

    <!-- This is the title of a full-screen message. After this question, the user will get to choose how they want to use the storage device that they have in their phone. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_title">How will you use this <xliff:g id="name" example="SD card">^1</xliff:g>?</string>

    <!-- Title of a line item. Below this title, a user can tap a button to select this option if they want to use their SD card as extra device storage. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_internal_title" product="tablet">Use for extra tablet storage</string>
    <!-- Subtext for a line item. Below this subtext, a user can tap a button to select this option if they want to use their SD card as extra device storage. [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_v2_internal_summary" product="tablet">For apps, files, and media on this tablet only</string>
    <!-- Button text. A user can tap this button if they want to use their SD card as extra device storage. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_internal_action" product="tablet">Tablet storage</string>
    <!-- Title of a line item. Below this title, a user can tap a button to select this option if they want to use their SD card as extra device storage. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_internal_title" product="default">Use for extra phone storage</string>
    <!-- Subtext for a line item. Below this subtext, a user can tap a button to select this option if they want to use their SD card as extra device storage. [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_v2_internal_summary" product="default">For apps, files, and media on this phone only</string>
    <!-- Button text. A user can tap this button if they want to use their SD card as extra device storage. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_internal_action" product="default">Phone storage</string>
    <!-- This text separates two options in a full-screen message. It's used to indicate a user can choose one option or the other. [CHAR LIMIT=16] -->
    <string name="storage_wizard_init_v2_or">Or</string>
    <!-- Title of a line item. Below this title, a user can tap a button to select this option if they want to use their SD card as portable device storage. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_external_title">Use for portable storage</string>
    <!-- Subtext for a line item. Below this subtext, a user can tap a button to select this option if they want to use their SD card as portable device storage. [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_v2_external_summary">For transferring files and media between devices</string>
    <!-- Button text. A user can tap this button if they want to use their SD card as portable device storage. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_external_action">Portable storage</string>
    <!-- Button text. A user can tap this button if they want to delay setting up their SD card until a later time. [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_v2_later">Set up later</string>

    <!-- Title of a dialog. This string is asking users if they want to format their SD card or USB drive in order to use it as extra phone storage. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_v2_title">Format this <xliff:g id="name" example="SD card">^1</xliff:g>?</string>
    <!-- Body of a dialog. This text is confirming that the user wants to use their SD card as extra phone storage, but the formatting process will erase existing content on the card. The first placeholder is for the name of the device (e.g. a brand name of the SD card or USB drive). The second and third placeholders are for the general references (e.g. SD card, USB drive). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_confirm_v2_body">This <xliff:g id="name" example="SanDisk SD card">^1</xliff:g> needs to be formatted to store apps, files, and media.
\n\nFormatting will erase existing content on the <xliff:g id="name" example="SD card">^2</xliff:g>. To avoid losing content, back it up to another <xliff:g id="name" example="SD card">^3</xliff:g> or device.</string>
    <!-- Button text. If a user taps this button, their SD card or USB device will be formatted and used as extra phone storage. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=16] -->
    <string name="storage_wizard_format_confirm_v2_action">Format <xliff:g id="name" example="SD card">^1</xliff:g></string>

    <!-- Title of a full-screen message. This string is confirming that a user wants to move their content to the storage device. They can press a button at the bottom of the screen to move their content. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_v2_title">Move content to <xliff:g id="name" example="SD card">^1</xliff:g>?</string>
    <!-- Main text for a full-screen message. These strings let the user know what they can move to the storage device, how much space will be made in their phone's storage, and how long the move will take. The first placeholder is for the amount of space (e.g. 1.4 GB) that will become available ("free up" is the phrasal verb used for this case). The second placeholder is for the amount of time (e.g. 6 minutes) it'll take to move their content to the storage device. The third placeholder is the name of the storage device (e.g. brand name of the SD card). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_v2_body" product="tablet">You can move files, media, and certain apps to this <xliff:g id="name" example="SanDisk SD card">^1</xliff:g>.
\n\nThis move will free up <xliff:g id="size" example="3 GB">^2</xliff:g> of your tablet\u2019s storage and should take around <xliff:g id="duration" example="3 minutes">^3</xliff:g>.</string>
    <!-- Main text for a full-screen message. These strings let the user know what they can move to the storage device, how much space will be made in their device's storage, and how long the move will take. The first placeholder is for the amount of space (e.g. 1.4 GB) that will become available ("free up" is the phrasal verb used for this case). The second placeholder is for the amount of time (e.g. 6 minutes) it'll take to move their content to the storage device. The third placeholder is the name of the storage device (e.g. brand name of the SD card). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_v2_body" product="default">You can move files, media, and certain apps to this <xliff:g id="name" example="SanDisk SD card">^1</xliff:g>.
\n\nThis move will free up <xliff:g id="size" example="3 GB">^2</xliff:g> of your phone\u2019s storage and should take around <xliff:g id="duration" example="3 minutes">^3</xliff:g>.</string>

    <!-- Title of a section of main text that shows a checklist of items a user should be aware of while moving their content to the SD card. [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_v2_checklist">During the move:</string>
    <!-- Item that a user should be aware of while moving their content to the storage device. The string tells them not to remove the storage device while the move is happening. The placeholder is for the specific device (e.g. SD card, USB device, etc.). [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_v2_checklist_media">Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g></string>
    <!-- Item that a user should be aware of while moving their content to the SD card. Tells them that apps may have trouble working while the move is happening. [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_v2_checklist_apps">Some apps won\u2019t work</string>
    <!-- Item that a user should be aware of while moving their content to the SD card. Tells them to keep the tablet charged while the move is happening. [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet">Keep this tablet charged</string>
    <!-- Item that a user should be aware of while moving their content to the SD card. Tells them to keep the phone charged while the move is happening. [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default">Keep this phone charged</string>

    <!-- Button text. If a user taps this button, they'll start moving their content to the SD card. Move is a verb. [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_v2_now">Move content</string>
    <!-- Button text. If a user taps this button, they'll be able to move their content later. Move is a verb. [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_v2_later">Move content later</string>

    <!-- In-progress title. This string lets the user know that their content is being moved to the SD card. They won't be able to proceed until the move is complete. [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_progress_v2_title">Moving content\u2026</string>

    <!-- Title of a dialog. This string is telling users that their storage device is performing slowly. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=32] -->
    <string name="storage_wizard_slow_v2_title">Slow <xliff:g id="name" example="SD card">^1</xliff:g></string>
    <!-- Strings that are part of a full-screen message. These strings let the user know that their storage device is slow, and include some options they can try. The first placeholder is for the name of the storage device (e.g. brand name of the SD card), and the second and third placeholders are for the general references (e.g. SD card, USB drive, etc.). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_slow_v2_body">You can still use this <xliff:g id="name" example="SanDisk SD card">^1</xliff:g>, but it may be slow.
\n\nApps stored on this <xliff:g id="name" example="SD card">^2</xliff:g> may not work properly, and content transfers could take a long time.
\n\nTry using a faster <xliff:g id="name" example="SD card">^3</xliff:g>, or use this <xliff:g id="name" example="SD card">^4</xliff:g> for portable storage instead.</string>
    <!-- Action of a dialog. This action will start the wizard from the beginning, letting the user make an alternative choice. [CHAR LIMIT=32] -->
    <string name="storage_wizard_slow_v2_start_over">Start over</string>
    <!-- Action of a dialog. This action will continue the wizard, meaning the user acknowledges their card is slow. [CHAR LIMIT=32] -->
    <string name="storage_wizard_slow_v2_continue">Continue</string>

    <!-- Title of a full-screen message. This text lets the user know how to manage the storage device moving forward. The placeholder is for the name of the device (e.g. brand name of the SD card). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_v2_external_body">You can move content to <xliff:g id="name" example="SanDisk SD card">^1</xliff:g></string>
    <!-- Title of a full-screen message. This text lets the user know that their content was moved to their storage device and how to manage the storage device moving forward. The placeholder is for the name of the device (e.g. brand name of the SD card). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_v2_internal_body">To move content to <xliff:g id="name" example="SanDisk SD card">^1</xliff:g>, go to <b>Settings > Storage</b></string>
    <!-- Title of a full-screen message. This text lets the user know that their content was moved to their storage device and how to manage the storage device moving forward. The placeholder is for the name of the device (e.g. brand name of the SD card). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_v2_internal_moved_body">Your content was moved to <xliff:g id="name" example="SanDisk SD card">^1</xliff:g>.
\n\nTo manage this <xliff:g id="name" example="SD card">^2</xliff:g>, go to <b>Settings > Storage</b>.</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>
    <!-- APN error dialog messages: -->
    <string name="error_adding_apn_type">Carrier does not allow adding APNs of type %s.</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>


    <!-- Title for a screen containing all device reset options [CHAR LIMIT=50] -->
    <string name="reset_dashboard_title">Reset options</string>

    <!-- Summary text for a screen containing all device reset options [CHAR LIMIT=None] -->
    <string name="reset_dashboard_summary">Network, apps, or device can be reset</string>
    <!-- Summary text for a screen device reset option for Apps [CHAR LIMIT=NONE] -->
    <string name="reset_dashboard_summary_onlyApps">Apps can be reset</string>

    <!-- Reset Network -->
    <!-- Button title to reset Wi-Fi settings, Mobile data setting, bluetooth settings -->
    <string name="reset_network_title">Reset Wi-Fi, mobile &amp; Bluetooth</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>Mobile data</li>\n<li>Bluetooth</li>"</string>

    <!-- SD card & phone storage settings screen, title for the checkbox to let user decide whether erase eSIM data together [CHAR LIMIT=50] -->
    <string name="reset_esim_title">Erase downloaded SIMs</string>
    <!-- SD card & phone storage settings screen, message for the checkbox to let user decide whether erase eSIM data together [CHAR LIMIT=NONE] -->
    <string name="reset_esim_desc">To download replacement SIMs, contact your carrier. This won\u2019t cancel any mobile service plans.</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, message on screen after user selects Reset settings button [CHAR LIMIT=NONE] -->
    <string name="reset_network_final_desc_esim">Reset all network settings and erase downloaded SIMs? 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>
    <!-- Title of the error message shown when error happens during erase eSIM data [CHAR LIMIT=NONE] -->
    <string name="reset_esim_error_title">Can\u2019t erase SIMs</string>
    <!-- Message of the error message shown when error happens during erase eSIM data [CHAR LIMIT=NONE] -->
    <string name="reset_esim_error_msg">Downloaded SIMs can\u2019t be erased due to an error.\n\nRestart your device and try again.</string>

    <!-- Master Clear -->
    <!-- Button title to factory data reset the entire device -->
    <string name="master_clear_title">Erase all data (factory reset)</string>
    <!-- Button title to factory data reset the entire device. The "(factory reset)" part is optional for translation. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=3531267871084279512]-->
    <string name="master_clear_short_title">Erase all data (factory 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, list of items on an eSIM (embedded SIM) that will be erased during this operation [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_also_erases_esim">"<li>eSIMs</li>"</string>
    <!-- SD card & phone storage settings screen, notification if there are eSIM (embedded SIM) profiles present that the user's mobile service plan will not be canceled [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_no_cancel_mobile_plan">"\n\nThis will not cancel your mobile service plan.</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">Erase all data</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="master_clear_button_text" product="default">Erase all data</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button -->
    <string name="master_clear_final_desc">All of your personal information and downloaded apps will be deleted. You can\u2019t undo this action.</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button [CHAR LIMIT=NONE] -->
    <string name="master_clear_final_desc_esim">All of your personal information, including downloaded apps &amp; SIMs, will be deleted. 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=33] -->
    <string name="master_clear_confirm_title">Erase all data?</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=60]-->
    <string name="tether_settings_title_all">Hotspot &amp; tethering</string>
    <!-- Tethering setting summary when both Wi-Fi hotspot and tether are turned on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_on_tether_on">Hotspot on, tethering</string>
    <!-- Tethering setting summary when Wi-Fi hotspot is on and tether is off [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_on_tether_off">Hotspot on</string>
    <!-- Tethering setting summary when Wi-Fi hotspot is off and tether is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_off_tether_on">Tethering</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>

    <!-- Tethering setting summary when only Wi-Fi hotspot is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_only">Hotspot only</string>
    <!-- Tethering setting summary when only USB tethering is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_usb_tethering_only">USB only</string>
    <!-- Tethering setting summary when only Bluetooth tethering is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_bluetooth_tethering_only">Bluetooth only</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and USB tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_usb">Hotspot, USB</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and Bluetooth tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_bluetooth">Hotspot, Bluetooth</string>
    <!-- Tethering setting summary when USB and Bluetooth tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_usb_and_bluetooth">USB, Bluetooth</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and USB and Bluetooth tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth">Hotspot, USB, Bluetooth</string>
    <!-- Tethering setting summary when hotspot and tethering are off [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_off">Not sharing internet with other devices</string>

    <!-- Tethering interface options [CHAR LIMIT=NONE]-->
    <string name="tethering_interface_options">Tethering</string>

    <!-- Disable Wifi Hotspot option-->
    <!-- Don't use Wi-Fi hotspot title [CHAR LIMIT=NONE]-->
    <string name="disable_wifi_hotspot_title">Don\u2019t use Wi\u2011Fi hotspot</string>
    <!-- Don't use Wi-Fi hotspot summary when USB tethering is chosen [CHAR LIMIT=NONE]-->
    <string name="disable_wifi_hotspot_when_usb_on">Only share internet via USB</string>
    <!-- Don't use Wi-Fi hotspot summary when Bluetooth tethering is chosen [CHAR LIMIT=NONE]-->
    <string name="disable_wifi_hotspot_when_bluetooth_on">Only share internet via Bluetooth</string>
    <!-- Don't use Wi-Fi hotspot summary when USB tethering and Bluetooth tethering are chosen [CHAR LIMIT=NONE]-->
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on">Only share internet via USB and Bluetooth</string>

    <!-- USB Tethering options -->
    <string name="usb_title">USB</string>
    <string name="usb_tethering_button_text">USB tethering</string>
    <string name="usb_tethering_subtext" product="default">Share phone\u2019s internet connection via USB</string>
    <string name="usb_tethering_subtext" product="tablet">Share tablet\u2019s internet connection via USB</string>

    <!-- Bluetooth Tethering settings-->
    <!-- Label for bluetooth tether checkbox [CHAR LIMIT=25]-->
    <string name="bluetooth_tether_checkbox_text">Bluetooth tethering</string>
    <!-- Bluetooth Tethering subtext [CHAR LIMIT=70]-->
    <string name="bluetooth_tethering_subtext" product="tablet">Share tablet\u2019s internet connection via Bluetooth</string>
    <!-- Bluetooth Tethering subtext [CHAR LIMIT=70]-->
    <string name="bluetooth_tethering_subtext" product="default">Share phone\u2019s internet connection via Bluetooth</string>
    <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=80]-->
    <string name="bluetooth_tethering_off_subtext_config">Sharing this <xliff:g id="device_name">%1$d</xliff:g>\u2019s internet connection via Bluetooth</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 footer info [CHAR LIMIT=NONE]-->
    <string name="tethering_footer_info">Use hotspot and tethering to provide internet to other devices through your mobile data connection. Apps can also create a hotspot to share content with nearby devices.</string>
    <!-- Tethering footer info for the device which supports Wi-Fi and Wi-Fi tethering enabled at the same time [CHAR LIMIT=NONE]-->
    <string name="tethering_footer_info_sta_ap_concurrency">Use hotspot and tethering to provide internet to other devices through your Wi\u2011Fi or mobile data connection. Apps can also create a hotspot to share content with nearby devices.</string>

    <!-- Tethering help button - calls up a web view with general tethering info -->
    <string name="tethering_help_button_text">Help</string>

    <!-- Wireless controls, item title to go into the network settings -->
    <string name="network_settings_title">Mobile network</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>

    <!-- Network Scorer Picker title [CHAR LIMIT=40]-->
    <string name="network_scorer_picker_title">Network rating provider</string>
    <string name="network_scorer_picker_none_preference">None</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"><xliff:g id="operator">%1$s</xliff:g> 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>

    <!-- Location settings screen, sub category for recent location requests [CHAR LIMIT=42] -->
    <string name="location_category_recent_location_requests">Recent location requests</string>
    <!-- Location settings screen, displayed when there're more than three recent location requests [CHAR LIMIT=30] -->
    <string name="location_recent_location_requests_see_all">See all</string>
    <!-- Location settings screen, sub category for location services [CHAR LIMIT=30] -->
    <string name="location_category_location_services">Location services</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. It's a link that directs the user to a page that
      shows the location permission setting for each installed app -->
    <string name="location_app_level_permissions">App permission</string>
    <!-- Summary for app permission on Location settings page when location is off [CHAR LIMIT=NONE] -->
    <string name="location_app_permission_summary_location_off">Location is off</string>
    <!--
    Summary for Location settings when location is on, explaining how many apps have location
    permission.

    Please note that the distinction between singular and plural of this sentence only depends on
    the quantity of "permitted_location_app_count" ("has" vs "have"). The quantity of
    "total_location_app_count" is almost always greater than 1, so "apps" is always in plural form.

    [CHAR LIMIT=NONE]-->
    <plurals name="location_app_permission_summary_location_on">
        <item quantity="one">
            <xliff:g id="permitted_location_app_count">%1$d</xliff:g>
            of
            <xliff:g id="total_location_app_count">%2$d</xliff:g>
            apps has access to location</item>
        <item quantity="other">
            <xliff:g id="permitted_location_app_count">%1$d</xliff:g>
            of
            <xliff:g id="total_location_app_count">%2$d</xliff:g>
            apps have access to location</item>
    </plurals>
    <!-- [CHAR LIMIT=50] Location settings screen, sub category for recent location access -->
    <string name="location_category_recent_location_access">Recent location access</string>
    <!-- [CHAR LIMIT=30] Location settings screen, button to bring the user to view the details of recent location access -->
    <string name="location_recent_location_access_view_details">View details</string>
    <!-- Location settings screen, displayed when there's no recent app accessing location
      (for TV) [CHAR LIMIT=100] -->
    <string name="location_no_recent_apps">No apps have requested location recently</string>
    <!-- Location settings screen, displayed when there's no recent app accessing location
      (for phones and tablets) [CHAR LIMIT=100] -->
    <string name="location_no_recent_accesses">No apps recently accessed location</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=60] Wireless background scanning settings screen, screen title -->
    <string name="location_scanning_screen_title">Wi\u2011Fi and Bluetooth 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">Allow apps and services to scan for Wi\u2011Fi networks at any time, even when Wi\u2011Fi is off. This can be used, for example, to improve location-based features and services.</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">Allow apps and services to scan for nearby devices at any time, even when Bluetooth is off. This can be used, for example, to improve location-based features and services.</string>
    <!-- [CHAR LIMIT=50] Location settings screen, sub category for location services for managed profile -->
    <string name="managed_profile_location_services">Location services for work</string>

    <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for Google location service (cell ID, wifi, etc.) -->
    <string name="location_network_based">Wi\u2011Fi &amp; mobile network location</string>
    <!-- [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="device">About device</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 licensing info for Google Play system updates [CHAR LIMIT=50] -->
    <string name="module_license_title">Google Play system update licenses</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">Third-party 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=40] -->
    <string name="lockpassword_choose_your_screen_lock_header">Set screen lock</string>
    <!-- Message on first screen of choose password flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_password_message">For security, set password</string>
    <!-- Header on first screen of choose password/PIN as backup for fingerprint flow. If this string cannot be translated in under 40 characters, please translate "Set fingerprint backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_password_header_for_fingerprint">To use fingerprint, set password</string>
    <!-- Header on first screen of choose pattern as backup for fingerprint flow. If this string cannot be translated in under 40 characters, please translate "Set fingerprint backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint">To use fingerprint, set pattern</string>
    <!-- Message on first screen of choose PIN flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_pin_message">For security, set PIN</string>
    <!-- Header on first screen of choose password/PIN as backup for fingerprint flow. If this string cannot be translated in under 40 characters, please translate "Set fingerprint backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pin_header_for_fingerprint">To use fingerprint, set PIN</string>
    <!-- Message on first screen of choose pattern flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_pattern_message">For security, set pattern</string>
    <!-- Header on password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_password_header">Re-enter your password</string>
    <!-- Header on password confirm screen for the work profile [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_work_password_header">Enter your work password</string>
    <!-- Header on pattern confirm screen [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_pattern_header">Confirm your pattern</string>
    <!-- Header on pattern confirm screen for the work profile [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_work_pattern_header">Enter your work pattern</string>
    <!-- Header on password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_pin_header">Re-enter your PIN</string>
    <!-- Header on password confirm screen for the work profile [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_work_pin_header">Enter your work 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 on pattern confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_draw_your_pattern_again_header">Draw your pattern again</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>
    <!-- Header on first screen of choose password/PIN as backup for face unlock flow. If this string cannot be translated in under 40 characters, please translate "Set face unlock backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_password_header_for_face">To use face unlock, set password</string>
    <!-- Header on first screen of choose pattern as backup for face unlock flow. If this string cannot be translated in under 40 characters, please translate "Set face unlock backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pattern_header_for_face">To use face unlock, set pattern</string>
    <!-- Header on first screen of choose password/PIN as backup for face unlock flow. If this string cannot be translated in under 40 characters, please translate "Set face unlock backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pin_header_for_face">To use face unlock, set PIN</string>
    <!-- Text for button that the user should tap when they forgot their work profile password [CHAR LIMIT=40] -->
    <string name="lockpassword_forgot_password">Forgot your password?</string>
    <!-- Text for button that the user should tap when they forgot their work profile pattern [CHAR LIMIT=40] -->
    <string name="lockpassword_forgot_pattern">Forgot your pattern?</string>
    <!-- Text for button that the user should tap when they forgot their work profile PIN [CHAR LIMIT=40] -->
    <string name="lockpassword_forgot_pin">Forgot your PIN?</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>

    <!-- This string shows up on a screen where a user can enter a pattern that
     unlocks their device. This is an extra security measure that's required for them to
     continue. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_device_pattern">For added security, use your device pattern</string>
    <!-- This string shows up on a screen where a user can enter a PIN that unlocks their device.
         This is an extra security measure that's required for them to continue. [CHAR LIMIT=100]
         -->
    <string name="lockpassword_strong_auth_required_device_pin">For added security, enter your device PIN</string>
    <!-- This string shows up on a screen where a user can enter a password that unlocks their
         device. This is an extra security measure that's required for them to continue. [CHAR
         LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_device_password">For added security, enter your device password</string>

    <!-- This string shows up on a screen where a user can enter a pattern that lets them access
         their work profile, which is a part of their device that's specifically for work apps and
         managed by their employer. This is an extra security measure that's required for them to
         continue. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_work_pattern">For added security, use your work pattern</string>
    <!-- This string shows up on a screen where a user can enter a PIN that lets them access their
         work profile, which is a part of their device that's specifically for work apps and managed
         by their employer. This is an extra security measure that's required for them to continue.
         [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_work_pin">For added security, enter your work PIN</string>
    <!-- This string shows up on a screen where a user can enter a password that lets them access
         their work profile, which is a part of their device that's specifically for work apps and
         managed by their employer. This is an extra security measure that's required for them to
         continue. [CHAR LIMIT=100] -->
    <string name="lockpassword_strong_auth_required_work_password">For added security, enter your work password</string>

    <!-- An explanation text that the pattern needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_pattern_details_frp">Your phone was reset to factory settings. To use this phone, enter your previous pattern.</string>
    <!-- An explanation text that the pin needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_pin_details_frp">Your phone was reset to factory settings. To use this phone, enter your previous PIN.</string>
    <!-- An explanation text that the password needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_password_details_frp">Your phone was reset to factory settings. To use this phone, enter your previous password.</string>

    <!-- Header shown when pattern needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_pattern_header_frp">Verify pattern</string>
    <!-- Header shown when the pin needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_pin_header_frp">Verify PIN</string>
    <!-- Header shown when the password needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_password_header_frp">Verify password</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 device will use your work profile screen lock. Work policies will apply to both locks.</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">App info</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>
    <!-- Category title listing recently used apps [CHAR_LIMIT=50]-->
    <string name="recent_app_category_title">Recently opened apps</string>
    <!-- Preference title for showing all apps on device [CHAR_LIMIT=50]-->
    <string name="see_all_apps_title">See all <xliff:g id="count" example="3">%1$d</xliff:g> apps</string>

    <!-- Title of the dialog that asks the user to contact the IT admin to reset password [CHAR LIMIT=40] -->
    <string name="forgot_password_title">Contact your IT admin</string>
    <!-- Content of the dialog that asks the user to contact the IT admin to reset password [CHAR LIMIT=100] -->
    <string name="forgot_password_text">They can help you reset your PIN, pattern, or password</string>

    <!-- Warning that appears below the unknown sources switch in settings -->
    <string name="install_all_warning" product="tablet">
        Your tablet and personal data are more vulnerable
        to attack by unknown apps. By installing apps from
        this source, you agree that you are responsible for
        any damage to your tablet or loss of data that may
        result from their use.
    </string>

    <!-- Warning that appears below the unknown sources switch in settings -->
    <string name="install_all_warning" product="default">
        Your phone and personal data are more vulnerable
        to attack by unknown apps. By installing apps from
        this source, you agree that you are responsible for
        any damage to your phone or loss of data that may
        result from their use.
    </string>

    <!-- Warning that appears below the unknown sources switch in settings -->
    <string name="install_all_warning" product="device">
        Your device and personal data are more vulnerable
        to attack by unknown apps. By installing apps from
        this source, you agree that you are responsible for
        any damage to your device or loss of data that may
        result from their use.
    </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 size</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">User 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 example, remove all cached emails for an Email app) -->
    <string name="clear_user_data_text">Clear storage</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>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on how recently they sent notifications.-->
    <string name="sort_order_recent_notification">Most recent</string>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on how often they send notifications. -->
    <string name="sort_order_frequent_notification">Most frequent</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\nYou 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 apps</string>
    <!-- [CHAR LIMIT=NONE] Text for filter option in ManageApps screen to display disabled apps -->
    <string name="filter_apps_disabled">Disabled apps</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=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=30] App details, text telling an application is installed. -->
    <string name="installed">Installed</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>
    <!-- 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, text for dialog if clear data fails-->
    <string name="clear_failed_dlg_text">Couldn\u2019t clear storage for app.</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>
    <string name="computing_size">Computing\u2026</string>
    <string name="invalid_size_value">Couldn\u2019t compute package size.</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>

    <!-- 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="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 admin app can\'t be installed on external media</string>

    <string name="force_stop_dlg_title">Force stop?</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when killing persistent apps-->
    <string name="force_stop_dlg_text">If you force stop an app, it may misbehave.</string>
    <!-- Manage applications, 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, label for option to disable app -->
    <string name="app_disable_dlg_positive">Disable app</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, text for dialog when disabling apps -->
    <string name="app_disable_dlg_text">If you disable this app, Android and other apps may no longer function as intended. Keep in mind, you can\u2019t delete this app since it came pre-installed on your device. By disabling, you turn this app off and hide it on your device.</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>
    <!-- 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>

    <!-- Manage applications, individual application info screen, summary for the option which will trigger instant app info in it's installer [CHAR_LIMIT=50] -->
    <string name="instant_app_details_summary">More info on <xliff:g id="app_store">%1$s</xliff:g></string>

    <!-- App Ops Settings --> <skip />
    <!-- [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 Language, input & gestures setting on main settings screen. -->
    <string name="language_input_gesture_title">Languages, input &amp; gestures</string>
    <!-- Summary of Language, input & gestures setting on main settings screen when both gesture setting and assistant feature is on. -->
    <string name="language_input_gesture_summary_on_with_assist"></string>
    <!-- Summary of Language, input & gestures setting on main settings screen when both gesture setting and non-assistant feature is on. -->
    <string name="language_input_gesture_summary_on_non_assist"></string>
    <!-- Summary of Language, input & gestures setting on main settings screen when gesture setting is off. -->
    <string name="language_input_gesture_summary_off"></string>

    <!-- 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>
    <!-- Text displayed when user has restriction DISALLOW_CONFIG_LOCALE [CHAR LIMIT=NONE]-->
    <string name="language_empty_list_user_restricted">You don\u2019t have permission to change the device language.</string>
    <!-- Title of Languages & input settings screen -->
    <string name="language_keyboard_settings_title">Languages&#160;&amp; input</string>
    <!-- Title of preference category that lists all settings about helping user text input such as spell checker [CHAR LIMIT=60]-->
    <string name="input_assistance">Tools</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">Show passwords</string>
    <!-- On Security & location settings screen. This is a short summary text describing what "Show passwords" setting does -->
    <string name="show_password_summary">Display characters briefly as you type</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>
    <!-- Title for the 'keyboard and input methods' preference category. [CHAR LIMIT=45] -->
    <string name="keyboard_and_input_methods_category">Keyboards</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>
    <!-- Title for the 'Work profile keyboards & tools' preference category inside Languages and inputs'. [CHAR LIMIT=50] -->
    <string name="language_and_input_for_work_category_title">Work profile keyboards &amp; tools</string>
    <!-- Title for the 'Virtual keyboards for work' preference. [CHAR LIMIT=45] -->
    <string name="virtual_keyboards_for_work_title">Virtual keyboard for work</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, 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">Redirect vibration</string>
    <!-- On Languages & input settings screen, setting summary.  Setting to redirect vibration to input devices. [CHAR LIMIT=100] -->
    <string name="vibrate_input_devices_summary">Send vibration 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>
    <!-- Title for the 'Spell checker for work' preference. [CHAR LIMIT=45] -->
    <string name="user_dict_settings_for_work_title">Personal dictionary for work</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>
    <!-- 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>

    <!-- 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>
    <!-- Summary for Accessibility settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="accessibility_settings_summary">Screen readers, display, interaction controls</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>
    <!-- Label for suggested action which will allow the user to change the font size and other accessibility settings. [CHAR LIMIT=40] -->
    <string name="vision_settings_suggestion_title">Change font size</string>
    <!-- Title for the accessibility preference category of screen reader services and settings. [CHAR LIMIT=50] -->
    <string name="screen_reader_category_title">Screen readers</string>
    <!-- Title for the accessibility preference category of audio services and settings. [CHAR LIMIT=50] -->
    <string name="audio_and_captions_category_title">Audio &amp; on-screen text</string>
    <!-- Title for the accessibility preference category of display services and settings. [CHAR LIMIT=50] -->
    <string name="display_category_title">Display</string>
    <!-- Title for the accessibility preference category of interaction control services and settings. [CHAR LIMIT=50] -->
    <string name="interaction_control_category_title">Interaction controls</string>
    <!-- Title for the accessibility preference category of services downloaded by the user. [CHAR LIMIT=50] -->
    <string name="user_installed_services_category_title">Downloaded apps</string>
    <!-- Title for the accessibility preference category of settings considered to be experimental, meaning they might be changed or removed in the future. [CHAR LIMIT=50] -->
    <string name="experimental_category_title">Experimental</string>
    <!-- Title for feature flags dashboard where developers can turn on experimental features [CHAR LIMIT=50] -->
    <string name="feature_flags_dashboard_title">Feature flags</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>
    <!-- Summary for the Select to Speak Accessibility Service. [CHAR_LIMIT=none] -->
    <string name="select_to_speak_summary">Tap items on your screen to hear them read aloud</string>
    <!-- Title for the accessibility preference screen to enable video captioning. [CHAR LIMIT=35] -->
    <string name="accessibility_captioning_title">Caption preferences</string>
    <!-- Title for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_title">Magnification</string>
    <!-- Title for the accessibility preference screen to edit magnification area. [CHAR LIMIT=35] -->
    <string name="accessibility_magnification_mode_title">Magnification area</string>
    <!-- Title for the accessibility preference screen to edit magnification enable mode. [CHAR LIMIT=35] -->
    <string name="accessibility_magnification_enable_mode_title">Magnification enable</string>
    <!-- Message for the accessibility preference screen to edit magnification area dialog. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_message">Choose the magnification area(s) you want to use when magnifying the screen</string>
    <!-- Summary for the accessibility preference screen to edit full screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_full_screen_summary">Full screen</string>
    <!-- Summary for the accessibility preference screen to edit window screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_window_screen_summary">Part of screen</string>
    <!-- Summary for the accessibility preference screen to edit entire screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_all_summary">Full screen &amp; part of screen</string>
    <!-- Message for the accessibility preference screen to edit entire screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_full_screen">Magnify entire screen</string>
    <!-- Message for the accessibility preference screen to edit part of screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_window_screen">Magnify part of screen</string>
    <!-- Title for the accessibility preference screen to enable screen magnification settings. [CHAR LIMIT=35] -->
    <string name="accessibility_magnification_service_settings_title">Magnification settings</string>
    <!-- Title for the accessibility preference screen to enable triple-tap gesture screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_gestures_title">Magnify with triple-tap</string>
    <!-- Title for the accessibility preference screen to enable navigation bar screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_navbar_title">Magnify with shortcut</string>
    <!-- Summary for the accessibility magnification setting indicating both "Magnify with button" and "Magnify with triple-tap" are enabled [CHAR LIMIT=50] -->
    <string name="accessibility_screen_magnification_state_navbar_gesture">Magnify with shortcut &amp; triple-tap</string>
    <!-- Title for the footer text to explain what accessibility service does. [CHAR LIMIT=35] -->
    <string name="accessibility_introduction_title">About <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
    <!-- Title for the footer text to explain what option accessibility service does. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_option">Options</string>
    <!-- Summary for the accessibility preference to enable screen magnification. [CHAR LIMIT=25] -->
    <string name="accessibility_preference_magnification_summary">Zoom in on screen</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>
    <!-- Short summary for nav bar Magnification. Tells the user that this feature allows the user to magnify the screen using a button in the nav bar -->
    <string name="accessibility_screen_magnification_navbar_short_summary">Tap a button to zoom</string>
    <!-- Summary for the accessibility preference screen to enable screen magnification gestures. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_summary"><![CDATA[Quickly zoom in on the screen to see content more clearly.<br/><br/><b>To zoom in:</b><br/>\t1. Use shortcut to start magnification<br/>\t2. Tap the screen<br/>\t3. Drag 2 fingers to move around screen<br/>\t4. Pinch with 2 fingers to adjust zoom<br/>\t5. Use shortcut to stop magnification<br/><br/><b>To zoom in temporarily:</b><br/>\t1. Use shortcut to start magnification<br/>\t2. Touch & hold anywhere on the screen<br/>\t3. Drag finger to move around screen<br/>\t4. Lift finger to stop magnification]]></string>
    <!-- Summary for the accessibility preference screen to enable screen magnification via the nav bar. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_navbar_summary">When magnification is turned on, you can zoom in on your screen.\n\n<b>To zoom</b>, start magnification, then tap anywhere on the screen.\n<ul><li>Drag 2 or more fingers to scroll</li>\n<li>Pinch 2 or more fingers to adjust zoom</li></ul>\n\n<b>To zoom temporarily</b>, start magnification, then touch &amp; hold anywhere on the screen.\n<ul><li>Drag to move around the screen</li>\n<li>Lift finger to zoom out</li></ul>\n\nYou can’t zoom in on the keyboard or navigation bar.</string>
    <!-- Title for the Accessibility tutorial dialog in Accessibility service with button. [CHAR LIMIT=50] -->
    <string name="accessibility_tutorial_dialog_title_button">Use accessibility button to open</string>
    <!-- Title for the Accessibility tutorial dialog in Accessibility service with gesture. [CHAR LIMIT=50] -->
    <string name="accessibility_tutorial_dialog_title_gesture">Use gesture to open</string>
    <!-- Title for the Accessibility tutorial dialog in gesture navigation settings. [CHAR LIMIT=50] -->
    <string name="accessibility_tutorial_dialog_title_gesture_settings">Use new accessibility gesture</string>
    <!-- Message for the Accessibility tutorial dialog when user enables an accessibility service while using the 3-button nav bar. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_button">To turn this service on or off, tap the accessibility button <xliff:g id="accessibility_icon" example="[Icon]">%s</xliff:g> on the bottom of your screen.\n\nTo switch between services, touch &amp; hold the accessibility button.</string>
    <!-- Message for the Accessibility tutorial dialog when user enables an accessibility service while using gesture navigation and touch exploration is not enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture">To turn this service on or off, swipe up from the bottom of the screen with two fingers.\n\nTo switch between services, swipe up with two fingers and hold.</string>
    <!-- Message for the Accessibility tutorial dialog when user enables an accessibility service while using gesture navigation and touch exploration is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture_talkback">To turn this service on or off, swipe up from the bottom of the screen with three fingers.\n\nTo switch between services, swipe up with three fingers and hold.</string>
    <!-- Message for the Accessibility tutorial dialog when user chooses gesture navigation in navigation settings, an accessibility service is using the accessibility button, and touch exploration is disabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture_settings">To turn an accessibility service on or off, swipe up from the bottom of the screen with two fingers.\n\nTo switch between services, swipe up with two fingers and hold.</string>
    <!-- Message for the Accessibility tutorial dialog when user chooses gesture navigation in navigation settings, an accessibility service is using the accessibility button, and touch exploration is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback">To turn an accessibility service on or off, swipe up from the bottom of the screen with three fingers.\n\nTo switch between services, swipe up with three fingers and hold.</string>
    <!-- Button for the Accessibility tutorial dialog to dismiss the dialog when user clicks it. [CHAR LIMIT=10] -->
    <string name="accessibility_tutorial_dialog_button">Got it</string>
    <!-- Title for accessibility shortcut preference for accessibility apps. [CHAR LIMIT=40] -->
    <string name="accessibility_shortcut_title"><xliff:g id="service" example="Select to Speak">%1$s</xliff:g> shortcut</string>
    <!-- Title for software shortcut in Accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_summary_software">Accessibility Button</string>
    <!-- Title for software shortcut in gesture mode in Accessibility edit shortcut dialog while using gesture navigation is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture">Swipe up with 2 fingers</string>
    <!-- Title for software shortcut in gesture mode in Accessibility edit shortcut dialog while using gesture navigation and touch exploration are enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback">Swipe up with 3 fingers</string>
    <!-- Summary for accessibility shortcut preference for software shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software">Tap accessibility button</string>
    <!-- Summary for software shortcut in Accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software">Tap the accessibility button <xliff:g id="accessibility_icon" example="[Icon]">%s</xliff:g> at the bottom of your screen</string>
    <!-- Summary for software shortcut in gesture mode in Accessibility edit shortcut dialog while using gesture navigation is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture">Swipe up from the bottom of the screen with 2 fingers</string>
    <!-- Summary for software shortcut in gesture mode in Accessibility edit shortcut dialog while using gesture navigation and touch exploration are enabled [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback">Swipe up from the bottom of the screen with 3 fingers</string>
    <!-- Title for hardware shortcut in Accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_hardware">Hold volume keys</string>
    <!-- Summary for hardware shortcut in Accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_hardware">Press &amp; hold both volume keys for 1 second</string>
    <!-- Title for triple tap shortcut in Accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap">Triple-tap screen</string>
    <!-- Summary for triple tap shortcut in Accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap">Quickly tap screen 3 times. This shortcut may slow down your device.</string>
    <!-- Title for the Accessibility edit shortcut dialog to save the preference when user clicks it. [CHAR LIMIT=10] -->
    <string name="accessibility_shortcut_edit_dialog_title_advance">Advanced</string>
    <!-- Summary text appearing on the accessibility preference screen to enable screen magnification from the nav bar when the feature is enabled, but the accessibility button is not configured correctly for the feature to be used [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_navbar_configuration_warning">The Accessibility button is set to <xliff:g id="service" example="Select to Speak">%1$s</xliff:g>. To use magnification, touch &amp; hold the Accessibility button, then select magnification.</string>
    <!-- Summary text appearing on the accessibility preference screen to enable screen magnification from the nav bar when the feature is enabled, but the accessibility button is not configured correctly for the feature to be used [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_gesture_navigation_warning">The accessibility gesture is set to the <xliff:g id="service" example="Select to Speak">%1$s</xliff:g>. To use magnification, swipe up with two fingers from the bottom of the screen and hold. Then select magnification.</string>
    <!-- Title for the preference to configure the accessibility shortcut, which uses the volume keys. [CHAR LIMIT=35] -->
    <string name="accessibility_global_gesture_preference_title">Volume key shortcut</string>
    <!-- Title for the preference to choose the service that is turned on and off by the accessibility shortcut. [CHAR LIMIT=35] -->
    <string name="accessibility_shortcut_service_title">Shortcut service</string>
    <!-- Label for shortcut settings button. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_settings">Shortcut settings</string>
    <!-- Title for the switch preference that controls whether or not the accessibility shortcut works on the lock screen. [CHAR LIMIT=35] -->
    <string name="accessibility_shortcut_service_on_lock_screen_title">Shortcut from lock screen</string>
    <!-- Description of accessibility shortcut. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_description">Allow feature shortcut to turn on from the lock screen. Hold both volume keys for 3 seconds.</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 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 disabling animations. [CHAR LIMIT=35] -->
    <string name="accessibility_disable_animations">Remove animations</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 the accessibility preference for master balance. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_master_balance_title">Audio balance</string>
    <!-- 'Left' balance text for the accessibility preference for master balance. [CHAR LIMIT=20] -->
    <string name="accessibility_toggle_master_balance_left_label">Left</string>
    <!-- 'Right' balance text for the accessibility preference for master balance. [CHAR LIMIT=20] -->
    <string name="accessibility_toggle_master_balance_right_label">Right</string>

    <!-- Option heading to leave the timeout requirement for accessibility users at its default level. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_default">Default</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 10 secs. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_10secs">10 seconds</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 30 secs. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_30secs">30 seconds</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 1 min. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_1min">1 minute</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 2 mins. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_2mins">2 minutes</string>
    <!-- Title for accessibility settings timeout item. [CHAR LIMIT=43] -->
    <string name="accessibility_setting_item_control_timeout_title">Time to take action (Accessibility timeout)</string>
    <!-- Title for accessibility preference to accessibility timeout. [CHAR LIMIT=35] -->
    <string name="accessibility_control_timeout_preference_title">Time to take action</string>
    <!-- Descriptive text for accessibility preference to accessibility control timeout. [CHAR LIMIT=NONE] -->
    <string name="accessibility_control_timeout_preference_summary">Choose how long to show messages that ask you to take action, but are visible only temporarily.\n\nNot all apps support this setting.</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>
    <!-- Used in the accessibility service settings to control turning display color inversion on/off entirely. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_switch_title">Use color inversion</string>
    <!-- Subtitle for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_subtitle"><![CDATA[Color inversion turns light screens dark. This feature may be helpful for people who are sensitive to bright light.<br/><br/>Color inversion also turns dark screens light. Colors will change in media and images.<br/><br/>Note: You can also use Dark theme to display a dark background. Dark theme works with supported apps. Color inversion works on all apps.]]></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">Autoclick (dwell timing)</string>
    <!-- Footer text to explain what autoclick does -->
    <string name="accessibility_autoclick_description">Autoclick works with a connected mouse. You can set the mouse cursor to click automatically when the cursor stops moving for a certain amount of time.</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its default level. [CHAR LIMIT=50] -->
    <string name="accessibility_autoclick_default_title">Off</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its short level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_short_title">Short</string>
    <!-- Option summary text for the auto click delay 0.2 seconds radio button. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_short_summary">0.2 seconds</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its medium level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_medium_title">Medium</string>
    <!-- Option summary text for the auto click delay 0.6 seconds radio button. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_medium_summary">0.6 seconds</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its long level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_long_title">Long</string>
    <!-- Option summary text for the auto click delay 1 second radio button. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_long_summary">1 second</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its custom level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_custom_title">Custom</string>
    <!-- Description for the button that shorter auto click time. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_autoclick_shorter_desc">Shorter</string>
    <!-- Description for the button that longer auto click time. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_autoclick_longer_desc">Longer</string>
    <!-- Description for the seekbar that adjust auto click time. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_autoclick_seekbar_desc">Auto click time</string>
    <!-- Title for accessibility preference screen for configuring vibrations. -->
    <string name="accessibility_vibration_settings_title">Vibration &amp; haptic strength</string>
    <!-- Title for accessibility preference for configuring notification vibrations. -->
    <string name="accessibility_notification_vibration_title">Notification vibration</string>
    <!-- Title for accessibility preference for configuring ring vibrations. [CHAR LIMIT=NONE] -->
    <string name="accessibility_ring_vibration_title">Ring vibration</string>
    <!-- Title for accessibility preference for configuring touch feedback vibrations. -->
    <string name="accessibility_touch_vibration_title">Touch feedback</string>
    <!-- Used in the accessibility service settings to control turning on/off the service entirely -->
    <string name="accessibility_service_master_switch_title">Use <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g></string>
    <!-- Used in the accessibility service settings to open the activity. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_master_open_title">Open <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g></string>
    <!-- Used in the Color correction settings screen to control turning on/off the feature entirely -->
    <string name="accessibility_daltonizer_master_switch_title">Use color correction</string>
    <!-- Title for Captions settings screen to control turning on/off the feature entirely -->
    <string name="accessibility_caption_master_switch_title">Show captions</string>
    <!-- Summary for Captions settings screen to control turning on/off the feature entirely [CHAR LIMIT=NONE] -->
    <string name="accessibility_caption_master_switch_summary">For supported app only</string>
    <!-- Title for Caption preference settings screen for configuring font style. [CHAR LIMIT=NONE] -->
    <string name="captioning_caption_appearance_title">Caption size and style</string>
    <!-- Summary for Captions settings, explaining important settings under it. [CHAR LIMIT=NONE] -->
    <string name="captioning_caption_appearance_summary"><xliff:g id="accessibility_font_size" example="Large">%1$s</xliff:g> text size</string>
    <!-- Title for Caption preference settings screen for configuring language. [CHAR LIMIT=NONE] -->
    <string name="captioning_more_options_title">More options</string>
    <!-- Used in the Captions preference to tell users that the setting doesn't support all apps. [CHAR LIMIT=NONE] -->
    <string name="accessibility_caption_preference_summary">Not all apps support these caption preferences</string>
    <!-- Summary for accessibility shortcut preference for software shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_software">Accessibility button</string>
    <!-- Summary for accessibility shortcut preference for software shortcut type when gesture mode is on. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_software_gesture">2-finger swipe up from bottom</string>
    <!-- Summary for accessibility shortcut preference for hardware shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_hardware">Hold volume keys</string>
    <!-- Summary for accessibility shortcut preference for magnification triple tap shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_triple_tap">Triple tap screen</string>

    <!-- Button text for the accessibility dialog continue to the next screen for hearing aid. [CHAR LIMIT=32] -->
    <string name="accessibility_hearingaid_instruction_continue_button">Continue</string>
    <!-- Title for the accessibility preference for hearing aid. [CHAR LIMIT=35] -->
    <string name="accessibility_hearingaid_title">Hearing aids</string>
    <!-- Summary for the accessibility preference for hearing aid when not connected. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_not_connected_summary">No hearing aids connected</string>
    <!-- Summary for the accessibility preference for hearing aid when adding new devices. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_adding_summary">Add hearing aids</string>
    <!-- Message to ask the user to make sure that their hearing aid devices are in pairing mode. [CHAR LIMIT=NONE] -->
    <string name="accessibility_hearingaid_pair_instructions_message">To pair your hearing aids, find and tap your device on the next screen. Make sure your hearing aids are in pairing mode.</string>
    <!-- Summary for the accessibility preference for hearing aid when there is an active device. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_active_device_summary"><xliff:g id="device_name">%1$s</xliff:g> active</string>
    <!-- Summary for the accessibility preference for hearing aid when there are saved devices. [CHAR LIMIT=50] -->
    <plurals name="show_number_hearingaid_count">
        <item quantity="one"><xliff:g id="number_device_count">%1$d</xliff:g> saved hearing aid</item>
        <item quantity="other"><xliff:g id="number_device_count">%1$d</xliff:g> saved hearing aids</item>
    </plurals>

    <!-- Preference's shortcut when enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_shortcut_enabled">Shortcut on</string>
    <!-- Preference's shortcut when disabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_shortcut_disabled">Off</string>
    <!-- Preference's state when enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_state_enabled">On</string>
    <!-- Preference's state when disabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_state_disabled">Off</string>
    <!-- Accessibility service's preference's state when enabled but not running (like maybe it crashed). -->
    <string name="accessibility_summary_state_stopped">Not working. Tap for info.</string>
    <!-- Accessibility service's description when enabled but not running (like maybe it crashed). -->
    <string name="accessibility_description_state_stopped">This service is malfunctioning.</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>
    <!-- Title shown for deuteranomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_deuteranomaly_title">Deuteranomaly</string>
    <!-- Title shown for protanomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_protanomaly_title">Protanomaly</string>
    <!-- Title shown for tritanomaly (blue-yellow color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_tritanomaly_title">Tritanomaly</string>
    <!-- Summary shown for deuteranomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_deuteranomaly_summary">Red-green</string>
    <!-- Summary shown for protanomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_protanomaly_summary">Red-green</string>
    <!-- Summary shown for tritanomaly (blue-yellow color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_tritanomaly_summary">Blue-yellow</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$s</xliff:g> second)</item>
        <item quantity="other">Extremely short delay (<xliff:g id="click_delay_label" example="200">%1$s</xliff:g> seconds)</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$s</xliff:g> second)</item>
        <item quantity="other">Very short delay (<xliff:g id="click_delay_label" example="200">%1$s</xliff:g> seconds)</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$s</xliff:g> second)</item>
        <item quantity="other">Short delay (<xliff:g id="click_delay_label" example="200">%1$s</xliff:g> seconds)</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$s</xliff:g> second)</item>
        <item quantity="other">Long delay (<xliff:g id="click_delay_label" example="200">%1$s</xliff:g> seconds)</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$s</xliff:g> second)</item>
        <item quantity="other">Very long delay (<xliff:g id="click_delay_label" example="200">%1$s</xliff:g> seconds)</item>
    </plurals>

    <!-- Summary for autoclick seekbar settings preference when user selected custom item. [CHAR LIMIT=35] -->
    <plurals name="accessibilty_autoclick_delay_unit_second">
        <item quantity="one"><xliff:g id="click_delay_label" example="1">%1$s</xliff:g> second</item>
        <item quantity="other"><xliff:g id="click_delay_label" example="0.6">%1$s</xliff:g> seconds</item>
    </plurals>

    <!-- Summary for vibration settings preference when notification vibration and haptic feedback intensity are set. [CHAR LIMIT=50] -->
    <string name="accessibility_vibration_summary">Ring <xliff:g id="summary_ring" example="Medium">%1$s</xliff:g>, notification <xliff:g id="summary_notification" example="Low">%2$s</xliff:g>, touch <xliff:g id="summary_touch" example="High">%3$s</xliff:g></string>

    <!-- Summary for vibration settings preference when ring & notification are set to off-->
    <string name="accessibility_vibration_summary_off">Ring &amp; notification set to off</string>

    <!-- Summary for vibration settings preference when ring & notification are set to low-->
    <string name="accessibility_vibration_summary_low">Ring &amp; notification set to low</string>

    <!-- Summary for vibration settings preference when ring & notification are set to medium-->
    <string name="accessibility_vibration_summary_medium">Ring &amp; notification set to medium</string>

    <!-- Summary for vibration settings preference when ring & notification are set to high-->
    <string name="accessibility_vibration_summary_high">Ring &amp; notification set to high</string>

    <!-- Label describing an option turning vibrations off. [CHAR LIMIT=15] -->
    <string name="accessibility_vibration_intensity_off">Off</string>

    <!-- Label describing a low intensity vibration option. [CHAR LIMIT=15] -->
    <string name="accessibility_vibration_intensity_low">Low</string>

    <!-- Label describing a medium intensity vibration option. [CHAR LIMIT=15] -->
    <string name="accessibility_vibration_intensity_medium">Medium</string>

    <!-- Label describing a high intensity vibration option. [CHAR LIMIT=15] -->
    <string name="accessibility_vibration_intensity_high">High</string>

    <!-- Title for accessibility menu item to launch 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">Allow
         <xliff:g id="service" example="TalkBack">%1$s</xliff:g> to have full control of your
        device?</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>

    <!-- Warning that explains that accessibility services have a lot of access to user data [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_warning"><xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> is requesting full control of this device. The service
        can read the screen and act on behalf of users with accessibility needs.
        This level of control is not appropriate for most apps.
    </string>

    <!-- Warning description that explains that it's appropriate for accessibility
         services to have full control to help users with accessibility needs. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_warning_description">Full control is appropriate for apps
        that help you with accessibility needs, but not for most apps.
    </string>

    <!-- Title for the screen control in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_screen_control_title">View and control screen</string>

    <!-- Description for the screen control in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_screen_control_description">It can read all content on the
        screen and display content over other apps.
    </string>

    <!-- Title for the action perform in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_action_perform_title">View and perform actions</string>

    <!-- Description for the action perform in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_action_perform_description">It can track your interactions
        with an app or a hardware sensor, and interact with apps on your behalf.
    </string>

    <!-- String for the allow button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_allow">Allow</string>
    <!-- String for the deny button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_deny">Deny</string>

    <!-- String for the allow button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_stop">Stop</string>
    <!-- String for the deny button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_cancel">Cancel</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 <xliff:g id="stop" example="Stop">%1$s</xliff:g> will
        stop <xliff:g id="service" example="TalkBack">%2$s</xliff:g>.</string>

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

    <!-- Title for the acccessibility shortcut's summary if no service is selected for use with the shortcut. [CHAR LIMIT=50] -->
    <string name="accessibility_no_service_selected">No service selected</string>

    <!-- Default description for an accessibility service 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 setting summary in settings screen [CHAR LIMIT=50] -->
    <string name="print_settings_summary_no_service">Off</string>

    <!-- Print setting summary in settings screen [CHAR LIMIT=50] -->
    <plurals name="print_settings_summary">
        <item quantity="one">1 print service on</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> print services on</item>
    </plurals>

    <!-- Print setting summary in settings screenm indicating how many print jobs are active [CHAR LIMIT=None] -->
    <plurals name="print_jobs_summary">
        <item quantity="one">1 print job</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> 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 services 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 for a configuring print job (i.e. the user is currently selecting the paper size and printer to use). [CHAR LIMIT=25] -->
    <string name="print_configuring_state_title_template" >Configuring <xliff:g id="print_job_name" example="foo.jpg">%1$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>

    <!-- Title for the background activity setting, which allows a user to control whether an app can run in the background [CHAR_LIMIT=40] -->
    <string name="background_activity_title">Background restriction</string>
    <!-- Summary for the background activity [CHAR_LIMIT=120] -->
    <string name="background_activity_summary">Allow the app to run in the background</string>
    <!-- Summary for the background activity when it is disabled [CHAR_LIMIT=120] -->
    <string name="background_activity_summary_disabled">App not allowed to run in background</string>
    <!-- TODO: Pending UX review. Summary for the background activity when it is whitlisted [CHAR_LIMIT=120] -->
    <string name="background_activity_summary_whitelisted">Background usage can\u2019t be restricted</string>
    <!-- TODO: Pending UX review. Title for the warning dialog to show to the user when limiting background activity for an app -->
    <string name="background_activity_warning_dialog_title">Limit background activity?</string>
    <!-- TODO: Pending UX review. Text for the warning dialog to show to the user when limiting background activity for an app -->
    <string name="background_activity_warning_dialog_text">If you limit background activity for an app, it may misbehave</string>
    <!-- Dialog message when app can't been restricted because it is not optimized [CHAR_LIMIT=120] -->
    <string name="background_activity_disabled_dialog_text">Since this app is not set to optimize battery, you can\u2019t restrict it.\n\nTo restrict the app, first turn on battery optimization.</string>

    <!-- Title for the screen usage in power use UI [CHAR_LIMIT=60] -->
    <string name="device_screen_usage">Screen usage since full charge</string>
    <!-- Label for list of apps using battery in power use UI. Note: ^1 should be used in all translations[CHAR_LIMIT=120] -->
    <string name="power_usage_list_summary">Battery usage since full charge</string>
    <!-- Temp string used to debug new battery estimates [DO NOT TRANSLATE] -->
    <string name="power_usage_enhanced_debug" translatable="false"><xliff:g id="time">%1$s</xliff:g> left (New ML est)</string>
    <!-- Temp string used to debug old battery estimates [DO NOT TRANSLATE] -->
    <string name="power_usage_old_debug" translatable="false"><xliff:g id="time">%1$s</xliff:g> left (Old est)</string>
    <!-- Description for the screen usage item [CHAR_LIMIT=120] -->
    <string name="screen_usage_summary">Amount of time screen has been on since full charge</string>
    <!-- Label for list of different types using battery in power use UI [CHAR_LIMIT=60] -->
    <string name="device_usage_list_summary">Device usage since 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">Mobile network signal</string>
    <!-- Battery usage during last unplugged period -->
    <string name="battery_stats_last_duration">@string/menu_stats_last_unplugged</string>
    <!-- CPU awake time title -->
    <string name="awake">Device awake time</string>
    <!-- Wifi on time -->
    <string name="wifi_on_time">Wi\u2011Fi on time</string>
    <!-- Bluetooth on time -->
    <string name="bluetooth_on_time">Wi\u2011Fi on time</string>

    <!-- Activity title for advanced battery usage page [CHAR LIMIT=25] -->
    <string name="advanced_battery_title">Battery usage</string>
    <!-- Activity title for battery usage history details [CHAR LIMIT=60] -->
    <string name="history_details_title">History details</string>

    <!-- Activity title for battery usage details for an app. or power consumer -->
    <string name="battery_details_title">Battery usage</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>

    <!-- Title for the battery summary tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_summary_title">Apps are running normally</string>
    <!-- Summary for the battery summary tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_summary_summary" product="default">Phone has typical background battery usage</string>
    <!-- Summary for the battery summary tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_summary_summary" product="tablet">Tablet has typical background battery usage</string>
    <!-- Summary for the battery summary tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_summary_summary" product="device">Device has typical background battery usage</string>
    <!-- Title for the low battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_low_battery_title">Low battery capacity</string>
    <!-- Summary for the low battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_low_battery_summary">Battery can\'t provide good battery life</string>
    <!-- Title for the smart battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_smart_battery_title" product="default">Improve your phone\'s battery life</string>
    <!-- Title for the smart battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_smart_battery_title" product="tablet">Improve your tablet\'s battery life</string>
    <!-- Title for the smart battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_smart_battery_title" product="device">Improve your device\'s battery life</string>
    <!-- Summary for the smart battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_smart_battery_summary">Turn on Battery Manager</string>
    <!-- Title for the early heads up tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_early_heads_up_title">Turn on Battery Saver</string>
    <!-- Summary for the early hedas up tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_early_heads_up_summary">Battery may run out earlier than usual</string>
    <!-- Title when early heads up is solved [CHAR LIMIT=NONE] -->
    <string name="battery_tip_early_heads_up_done_title">Battery Saver is on</string>
    <!-- Summary when early heads up is solved [CHAR LIMIT=NONE] -->
    <string name="battery_tip_early_heads_up_done_summary">Some features may be limited</string>
    <!-- Title for the battery high usage tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_high_usage_title" product="default">Phone used more than usual</string>
    <!-- Title for the battery high usage tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_high_usage_title" product="tablet">Tablet used more than usual</string>
    <!-- Title for the battery high usage tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_high_usage_title" product="device">Device used more than usual</string>
    <!-- Summary for the battery high usage tip, which presents battery may run out earlier [CHAR LIMIT=NONE] -->
    <string name="battery_tip_high_usage_summary">Battery may run out earlier than usual</string>
    <!-- Message for battery tip dialog to show the status about the battery [CHAR LIMIT=NONE] -->
    <string name="battery_tip_dialog_message" product="default">Your phone has been used more than usual. Your battery may run out sooner than expected.\n\nTop apps by battery usage:</string>
    <!-- Message for battery tip dialog to show the status about the battery [CHAR LIMIT=NONE] -->
    <string name="battery_tip_dialog_message" product="tablet">Your tablet has been used more than usual. Your battery may run out sooner than expected.\n\nTop apps by battery usage:</string>
    <!-- Message for battery tip dialog to show the status about the battery [CHAR LIMIT=NONE] -->
    <string name="battery_tip_dialog_message" product="device">Your device has been used more than usual. Your battery may run out sooner than expected.\n\nTop apps by battery usage:</string>
    <!-- Footer message for battery tip dialog to show the status about the battery [CHAR LIMIT=NONE] -->
    <string name="battery_tip_dialog_message_footer">Includes high-power background activity</string>
    <!-- Title for restricted app preference, showing how many app need to be restricted [CHAR LIMIT=NONE] -->
    <plurals name="battery_tip_restrict_title">
        <item quantity="one">Restrict %1$d app</item>
        <item quantity="other">Restrict %1$d apps</item>
    </plurals>
    <!-- Title for restricted app preference, showing how many app been restricted [CHAR LIMIT=NONE] -->
    <plurals name="battery_tip_restrict_handled_title">
        <item quantity="one">%1$s recently restricted</item>
        <item quantity="other">%2$d apps recently restricted</item>
    </plurals>
    <!-- Summary for restricted app preference, showing the impact of the apps [CHAR LIMIT=NONE] -->
    <plurals name="battery_tip_restrict_summary">
        <item quantity="one">%1$s has high background battery usage</item>
        <item quantity="other">%2$d apps have high background battery usage</item>
    </plurals>
    <!-- Summary for restricted app preference, showing the impact of the apps [CHAR LIMIT=NONE] -->
    <plurals name="battery_tip_restrict_handled_summary">
        <item quantity="one">This app can\'t run in the background</item>
        <item quantity="other">These apps can\'t run in the background</item>
    </plurals>

    <!-- Title for dialog to restrict the app [CHAR LIMIT=NONE] -->
    <plurals name="battery_tip_restrict_app_dialog_title">
        <item quantity="one">Restrict app?</item>
        <item quantity="other">Restrict %1$d apps?</item>
    </plurals>
    <!-- Message for battery tip dialog to show the info to restrict the app [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_app_dialog_message">To save battery, stop <xliff:g id="app">%1$s</xliff:g> from using battery in the background. This app may not work properly and notifications may be delayed.</string>
    <!-- Message for battery tip dialog to show the info to restrict the app, below it app list will be shown as a view [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message">To save battery, stop these apps from using battery in the background. Restricted apps may not work properly and notifications may be delayed.\n\nApps:</string>
    <!-- Message for battery tip dialog to show the info to restrict the app, below it app list will be shown as raw string[CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message">To save battery, stop these apps from using battery in the background. Restricted apps may not work properly and notifications may be delayed.\n\nApps:\n<xliff:g id="app_list">%1$s</xliff:g>.</string>
    <!-- OK button for battery tip dialog to show the restrict app list [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_app_dialog_ok">Restrict</string>
    <!-- Title for dialog to remove restriction for the app [CHAR LIMIT=NONE] -->
    <string name="battery_tip_unrestrict_app_dialog_title">Remove restriction?</string>
    <!-- Message for  dialog to show the impact if remove restriction for app [CHAR LIMIT=NONE] -->
    <string name="battery_tip_unrestrict_app_dialog_message">This app will be able to use battery in the background. Your battery may run out sooner than expected.</string>
    <!-- OK button for dialog to remove restriction for app [CHAR LIMIT=NONE] -->
    <string name="battery_tip_unrestrict_app_dialog_ok">Remove</string>
    <!-- CANCEL button for dialog to remove restriction for app [CHAR LIMIT=NONE] -->
    <string name="battery_tip_unrestrict_app_dialog_cancel">Cancel</string>

    <!-- Message for battery tip dialog to show the battery summary -->
    <string name="battery_tip_dialog_summary_message" product="default">Your apps are using a normal amount of battery. If apps use too much battery, your phone will suggest actions you can take.\n\nYou can always turn on Battery Saver if you\u2019re running low on battery.</string>
    <!-- Message for battery tip dialog to show the battery summary -->
    <string name="battery_tip_dialog_summary_message" product="tablet">Your apps are using a normal amount of battery. If apps use too much battery, your tablet will suggest actions you can take.\n\nYou can always turn on Battery Saver if you\u2019re running low on battery.</string>
    <!-- Message for battery tip dialog to show the battery summary -->
    <string name="battery_tip_dialog_summary_message" product="device">Your apps are using a normal amount of battery. If apps use too much battery, your device will suggest actions you can take.\n\nYou can always turn on Battery Saver if you\u2019re running low on battery.</string>

    <!-- Title for the smart battery manager preference [CHAR LIMIT=NONE] -->
    <string name="smart_battery_manager_title">Battery Manager</string>
    <!-- Title for the smart battery toggle [CHAR LIMIT=NONE] -->
    <string name="smart_battery_title">Manage apps automatically</string>
    <!-- Summary for the smart battery toggle [CHAR LIMIT=NONE] -->
    <string name="smart_battery_summary" product="default">Limit battery for apps that you don\u2019t use often</string>
    <!-- Footer for the aosp smart battery page -->
    <string name="smart_battery_footer">When Battery Manager detects that apps are draining battery, you\u2019ll have the option to restrict these apps. Restricted apps may not work properly and notifications may be delayed.</string>
    <!-- Title for restricted app preference, clicking it will goes to restricted app list [CHAR LIMIT=NONE] -->
    <string name="restricted_app_title">Restricted apps</string>
    <!-- Summary for restricted app preference, clicking it will goes to restricted app list [CHAR LIMIT=NONE] -->
    <plurals name="restricted_app_summary">
        <item quantity="one">Limiting battery usage for %1$d app</item>
        <item quantity="other">Limiting battery usage for %1$d apps</item>
    </plurals>

    <!-- Summary for restricted app to show the restriction time [CHAR LIMIT=NONE] -->
    <string name="restricted_app_time_summary">Restricted <xliff:g id="time" example="5 days ago">%1$s</xliff:g></string>

    <!-- Footer message for restrict app details page -->
    <string name="restricted_app_detail_footer">These apps have been using battery in the background. Restricted apps may not work properly and notifications may be delayed.</string>

    <!-- Title for auto restriction toggle -->
    <string name="battery_auto_restriction_title">Use Battery Manager</string>
    <!-- Summary for auto restriction toggle -->
    <string name="battery_auto_restriction_summary">Detect when apps drain battery</string>

    <!-- Summary for battery manager when it is on -->
    <string name="battery_manager_on" product="default">On / Detecting when apps drain battery</string>

    <!-- Summary for battery manager when it is off -->
    <string name="battery_manager_off">Off</string>
    <!-- Summary for battery manager, showing app restricted -->
    <plurals name="battery_manager_app_restricted">
        <item quantity="one">%1$d app restricted</item>
        <item quantity="other">%1$d apps restricted</item>
    </plurals>

    <!-- Title to display the battery percentage. [CHAR LIMIT=24] -->
    <string name="battery_header_title_alternate"><xliff:g id="number" example="88">^1</xliff:g><small> <font size="20"><xliff:g id="unit" example="%">%</xliff:g></font></small></string>

    <!-- Title for force stop dialog [CHAR LIMIT=30] -->
    <string name="dialog_stop_title">Stop app?</string>
    <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_stop_message" product="default">Your phone can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> is keeping your phone awake.\n\nTo try to fix this issue, you can stop the app.\n\nIf this keeps happening, you may need to uninstall the app to improve battery performance.</string>
    <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_stop_message" product="tablet">Your tablet can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> is keeping your tablet awake.\n\nTo try to fix this issue, you can stop the app.\n\nIf this keeps happening, you may need to uninstall the app to improve battery performance.</string>
    <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_stop_message" product="device">Your device can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> is keeping your device awake.\n\nTo try to fix this issue, you can stop the app.\n\nIf this keeps happening, you may need to uninstall the app to improve battery performance.</string>

    <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_stop_message_wakeup_alarm" product="default">Your phone can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps waking up your phone.\n\nTo try to fix this issue, you can stop <xliff:g id="app">%1$s</xliff:g>.\n\nIf this keeps happening, you may need to uninstall the app to improve battery performance.</string>
    <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_stop_message_wakeup_alarm" product="tablet">Your tablet can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps waking up your tablet.\n\nTo try to fix this issue, you can stop <xliff:g id="app">%1$s</xliff:g>.\n\nIf this keeps happening, you may need to uninstall the app to improve battery performance.</string>
    <!-- Message body for force stop dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_stop_message_wakeup_alarm" product="device">Your device can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps waking up your device.\n\nTo try to fix this issue, you can stop <xliff:g id="app">%1$s</xliff:g>.\n\nIf this keeps happening, you may need to uninstall the app to improve battery performance.</string>

    <!-- Text for OK button in force stop dialog [CHAR LIMIT=30] -->
    <string name="dialog_stop_ok">Stop app</string>

    <!-- Title for background usage dialog [CHAR LIMIT=70] -->
    <string name="dialog_background_check_title">Turn off background usage &amp; stop app?</string>
    <!-- Message body for background usage dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_background_check_message" product="default">Your phone can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps waking up your phone.\n\nTo try to fix this issue, you can stop <xliff:g id="app">%1$s</xliff:g> and prevent it from running in the background.</string>
    <!-- Message body for background usage dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_background_check_message" product="tablet">Your tablet can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps waking up your tablet.\n\nTo try to fix this issue, you can stop <xliff:g id="app">%1$s</xliff:g> and prevent it from running in the background.</string>
    <!-- Message body for background usage dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_background_check_message" product="device">Your device can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps waking up your device.\n\nTo try to fix this issue, you can stop <xliff:g id="app">%1$s</xliff:g> and prevent it from running in the background.</string>
    <!-- Text for OK button in background usage dialog [CHAR LIMIT=30] -->
    <string name="dialog_background_check_ok">Turn off</string>

    <!-- Title for location dialog [CHAR LIMIT=60] -->
    <string name="dialog_location_title">Turn off location?</string>
    <!-- Message body for location dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_location_message" product="default">Your phone can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps requesting your location when you\'re not using the app.\n\nTo fix this issue, you can turn off location for this app.</string>
    <!-- Message body for location dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_location_message" product="tablet">Your tablet can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps requesting your location when you\'re not using the app.\n\nTo fix this issue, you can turn off location for this app.</string>
    <!-- Message body for location dialog [CHAR LIMIT=NONE] -->
    <string name="dialog_location_message" product="device">Your device can\'t manage battery normally because <xliff:g id="app">%1$s</xliff:g> keeps requesting your location when you\'re not using the app.\n\nTo fix this issue, you can turn off location for this app.</string>

    <!-- Text for OK button in location dialog [CHAR LIMIT=30] -->
    <string name="dialog_location_ok">Turn off</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 Mobile network idle -->
    <string name="power_cell">Mobile network 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>

    <!-- Description for battery usage time for an app, i.e. Used for 30min. Note: ^1 should be used in all translations [CHAR LIMIT=60] -->
    <string name="battery_used_for">Used for <xliff:g id="time">^1</xliff:g></string>
    <!-- Description for battery usage background time for an app, i.e. Active for 30min. Note: ^1 should be used in all translations [CHAR LIMIT=60] -->
    <string name="battery_active_for">Active for <xliff:g id="time">^1</xliff:g></string>
    <!-- Description for battery screen usage time for an app, i.e. Screen usage 30min. Note: ^1 should be used in all translations [CHAR LIMIT=60] -->
    <string name="battery_screen_usage">Screen usage <xliff:g id="time">^1</xliff:g></string>
    <!-- Description for battery usage info for an app, i.e. 60% used by facebook. [CHAR LIMIT=60] -->
    <string name="battery_used_by"><xliff:g id="percent">%1$s</xliff:g> used by <xliff:g id="app">%2$s</xliff:g></string>
    <!-- Description for percentage of battery usage for an app, i.e. Screen: 30% of overall battery. [CHAR LIMIT=60] -->
    <string name="battery_overall_usage"><xliff:g id="percent">%1$s</xliff:g> of overall battery</string>
    <!-- Description for battery usage detail information since last full charge. [CHAR LIMIT=120] -->
    <string name="battery_detail_since_full_charge">Breakdown since last full charge</string>
    <!-- Title for usage time since last full charge. [CHAR LIMIT=60] -->
    <string name="battery_last_full_charge">Last full charge</string>
    <!-- Title for usage time that full charge lasts. [CHAR LIMIT=60] -->
    <string name="battery_full_charge_last">Full charge lasts about</string>
    <!-- Description for text in battery footer. [CHAR LIMIT=NONE] -->
    <string name="battery_footer_summary">Battery usage data is approximate and can change based on usage</string>
    <!-- Title for text that shows the amount of time an app has been running while in the foreground. [CHAR LIMIT=80] -->
    <string name="battery_detail_foreground">While in active use</string>
    <!-- Title for text that shows the amount of time an app has been running while in the background. [CHAR LIMIT=80] -->
    <string name="battery_detail_background">While in background</string>
    <!-- Title for battery usage amount by this app. [CHAR LIMIT=80] -->
    <string name="battery_detail_power_usage">Battery usage</string>
    <!-- Title for the battery usage group, which means all the battery data are calculated 'since full charge' [CHAR LIMIT=40] -->
    <string name ="battery_detail_info_title">Since full charge</string>
    <!-- Title for the battery management group [CHAR LIMIT=40] -->
    <string name ="battery_detail_manage_title">Manage battery usage</string>

    <!-- Graph subtext displayed to user when enhanced battery estimate is being used [CHAR LIMIT=120] -->
    <string name="advanced_battery_graph_subtext">Battery left estimate is based on your device usage</string>

    <!-- Description for battery time left, i.e. 50min Estimated time left. [CHAR LIMIT=80]-->
    <string name="estimated_time_left">Estimated time left</string>

    <!-- Description for charging time left, i.e. 50min until fully charged [CHAR LIMIT=80]-->
    <string name="estimated_charging_time_left">Until fully charged</string>

    <!-- Description for estimated time. [CHAR LIMIT=80]-->
    <string name="estimated_time_description">Estimate may change based on usage</string>

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

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

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

    <!-- Battery saver: Label for preference to turn on battery saver automatically when battery is low [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_title">Turn on automatically</string>

    <!-- Battery saver: Label for preference to indicate there is no battery saver schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_no_schedule">No schedule</string>

    <!-- Battery saver: Label for preference to indicate there is a routine based schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_routine">Based on your routine</string>

    <!-- Battery saver: Label for preference to indicate there is a percentage based schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_percentage">Based on percentage</string>

    <!-- Battery saver: Summary for preference to describe what is meant by a routine based schedule [CHAR_LIMIT=NONE] -->
    <string name="battery_saver_auto_routine_summary">Battery Saver turns on if your battery is likely to run out before your next typical charge</string>

    <!-- Battery saver: Label for seekbar to change battery saver threshold [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_percentage_summary">Will turn on at <xliff:g id="percent" example="52%">%1$s</xliff:g></string>

    <!-- Battery saver: Title for battery saver schedule screen [CHAR_LIMIT=40] -->
    <string name="battery_saver_schedule_settings_title">Set a schedule</string>

    <!-- Battery saver: Summary text displayed below "Turn on" button for battery saver [CHAR_LIMIT=40] -->
    <string name="battery_saver_turn_on_summary">Extend battery life</string>

    <!-- Battery Saver: Title for sticky battery saver preference [CHAR_LIMIT=60] -->
    <string name="battery_saver_sticky_title_new">Turn off when fully charged</string>

    <!-- Battery Saver: Description for sticky battery saver preference [CHAR_LIMIT=NONE] -->
    <string name="battery_saver_sticky_description_new" product="default">Battery Saver turns off when your phone is at <xliff:g id="percent" example="90%">%1$s</xliff:g></string>
    <!-- Battery Saver: Description for sticky battery saver preference [CHAR_LIMIT=NONE] -->
    <string name="battery_saver_sticky_description_new" product="tablet">Battery Saver turns off when your tablet is at <xliff:g id="percent" example="90%">%1$s</xliff:g></string>
    <!-- Battery Saver: Description for sticky battery saver preference [CHAR_LIMIT=NONE] -->
    <string name="battery_saver_sticky_description_new" product="device">Battery Saver turns off when your device is at <xliff:g id="percent" example="90%">%1$s</xliff:g></string>

    <!-- Battery saver: Label for seekbar to change battery saver threshold [CHAR_LIMIT=40] -->
    <string name="battery_saver_seekbar_title"><xliff:g id="percent">%1$s</xliff:g></string>

    <!-- Battery saver: Placeholder label for seekbar to change battery saver threshold [CHAR_LIMIT=40] -->
    <string name="battery_saver_seekbar_title_placeholder">Turn on</string>

    <!-- Used in the Battery Saver settings screen to control turning on/off the feature entirely -->
    <string name="battery_saver_master_switch_title">Use 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 <xliff:g id="percent">%1$s</xliff:g> battery</string>

    <!-- [CHAR_LIMIT=40] Battery percentage: Title -->
    <string name="battery_percentage">Battery percentage</string>
    <!-- [CHAR_LIMIT=NONE] Battery percentage: Description for preference -->
    <string name="battery_percentage_description">Show battery percentage in status bar</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] 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>

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

    <!-- [CHAR LIMIT=50] The text for the settings section that is used to set a preferred text to speech engine -->
    <string name="tts_engine_preference_title">Preferred engine</string>
    <!-- [CHAR LIMIT=50] The text for a settings screen of the currently set text to speech engine -->
    <string name="tts_engine_settings_title">Engine settings</string>
    <!-- [CHAR LIMIT=50] The text for a button that goes to the speech rate and pitch settings for text to speech. -->
    <string name="tts_sliders_title">Speech rate &amp; pitch</string>
    <!-- [CHAR LIMIT=50] Name for the general text to speech settings section. -->
    <string name="tts_engine_section_title">Engine</string>
    <!-- [CHAR LIMIT=50] Name for the button that goes to the voice selection screen. -->
    <string name="tts_install_voice_title">Voices</string>

    <!-- The text for the settings to choose the language to use on TTS.-->
    <string name="tts_spoken_language">Spoken Language</string>

    <!-- Title of the pop-up to install 3P voices on first use. -->
    <string name="tts_install_voices_title">Install Voices</string>
    <!-- Text of the pop-up to install 3P voices on first use. -->
    <string name="tts_install_voices_text">Continue to the <xliff:g id="tts_app_name">%s</xliff:g> app to install voices</string>
    <!-- Text of the button on the pop-up to install 3P voices on first use to procedd to the 3p app. -->
    <string name="tts_install_voices_open">Open App</string>
    <!-- Text of the button on the pop-up to install 3P voices on first use to cancel the operation. -->
    <string name="tts_install_voices_cancel">Cancel</string>

    <!-- Name for button that resets speech rate and pitch for synthesized voice to default values in the text to speech settings.-->
    <string name="tts_reset">Reset</string>

    <!-- Name for buttont hat plays a sample of the currently selected text-to-speech engine. -->
    <string name="tts_play">Play</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 [CHAR LIMIT=30] -->
    <string name="credentials_install">Install a certificate</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>
    <!-- Description of dialog to reset credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_hint">Remove all the contents?</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>
    <!-- Title of Usage Access preference item [CHAR LIMIT=30] -->
    <string name="usage_access_title">Apps with usage access</string>
    <!-- Title of CA certificate [CHAR LIMIT=30] -->
    <string name="ca_certificate">CA certificate</string>
    <!-- Title of User certificate [CHAR LIMIT=30] -->
    <string name="user_certificate">VPN &amp; app user certificate</string>
    <!-- Title of Wi-Fi certificate [CHAR LIMIT=30] -->
    <string name="wifi_certificate">Wi\u2011Fi certificate</string>
    <!-- Title of warning shown to the user before they can install a CA certificate [CHAR LIMIT=NONE] -->
    <string name="ca_certificate_warning_title">Your privacy is at risk</string>
    <!-- Description of warning shown to the user before they can install a CA certificate [CHAR LIMIT=NONE] -->
    <string name="ca_certificate_warning_description">CA certificates are used by websites, apps, and VPNs for encryption. Only install CA certificates from organizations you trust. \n\n If you install a CA certificate, the certificate owner could access your information, such as passwords, messages, or credit card details, from websites you visit or apps you use - even if that information is encrypted.</string>
    <!-- Label for button to not install a certificate [CHAR_LIMIT=50] -->
    <string name="certificate_warning_dont_install">Don\u2019t install</string>
    <!-- Label for button to continue installing a certificate [CHAR_LIMIT=50] -->
    <string name="certificate_warning_install_anyway">Install anyways</string>
    <!-- Toast message that a certificate was not installed -->
    <string name="cert_not_installed">Certificate not installed</string>

    <!-- Sound settings screen, setting check box label -->
    <string name="emergency_tone_title">Emergency dialing signal</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 and activity title -->
    <string name="privacy_settings_title">Backup</string>
    <!-- Summary for the Backup settings when it is turned on. -->
    <string name="backup_summary_state_on">On</string>
    <!-- Summary for the Backup settings when it is turned off. -->
    <string name="backup_summary_state_off">Off</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>
    <!-- Configure backup account menu title [CHAR LIMIT=50]-->
    <string name="backup_data_management_title">Manage 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 isn\'t active</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 app settings screen --><skip />
    <!-- Device admin app settings activity title -->
    <string name="device_admin_settings_title">Device admin settings</string>
    <!-- Label for screen showing the active device admin apps -->
    <string name="active_device_admin_msg">Device admin app</string>
    <!-- Label for button to remove the active device admin app [CHAR LIMIT=80] -->
    <string name="remove_device_admin">Deactivate this device admin app</string>
    <!-- Label for button to uninstall the device admin app [CHAR LIMIT=80] -->
    <string name="uninstall_device_admin">Uninstall app</string>
    <!-- Label for button to deactivate and uninstall the device admin app [CHAR_LIMIT=50]-->
    <string name="remove_and_uninstall_device_admin">Deactivate &amp; uninstall</string>
    <!-- Label for screen showing to select device admin apps -->
    <string name="select_device_admin_msg">Device admin apps</string>

    <!-- Message when there are no available device admin apps to display -->
    <string name="no_device_admins">No device admin apps available</string>

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

    <!-- Title for screen to add a device admin app [CHAR LIMIT=40] -->
    <string name="add_device_admin_msg">Activate device admin app?</string>
    <!-- Label for button to set the active device admin [CHAR_LIMIT=80] -->
    <string name="add_device_admin">Activate this device admin app</string>
    <!-- Device admin add activity title -->
    <string name="device_admin_add_title">Device admin</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_warning">Activating this admin app will allow
        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>
    <!-- Simplified device admin warning message [CHAR LIMIT=NONE]-->
    <string name="device_admin_warning_simplified">This device will be managed and monitored by
        <xliff:g id="app_name" example="Example Supervisor">%1$s</xliff:g>.</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_status">This admin app 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>
    <!-- Simplified title for dialog to set a profile owner [CHAR LIMIT=40] -->
    <string name="profile_owner_add_title_simplified">Allow supervision?</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
        admin which may also be able to store associated data, in addition to your personal
        data.\n\nYour admin has the ability to monitor and manage settings, access, apps,
        and data associated with this user, including network activity and your device\'s 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 admin</string>
    <string name="admin_more_details">More details</string>
    <string name="notification_log_title">Notification log</string>

    <string name="notification_history_title">Notification history</string>
    <string name="notification_history_today">Today</string>
    <string name="notification_history_snooze">Snoozed</string>
    <string name="notification_history_dismiss">Recently dismissed</string>

    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <plurals name="notification_history_count">
        <item quantity="one"><xliff:g id="number">%d</xliff:g> notification</item>
        <item quantity="other"><xliff:g id="number">%d</xliff:g> notifications</item>
    </plurals>

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

    <!-- 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>
    <!-- This string is the title of a setting. If a user taps the setting, they can turn their work profile on or off. The work profile is a section of their phone that's managed by their employer. "Work" is an adjective. -->
    <string name="work_mode_label">Work profile</string>
    <!-- This string is located under a setting and describes what the setting does. It's letting a user know whether their work profile is on or off, and they can use the setting to turn it on or off. The work profile is a section of their phone that's managed by their employer. "Work" is an adjective.-->
    <string name="work_mode_on_summary">Managed by your organization</string>
    <!-- This string is located under a setting and describes what the setting does. It's letting a user know whether their work profile is on or off, and they can use the setting to turn it on or off. The work profile is a section of their phone that's managed by their employer. "Work" is an adjective.-->
    <string name="work_mode_off_summary">Apps and notifications are off</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>
    <!-- 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>
    <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
    <string name="really_remove_account_message" product="device">Removing this account will delete all of its messages, contacts, and other data from the device!</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\'t allowed by your admin</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>

    <!-- 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 Mobile data & WI-FI summary. [CHAR LIMIT=40] -->
    <string name="data_usage_app_summary_title">Mobile data &amp; Wi\u2011Fi</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">Mobile 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>
    <!-- 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 mobile data?</string>
    <!-- Checkbox label that will disable mobile network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_mobile_limit">Set mobile data limit</string>
    <!-- Checkbox label that will disable 4G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_4g_limit">Set 4G data limit</string>
    <!-- Checkbox label that will disable 2G-3G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_3g_limit">Set 2G-3G data limit</string>
    <!-- Checkbox label that will disable Wi-Fi network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_wifi_limit">Set Wi\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">Mobile</string>
    <!-- Tab title for showing 4G data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_4g">4G</string>
    <!-- Tab title for showing 2G and 3G data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_3g">2G-3G</string>

    <!-- Title shown when current operation applies to mobile networks. [CHAR LIMIT=20] -->
    <string name="data_usage_list_mobile">Mobile</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">Mobile data</string>
    <!-- Toggle switch title for enabling 2G and 3G data network connections. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_3g">2G-3G data</string>
    <!-- Toggle switch title for enabling 4G data network connection. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_4g">4G data</string>
    <!-- Toggle switch title for enabling roaming on the primary data SIM card. [CHAR LIMIT=32] -->
    <string name="data_roaming_enable_mobile">Roaming</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 mobile 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 mobile data limit.</string>
    <!-- Title of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=48] -->
    <string name="data_usage_app_restrict_dialog_title">Restrict background data?</string>
    <!-- Body of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_app_restrict_dialog">This feature may cause an app that depends on background data to stop working when only mobile networks are available.\n\nYou can find more appropriate data usage controls in the settings available within the app.</string>
    <!-- Body of dialog shown when user attempts to restrict background data before a network data limit has been set. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_denied_dialog">Restricting background data is possible only when you\u2019ve set a mobile data limit.</string>
    <!--  Title of dialog shown when user enables global auto sync [CHAR LIMIT=32] -->
    <string name="data_usage_auto_sync_on_dialog_title">Turn auto-sync data on?</string>
    <!--  Body of dialog shown when user enables global auto sync, for tablet [CHAR LIMIT=none] -->
    <string name="data_usage_auto_sync_on_dialog" product="tablet">Any changes you make to your accounts on the web will be automatically copied to your tablet.\n\nSome accounts may also automatically copy any changes you make on the tablet to the web. A Google Account works this way.</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 mobile 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 mobile data once it reaches the limit you set.\n\nSince data usage is measured by your phone, and your carrier may account for usage differently, consider setting a conservative limit.</string>

    <!-- Title of dialog shown before user restricts background data usage. [CHAR LIMIT=48] -->
    <string name="data_usage_restrict_background_title">Restrict background data?</string>
    <!-- Body of dialog shown before user restricts background data usage. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background">If you restrict background mobile data, some apps and services won\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 mobile 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 mobile 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 mobile networks 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">Mobile 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>

    <!-- Option for indicating that a network being metered (expensive) should be determined automatically. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_auto">Automatic</string>
    <!-- Title for Network usage to control whether Wifi is metered or not [CHAR LIMIT=20] -->
    <string name="wifi_metered_title">Network usage</string>
    <!-- Option for indicating that a network is metered (expensive). [CHAR LIMIT=32] -->
    <string name="data_usage_metered_yes">Metered</string>
    <!-- Option for indicating that a network is not metered (inexpensive). [CHAR LIMIT=32] -->
    <string name="data_usage_metered_no">Not metered</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>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        the selected VPN type doesn't support always-on. [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_type">This VPN type can\'t stay connected at all
        times</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        the server address is not in numeric form (e.g. 8.8.8.8). [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_server">Always-on VPN only supports numeric server
        addresses</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        no DNS is found. [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_no_dns">A DNS server must be specified for always-on
        VPN</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        DNS server addresses are not in numeric form (e.g. 8.8.8.8). [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_dns">DNS server addresses must be numeric for
        always-on VPN</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        generic error. [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_other">The information entered doesn\'t support
        always-on VPN</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">When this setting is on, 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 always-on VPN checkbox. [CHAR LIMIT=40] -->
    <string name="vpn_always_on_summary">Stay connected to VPN at all times</string>
    <!-- Preference summary for app not supporting always-on VPN [CHAR LIMIT=40] -->
    <string name="vpn_always_on_summary_not_supported">Not supported by this app</string>
    <!-- Preference summary for a VPN app that is set to be always-on. [CHAR LIMIT=40]  -->
    <string name="vpn_always_on_summary_active">Always-on active</string>
    <!-- Preference title for the toggle that controls whether to force all network connections to
        go through VPN. [CHAR LIMIT=40] -->
    <string name="vpn_require_connection">Block connections without VPN</string>
    <!-- Dialog message title to confirm forcing all network connections to go through VPN.
        [CHAR LIMIT=40] -->
    <string name="vpn_require_connection_title">Require VPN connection?</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 VPN has disconnected automatically due to Clear credentials. [CHAR LIMIT=NONE] -->
    <string name="vpn_disconnected">Disconnected from VPN</string>
    <!-- Seting subtext indicating the device is not currently connected to any VPN [CHAR LIMIT=40]-->
    <string name="vpn_disconnected_summary">None</string>
    <!-- Toast message when a certificate is missing. [CHAR LIMIT=100] -->
    <string name="vpn_missing_cert">A certificate is missing. Try editing 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>
    <!-- Placeholder for the list of installed user credentials (private keys) when the list is empty. [CHAR LIMIT=120] -->
    <string name="user_credential_none_installed">No user credentials installed</string>

    <!--  Title for spell checker settings -->
    <string name="spellcheckers_settings_title">Spell checker</string>
    <!--  Title for spell checker settings for work [CHAR LIMIT=45]-->
    <string name="spellcheckers_settings_for_work_title">Spell checker for work</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>

    <!-- 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 screen title [CHAR LIMIT=40] -->
    <string name="user_settings_title">Multiple users</string>
    <!-- User settings screen footer text [CHAR LIMIT=NONE] -->
    <string name="user_settings_footer_text" product="device">Share your device by adding new users. Each user has a personal space on your device for custom Home screens, accounts, apps, settings, and more.</string>
    <!-- User settings screen footer text [CHAR LIMIT=NONE] -->
    <string name="user_settings_footer_text" product="tablet">Share your tablet by adding new users. Each user has a personal space on your tablet for custom Home screens, accounts, apps, settings, and more.</string>
    <!-- User settings screen footer text [CHAR LIMIT=NONE] -->
    <string name="user_settings_footer_text" product="default">Share your phone by adding new users. Each user has a personal space on your phone for custom Home screens, accounts, apps, settings, and more.</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. Accessibility settings and services may not transfer to the new user.</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 screen [CHAR LIMIT=50] -->
    <string name="user_add_on_lockscreen_menu">Add users from lock screen</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">Delete 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">Delete 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>
    <!-- Summary for the emergency info preference [CHAR LIMIT=40] -->
    <string name="emergency_info_summary">Info &amp; contacts for <xliff:g id="user_name" example="Jason">%1$s</xliff:g></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>

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

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

    <!-- Summary text for support setting tile [CHAR LIMIT=None] -->
    <string name="support_summary">Help articles, phone &amp; chat, getting started</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, manage apps storage [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_storage" translatable="false"></string>
    <!-- Help URI, manage apps power [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_high_power" translatable="false"></string>
    <!-- Help URI, manage apps overlay [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_overlay" translatable="false"></string>
    <!-- Help URI, manage apps write settings [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_write_settings" translatable="false"></string>
    <!-- Help URI, manage apps manage sources [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_manage_sources" translatable="false"></string>
    <!-- Help URI, manage apps games [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_games" translatable="false"></string>
    <!-- Help URI, manage apps movies [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_movies" translatable="false"></string>
    <!-- Help URI, manage apps photography [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_photography" translatable="false"></string>
    <!-- Help URI, manage apps wifi access [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_wifi_access" translatable="false"></string>
    <!-- Help URI, manage apps that have access to all files [DO NOT TRANSLATE] -->
    <string name="help_uri_manage_external_storage" 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, WiFi Direct [DO NOT TRANSLATE] -->
    <string name="help_url_wifi_p2p" 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, Encryption settings [DO NOT TRANSLATE] -->
    <string name="help_url_encryption" translatable="false"></string>
    <!-- Help URL, Install certificate settings [DO NOT TRANSLATE] -->
    <string name="help_url_install_certificate" 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, Face [DO NOT TRANSLATE] -->
    <string name="help_url_face" 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>
    <!-- Help URL, Font size [DO NOT TRANSLATE] -->
    <string name="help_url_font_size" translatable="false"></string>
    <!-- Help URL, Display size [DO NOT TRANSLATE] -->
    <string name="help_url_display_size" translatable="false"></string>
    <!-- Help URL, Auto brightness [DO NOT TRANSLATE] -->
    <string name="help_url_auto_brightness" translatable="false" />
    <!-- Help URL, Adaptive sleep [DO NOT TRANSLATE] -->
    <string name="help_url_adaptive_sleep" translatable="false" />
    <!-- Help URL, Previously connected bluetooth devices [DO NOT TRANSLATE] -->
    <string name="help_url_previously_connected_devices" translatable="false"></string>
    <!-- Help URL, Top level privacy settings [DO NOT TRANSLATE] -->
    <string name="help_url_privacy_dashboard" translatable="false"></string>

    <string name="help_url_network_dashboard" translatable="false"></string>
    <string name="help_url_connected_devices" translatable="false"></string>
    <string name="help_url_apps_and_notifications" translatable="false"></string>
    <string name="help_url_night_display" translatable="false"></string>
    <string name="help_url_dark_theme" translatable="false"></string>
    <string name="help_url_screen_saver" translatable="false"></string>
    <string name="help_url_pickup_gesture" translatable="false"></string>
    <string name="help_url_storage_dashboard" translatable="false"></string>
    <string name="help_url_lockscreen" translatable="false"></string>
    <string name="help_url_trust_agent" translatable="false"></string>
    <string name="help_url_usage_access" translatable="false"></string>
    <string name="help_url_screen_pinning" translatable="false"></string>
    <string name="help_url_user_and_account_dashboard" translatable="false"></string>
    <string name="help_url_accessibility_shortcut" translatable="false"></string>
    <string name="help_url_magnification" translatable="false"></string>
    <string name="help_url_color_correction" translatable="false"></string>
    <string name="help_url_autoclick" translatable="false"></string>
    <!-- Help URL, Accessibility caption preferences [DO NOT TRANSLATE] -->
    <string name="help_url_caption" translatable="false"></string>
    <string name="help_url_system_dashboard" translatable="false"></string>
    <string name="help_url_double_tap_screen" translatable="false"></string>
    <string name="help_url_account_detail" translatable="false"></string>
    <string name="help_url_icc_lock" translatable="false"></string>
    <string name="help_uri_process_stats_summary" translatable="false"></string>
    <string name="help_uri_process_stats_apps" translatable="false"></string>
    <string name="help_uri_private_dns" translatable="false"></string>
    <string name="help_uri_about_phone_v2" translatable="false"></string>
    <string name="help_uri_wifi_calling" translatable="false"></string>
    <!-- url for the wifi scanning required dialog help page -->
    <string name="help_uri_wifi_scanning_required" translatable="false"></string>
    <!-- url for the bluetooth toggle required dialog help page -->
    <string name="help_uri_bluetooth_screen" translatable="false"></string>
    <!-- url for the SIM combination warning required dialog help page -->
    <string name="help_uri_sim_combination_warning" translatable="false"></string>
    <!-- url for the NFC and payment settings page -->
    <string name="help_uri_nfc_and_payment_settings" 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 alerts</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">VoLTE</string>
    <!-- Enhaced 4G LTE Mode title for carriers who want to show Advanced Calling.  [CHAR LIMIT=50] -->
    <string name="enhanced_4g_lte_mode_title_advanced_calling">Advanced Calling</string>
    <!-- Enhaced 4G LTE Mode title for carriers who want to show 4G Calling.  [CHAR LIMIT=50] -->
    <string name="enhanced_4g_lte_mode_title_4g_calling">4G Calling</string>
    <!-- Enhaced 4G LTE Mode summary.  [CHAR LIMIT=100] -->
    <string name="enhanced_4g_lte_mode_summary">Use LTE services to improve voice and other communications (recommended)</string>
    <!-- Enhaced 4G LTE Mode summary for 4g calling.  [CHAR LIMIT=100] -->
    <string name="enhanced_4g_lte_mode_summary_4g_calling">Use 4G services to improve voice and other communications (recommended)</string>
    <!-- Title of a preference determining whether or not the user has enabled contact discovery,
         which is a service that uses the phone numbers in your contacts to determine if your
         contacts support advanced calling features, such as video calling. [CHAR LIMIT=50]-->
    <string name="contact_discovery_opt_in_title">Contact discovery</string>
    <!-- Summary of a preference determining whether or not the user has enabled contact discovery.
         [CHAR LIMIT=100] -->
    <string name="contact_discovery_opt_in_summary">Allows your carrier to discover which calling features your contacts support.</string>
    <!-- Title of the dialog shown when the user tries to enable Contact Discovery.
         [CHAR LIMIT=50] -->
    <string name="contact_discovery_opt_in_dialog_title">Enable contact discovery?</string>
    <!-- Text displayed in the dialog shown when the user tries to enable Contact Discovery.
         [CHAR LIMIT=NONE]-->
    <string name="contact_discovery_opt_in_dialog_message">Enabling this feature will allow your carrier access to phone numbers in your contacts in order to discover which calling features they support.</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>
    <!-- Title of multimedia messaging service settings.  [CHAR LIMIT=50] -->
    <string name="mms_message_title">MMS messages</string>
    <!-- Summary of multimedia messaging service settings.  [CHAR LIMIT=100] -->
    <string name="mms_message_summary">Send &amp; receive when mobile data is off</string>

    <!-- Title of a preference for whether to allow data during calls that is shown when mobile
         data is turned off. This is needed for some multi-SIM scenarios, because the SIM that is
         default for data might not be available during a phone call. [CHAR LIMIT=60] -->
    <string name="data_during_calls_title">Data during calls</string>
    <!-- Title of a preference for whether to allow data during calls that is shown when mobile
         data is turned off. This is needed for some multi-SIM scenarios, because the SIM that is
         default for data might not be available during a phone call. [CHAR LIMIT=NONE] -->
    <string name="data_during_calls_summary">
        Allow this SIM to be used for mobile data only during calls
    </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 finish button label [CHAR LIMIT=25] -->
    <string name="wizard_finish">Finish</string>

    <!-- An option in a photo selection dialog to take a new photo [CHAR LIMIT=50] -->
    <string name="user_image_take_photo" msgid="7496128293167402354">Take a photo</string>
    <!-- An option in a photo selection dialog to choose a pre-existing image [CHAR LIMIT=50] -->
    <string name="user_image_choose_photo" msgid="3746334626214970837">Choose an image</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">Mobile 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 selecting sim for SMS in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_sms">Select a SIM for SMS</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 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>
    <!-- SIM status title  [CHAR LIMIT=40] -->
    <string name="sim_status_title_sim_slot">SIM status (sim slot %1$d)</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>

    <!-- 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>
    <!-- Title for SIM selection notification channel -->
    <string name="sim_selection_channel_title">SIM selection</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>
    <!-- Summary for Network and Internet settings, explaining it contains mobile network setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_mobile">mobile</string>
    <!-- Summary for Network and Internet settings, explaining it contains network data usage setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_data_usage">data usage</string>
    <!-- Summary for Network and Internet settings, explaining it contains hotspot (tethering) setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_hotspot">hotspot</string>

    <!-- Title for setting tile leading to Connected devices settings [CHAR LIMIT=40]-->
    <string name="connected_devices_dashboard_title">Connected devices</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_summary">Bluetooth, driving mode, NFC</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_no_nfc_summary">Bluetooth, driving mode</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_no_driving_mode_summary">Bluetooth, NFC</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary">Bluetooth</string>
    <!-- Summary for Tap & pay settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary">Unavailable because NFC is off</string>
    <!-- Title for setting tile leading to Apps & Notification settings [CHAR LIMIT=40]-->
    <string name="app_and_notification_dashboard_title">Apps &amp; notifications</string>
    <!-- Summary for Apps & Notification settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="app_and_notification_dashboard_summary">Recent apps, default apps</string>
    <!-- Toast shown when an app in the work profile attempts to open notification settings. The apps in the work profile cannot access notification settings. [CHAR LIMIT=NONE] -->
    <string name="notification_settings_work_profile">Notification access is not available for apps in the work profile.</string>
    <!-- Title for setting tile leading to account settings [CHAR LIMIT=40]-->
    <string name="account_dashboard_title">Accounts</string>
    <!-- Summary for account settings tiles when there is no accounts on device [CHAR LIMIT=NONE]-->
    <string name="account_dashboard_default_summary">No accounts added</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 important setting items under system setting [CHAR LIMIT=NONE]-->
    <string name="system_dashboard_summary">Languages, gestures, time, backup</string>

    <!-- Search strings -->
    <!-- Text to describe the search results fragment title [CHAR LIMIT=16] -->
    <string name="search_results_title">Settings</string>
    <!-- Search breadcrumb connector symbol -->
    <string name="search_breadcrumb_connector" translatable="false">
        <xliff:g name="first_item">%1$s</xliff:g> > <xliff:g name="second_item">%2$s</xliff:g>
    </string>

    <!--Search Keywords [CHAR LIMIT=NONE]-->
    <string name="keywords_wifi">wifi, wi-fi, network connection, internet, wireless, data, wi fi</string>
    <!-- Search keyword for "Open Network Notification" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_wifi_notify_open_networks">Wi\u2011Fi notification, wifi notification</string>
    <!-- Search keyword for "Wi-fi data usage" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_wifi_data_usage">data usage</string>
    <!-- Search keyword for "Vibrate on touch" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_vibrate_on_touch">Stop vibration, tap, keyboard</string>
    <!-- Search keyword for "Time format" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_time_format">Use 24-hour format</string>
    <!-- Search keyword for "Files" settings under Settings > Storage. [CHAR_LIMIT=NONE]-->
    <string name="keywords_storage_files">Download</string>
    <!-- Search keyword for "Default Apps" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_app_default">Open with</string>
    <!-- Search keyword for "App info" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_applications_settings">Applications</string>
    <!-- Search keyword for "Time zone" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_time_zone">timezone</string>
    <!-- Search keyword for "Display over other apps" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_draw_overlay">Chat head, system, alert, window, dialog, display, on top other apps, draw</string>

    <!-- Search keyword for "Flashlight" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_flashlight">Flashlight, Light, Torch</string>
    <string name="keywords_change_wifi_state">wifi, wi-fi, toggle, control</string>
    <string name="keywords_more_mobile_networks">cellular, mobile, cell carrier, wireless, data, 4g,3g, 2g, lte</string>
    <string name="keywords_wifi_calling">wifi, wi-fi, call, calling</string>
    <string name="keywords_display">screen, touchscreen</string>
    <string name="keywords_display_brightness_level">dim screen, touchscreen, battery, bright</string>
    <string name="keywords_display_night_display">dim screen, night, tint, night shift, brightness, screen color, colour, color</string>
    <string name="keywords_display_wallpaper">background, personalize, customize display</string>
    <string name="keywords_display_font_size">text size</string>
    <!-- Search keyword for "Cast" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_display_cast_screen">project, cast, Screen mirroring, Screen sharing, mirroring, share screen, screen casting</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, factory reset</string>
    <string name="keywords_printing">printer</string>
    <string name="keywords_sounds">speaker beep, speaker, volume, mute, silence, audio, music</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, GPS</string>
    <string name="keywords_accounts">account, add an account, work profile, add 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_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">gestures</string>
    <!-- Search keywords for Global Actions Panel. [DO NOT TRANSLATE] -->
    <string name="keywords_global_actions_panel" translatable="false">global actions</string>
    <string name="keywords_payment_settings">pay, tap, payments</string>
    <string name="keywords_backup">backup, back up</string>
    <string name="keywords_assist_gesture_launch">gesture</string>
    <string name="keywords_face_unlock">face, unlock, auth, sign in</string>
    <string name="keywords_imei_info">imei, meid, min, prl version, imei sv</string>
    <string name="keywords_sim_status">network, mobile network state, service state, signal strength, mobile network type, roaming, iccid, eid</string>
    <string name="keywords_model_and_hardware">serial number, hardware version</string>
    <string name="keywords_android_version">android security patch level, baseband version, kernel version</string>
    <!-- Search keywords for dark mode settings [CHAR LIMIT=NONE] -->
    <string name="keywords_dark_ui_mode">theme, light, dark, mode</string>

    <!-- Search keyword for Device Theme Settings [CHAR LIMIT=NONE] -->
    <string name="keywords_systemui_theme">dark theme</string>

    <!-- Search keyword for Send Device Feedback Setting [CHAR LIMIT=NONE] -->
    <string name="keywords_device_feedback">bug</string>

    <!-- Search keyword for Ambient display settings screen. -->
    <string name="keywords_ambient_display_screen">Ambient display, Lock screen display</string>

    <!-- Search keyword for lock screen notification setting [CHAR_LIMIT=NONE] -->
    <string name="keywords_lock_screen_notif">lock screen notification, notifications</string>

    <!-- Search keyword for face settings. -->
    <string name="keywords_face_settings">face</string>

    <!-- Search keyword for fingerprint settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_fingerprint_settings">fingerprint, add fingerprint</string>

    <!-- Search keywords for adaptive brightness setting [CHAR LIMIT=NONE]-->
    <string name="keywords_display_auto_brightness">dim screen, touchscreen, battery, smart brightness, dynamic brightness, Auto brightness</string>

    <!-- Search keywords for adaptive sleep setting [CHAR LIMIT=NONE]-->
    <string name="keywords_display_adaptive_sleep">dim screen, sleep, battery, timeout, attention, display, screen, inactivity</string>

    <!-- List of synonyms for the auto rotate (rotate the virtual display when the device rotates) setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_auto_rotate">rotate, flip, rotation, portrait, landscape, orientation, vertical, horizontal</string>

    <!-- List of synonyms for the System Update (update the operating system) setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_system_update_settings">upgrade, android</string>

    <!-- List of synonyms for the Do Not Disturb setting, used to match in settings search. Do Not Disturb turns of notification volume, notifications, vibrations, among other things on the device. [CHAR LIMIT=NONE] -->
    <string name="keywords_zen_mode_settings">dnd, schedule, notifications, block, silence, vibrate, sleep, work, focus, sound, mute, day, weekday, weekend, weeknight, event</string>

    <!-- List of synonyms for the display timeout (how long until the screen turns off) setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_screen_timeout">screen, lock time, timeout, lockscreen</string>

    <!-- List of synonyms for Storage settings (everything related to storage on the device), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_storage_settings">memory, cache, data, delete, clear, free, space</string>

    <!-- List of synonyms for the Bluetooth setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_bluetooth_settings">connected, device, headphones, headset, speaker, wireless, pair, earbuds, music, media </string>

    <!-- List of synonyms for the Wallpaper picker setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_wallpaper">background, screen, lockscreen, theme</string>

    <!-- List of synonyms for the Styles picker setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_styles">icon shape, accent color, font</string>

    <!-- List of synonyms for the Default Assist and Voice input setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_assist_input">default, assistant</string>

    <!-- List of synonyms for the default payment app setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_default_payment_app">payment, default</string>

    <!-- List of synonyms for Ambient display setting (when the screen is off), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_ambient_display">incoming notification</string>

    <!-- List of synonyms for hotspot and tethering setting (where you share your wifi with other devices), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_hotspot_tethering">usb tether, bluetooth tether, wifi hotspot</string>

    <!-- List of synonyms for touch vibration setting (where you get a haptic response for touching things on the screen), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_touch_vibration">haptics, vibrate, screen, sensitivity</string>

    <!-- List of synonyms for ring vibration setting (changes whether your phone vibrates when it rings), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_ring_vibration">haptics, vibrate, phone, call, sensitivity, ring</string>
    <!-- List of synonyms for notification vibration setting (changes whether your phone vibrates when it shows a notification), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_notification_vibration">haptics, vibrate, sensitivity</string>
    <!-- Battery Saver: Search terms for sticky battery saver preference [CHAR_LIMIT=NONE] -->
    <string name="keywords_battery_saver_sticky">battery saver, sticky, persist, power saver, battery</string>
    <!-- Battery Saver: Search terms for battery saver schedule preference. Feel free to add additional terms when translating if appropriate [CHAR_LIMIT=NONE] -->
    <string name="keywords_battery_saver_schedule">routine, schedule, battery saver, power saver, battery, automatic, percent</string>

    <!-- List of synonyms for the enhance 4G LTE titles, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_enhance_4g_lte">volte, advanced calling, 4g calling</string>

    <!-- List of synonyms for add language, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_add_language">add language, add a language</string>

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

    <!-- Wifi Picker defaults-->
    <!-- The minimum kbps threshold needed to use badge; value is a map with key corresponding to
    the badge enum in ScoredNetworks (SD, HD etc) and value throughput in kbps -->
    <string name="wifi_badging_thresholds_default" translatable="false">10:3000,20:5000,30:25000</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 &amp; notification volume at <xliff:g id="percentage" example="2%">%1$s</xliff:g></string>

    <!-- Summary for sound settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="sound_dashboard_summary">Volume, vibration, Do Not Disturb</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 &amp; notification 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 remote media volume. [CHAR LIMIT=30] -->
    <string name="remote_media_volume_option_title">Cast volume</string>

    <!-- Sound: Title for the option managing call volume. [CHAR LIMIT=30] -->
    <string name="call_volume_option_title">Call 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 &amp; notification 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 sound. [CHAR LIMIT=30] -->
    <string name="notification_ringtone_title">Default notification sound</string>

    <!-- Sound: Sound title for apps that have not provided a title. [CHAR LIMIT=30] -->
    <string name="notification_unknown_sound_title">App provided sound</string>

    <!-- Notification sound summary when chosen sound is the system default. -->
    <string name="notification_sound_default">Default notification sound</string>

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

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

    <!-- Sound: Option for vibrate when ringing setting: Never vibrate. [CHAR LIMIT=40] -->
    <string name="vibrate_when_ringing_option_never_vibrate">Never vibrate</string>

    <!-- Sound: Option for vibrate when ringing setting: Always vibrate. [CHAR LIMIT=40] -->
    <string name="vibrate_when_ringing_option_always_vibrate">Always vibrate</string>

    <!-- Sound: Option for vibrate when ringing setting: Ramping ringer. [CHAR LIMIT=80] -->
    <string name="vibrate_when_ringing_option_ramping_ringer">Vibrate first then ring gradually</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 and vibration. [CHAR LIMIT=50] -->
    <string name="charging_sounds_title">Charging sounds and vibration</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">Touch vibration</string>

    <!-- Sound: Other sounds: Preference summary to the option enabling haptic feedback on touch. -->
    <string name="vibrate_on_touch_summary">Haptic feedback for tap, keyboard, and more</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 dialing signal option with value 0: silence. [CHAR LIMIT=30] -->
    <string name="emergency_tone_silent">Silence</string>

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

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

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

    <!-- Setting title for controlling how caption text display in real time [CHAR LIMIT=40]-->
    <string name="live_caption_title">Live Caption</string>

    <!-- Setting summary for controlling how caption text display in real time [CHAR LIMIT=NONE]-->
    <string name="live_caption_summary">Automatically caption media</string>

    <!-- Sound: Summary for the Do not Disturb option when there is no automatic rules turned on. [CHAR LIMIT=NONE]-->
    <string name="zen_mode_settings_summary_off">Never</string>

    <!-- Sound: Summary for the Do not Disturb option when at least one automatic rules turned on. [CHAR LIMIT=NONE]-->
    <plurals name="zen_mode_settings_summary_on">
        <item quantity="one">1 enabled</item>
        <item quantity="other"><xliff:g id="on_count" example="10">%d</xliff:g> enabled</item>
    </plurals>

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

    <!-- Sound: Summary for the Do not Disturb option and associated settings page. [CHAR LIMIT=240]-->
    <string name="zen_mode_settings_summary">Only get notified by important people and apps</string>

    <!-- Subtitle for the Do not Disturb slice. [CHAR LIMIT=50]-->
    <string name="zen_mode_slice_subtitle">Limit interruptions</string>

    <!-- Do not disturb: Title for the Do not Disturb dialog to turn on Do not disturb. [CHAR LIMIT=50]-->
    <string name="zen_mode_settings_turn_on_dialog_title">Turn on Do Not Disturb</string>

    <!-- Do not disturb: Title for the page describing what can bypass DND. [CHAR LIMIT=30] -->
    <string name="zen_mode_behavior_settings_title">Exceptions</string>

    <!-- Do not disturb: Title for the dnd duration setting (user can specify how long dnd will last when toggling dnd on from qs or settings) [CHAR LIMIT=30] -->
    <string name="zen_mode_duration_settings_title">Default duration</string>

    <!-- Do not disturb: Instructions indicating what types of sounds can bypass DND. [CHAR LIMIT=52] -->
    <string name="zen_mode_behavior_allow_title">Allow sounds and vibrations from</string>

    <!-- Do not disturb: Subtitle for DND behavior indicating no sound will get past DND. [CHAR LIMIT=30] -->
    <string name="zen_mode_behavior_no_sound">No sound</string>

    <!-- Do not disturb: Subtitle for DND behavior indicating no sound will get past DND. [CHAR LIMIT=40] -->
    <string name="zen_mode_behavior_total_silence">Total Silence</string>

    <!-- Do not disturb: Used before specifying which sounds can bypass DND (ie: No sound except alarms and reminders). [CHAR LIMIT=40] -->
    <string name="zen_mode_behavior_no_sound_except">No sound except <xliff:g id="categories" example="alarms, media and system feedback">%1$s</xliff:g></string>

    <!-- Do not disturb: Specifies alarms and media can bypass DND.  [CHAR LIMIT=100] -->
    <string name="zen_mode_behavior_alarms_only">No sound except alarms and media</string>

    <!--  Do not disturb: Title for the zen mode automation option in Settings. [CHAR LIMIT=40] -->
    <string name="zen_mode_automation_settings_title">Schedules</string>

    <!--  Do not disturb: Title for dialog that allows users to delete DND rules/schedules[CHAR LIMIT=40] -->
    <string name="zen_mode_delete_automatic_rules">Delete schedules</string>

    <!--  Do not disturb: Delete text button presented in a dialog to confirm the user would like to delete the selected DND rules. [CHAR LIMIT=30] -->
    <string name="zen_mode_schedule_delete">Delete</string>

    <!--  Do not disturb: Edit label for button that allows user to edit the dnd schedule name. [CHAR LIMIT=30] -->
    <string name="zen_mode_rule_name_edit">Edit</string>

    <!--  Do not disturb: Title for the zen mode automatic rules page in settings. [CHAR LIMIT=30] -->
    <string name="zen_mode_automation_settings_page_title">Schedules</string>

    <!--  Do not disturb: Title for a specific zen mode automatic rule in settings. [CHAR LIMIT=30] -->
    <string name="zen_mode_automatic_rule_settings_page_title">Schedule</string>

    <!--  Do not disturb: Title do not disturb settings representing automatic (scheduled) do not disturb rules. [CHAR LIMIT=30] -->
    <string name="zen_mode_schedule_category_title">Schedule</string>

    <!--  Do not disturb: Title for the zen mode automation option Suggestion. [CHAR LIMIT=46] -->
    <string name="zen_mode_automation_suggestion_title">Silence phone at certain times</string>

    <!--  Do not disturb: Summary for the zen mode automation option Suggestion. [CHAR LIMIT=55] -->
    <string name="zen_mode_automation_suggestion_summary">Set Do Not Disturb rules</string>

    <!--  Do not disturb: Header for the Do Not Disturb automatic rules. [CHAR LIMIT=55] -->
    <string name="zen_mode_schedule_title">Schedule</string>

    <!--  Do not disturb: Switch toggle to toggle whether to use an automatic dnd rule or not [CHAR LIMIT=40] -->
    <string name="zen_mode_use_automatic_rule">Use schedule</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>

    <!--  Do not disturb: Subtitle for the Visual signals option to toggle on/off visual signals/alerts when the screen is on/when screen is off. [CHAR LIMIT=30] -->
    <string name="zen_mode_visual_signals_settings_subtitle">Allow visual signals</string>

    <!-- Do not disturb: zen settings screens category title [CHAR LIMIT=100] -->
    <string name="zen_mode_settings_category">Allow interruptions that make sound</string>

    <!-- Do not disturb: restrict notifications title [CHAR LIMIT=80] -->
    <string name="zen_mode_restrict_notifications_title">Restrict notifications</string>
    <!-- Do not disturb: Mute notifications option [CHAR LIMIT=60] -->
    <string name="zen_mode_restrict_notifications_mute">No sound from notifications</string>
    <!-- Do not disturb:Mute notifications summary [CHAR LIMIT=NONE] -->
    <string name="zen_mode_restrict_notifications_mute_summary">You will see notifications on your screen</string>
    <!-- Do not disturb:Mute notifications footer [CHAR LIMIT=NONE] -->
    <string name="zen_mode_restrict_notifications_mute_footer">When notifications arrive, your phone won\u2019t make a sound or vibrate.</string>
    <!-- Do not disturb: Hide notifications option [CHAR LIMIT=76] -->
    <string name="zen_mode_restrict_notifications_hide">No visuals or sound from notifications</string>
    <!-- Do not disturb: Hide notifications summary [CHAR LIMIT=NONE] -->
    <string name="zen_mode_restrict_notifications_hide_summary">You won\u2019t see or hear notifications</string>
    <!-- Do not disturb: Hide notifications footer [CHAR LIMIT=NONE] -->
    <string name="zen_mode_restrict_notifications_hide_footer">Your phone won\u2019t show, vibrate or make sound for new or existing notifications. Keep in mind, critical notifications for phone activity and status will still appear.\n\nWhen you turn off Do Not Disturb, find missed notifications by swiping down from the top of your screen.</string>
    <!-- Do not disturb: Custom settings option [CHAR LIMIT=60] -->
    <string name="zen_mode_restrict_notifications_custom">Custom</string>
    <!-- Do not disturb: restrict notifications page, menu option [CHAR LIMIT=60] -->
    <string name="zen_mode_restrict_notifications_enable_custom">Enable custom setting</string>
    <!-- Do not disturb: restrict notifications page, menu option [CHAR LIMIT=60] -->
    <string name="zen_mode_restrict_notifications_disable_custom">Remove custom setting</string>
    <!-- Do not disturb: restrict notifications page, menu option [CHAR LIMIT=60] -->
    <string name="zen_mode_restrict_notifications_summary_muted">No sound from notifications</string>
    <!-- Do not disturb: restrict notifications page, menu option [CHAR LIMIT=60] -->
    <string name="zen_mode_restrict_notifications_summary_custom">Partially hidden</string>
    <!-- Do not disturb: restrict notifications page, menu option [CHAR LIMIT=100] -->
    <string name="zen_mode_restrict_notifications_summary_hidden">No visuals or sound from notifications</string>

    <!-- Do not disturb: what to block title [CHAR LIMIT = 60] -->
    <string name="zen_mode_what_to_block_title">Custom restrictions</string>
    <!-- Do not disturb: what to block > effects title [CHAR LIMIT = 60] -->
    <string name="zen_mode_block_effects_screen_on">When the screen is on</string>
    <!-- Do not disturb: what to block > effects title [CHAR LIMIT = 60] -->
    <string name="zen_mode_block_effects_screen_off">When the screen is off</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_sound">Mute sound and vibration</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_intent">Don\'t turn on screen</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_light">Don\'t blink light</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_peek">Don\'t pop notifications on screen</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_status">Hide status bar icons at top of screen</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_badge">Hide notification dots on app icons</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_ambient">Don\'t wake for notifications</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_list">Hide from pull-down shade</string>

    <!-- Do not disturb: what to block summary, none -->
    <string name="zen_mode_block_effect_summary_none">Never</string>
    <!-- Do not disturb: what to block summary, screen off -->
    <string name="zen_mode_block_effect_summary_screen_off">When screen is off</string>
    <!-- Do not disturb: what to block summary, screen on -->
    <string name="zen_mode_block_effect_summary_screen_on">When screen is on</string>
    <!-- Do not disturb: what to block summary, only sound and vibration -->
    <string name="zen_mode_block_effect_summary_sound">Sound and vibration</string>
    <!-- Do not disturb: what to block summary, sound vibration and some visual signals-->
    <string name="zen_mode_block_effect_summary_some">Sound, vibration, and some visual signs of notifications</string>
    <!-- Do not disturb: what to block summary, all effects -->
    <string name="zen_mode_block_effect_summary_all">Sound, vibration, and visual signs of notifications</string>

    <string name="zen_mode_blocked_effects_footer">Notifications needed for basic phone activity and status will never be hidden.</string>

    <!--  Do not disturb: Zen mode no sounds are exceptions to bypass do not disturb-->
    <string name="zen_mode_no_exceptions">None</string>
    <!--  Do not disturb: Zen mode catch all "other" sounds can bypass do not disturb -->
    <string name="zen_mode_other_options">other options</string>

    <!--  Do not disturb: Button to add new automatic rule to DND. [CHAR LIMIT=30] -->
    <string name="zen_mode_add">Add</string>

    <!--  Do not disturb: Label for button in enable zen dialog that will turn on zen mode. [CHAR LIMIT=30] -->
    <string name="zen_mode_enable_dialog_turn_on">Turn on</string>

    <!--  Do not disturb: Label for button that will turn on zen mode. [CHAR LIMIT=30] -->
    <string name="zen_mode_button_turn_on">Turn on now</string>

    <!--  Do not disturb: Label for button that will turn off zen mode. [CHAR LIMIT=30] -->
    <string name="zen_mode_button_turn_off">Turn off now</string>

    <!-- [CHAR LIMIT=110] Zen mode settings footer: Footer showing end time of DND -->
    <string name="zen_mode_settings_dnd_manual_end_time">Do Not Disturb is on until <xliff:g id="formatted_time" example="7:00 AM">%s</xliff:g></string>

    <!-- [CHAR LIMIT=110] Zen mode settings footer: Footer showing length of DND -->
    <string name="zen_mode_settings_dnd_manual_indefinite">Do Not Disturb will stay on until you turn it off</string>

    <!-- [CHAR LIMIT=110] Zen mode settings footer: Footer showing how DND was triggered by an automatic DND schedule -->
    <string name="zen_mode_settings_dnd_automatic_rule">Do Not Disturb was automatically turned on by a schedule (<xliff:g id="rule_name" example="Weeknights">%s</xliff:g>)</string>

    <!-- [CHAR LIMIT=110] Zen mode settings footer: Footer how DND was triggered by an app -->
    <string name="zen_mode_settings_dnd_automatic_rule_app">Do Not Disturb was automatically turned on by an app (<xliff:g id="app_name" example="Android Services">%s</xliff:g>)</string>

    <!-- [CHAR LIMIT=120] Zen mode settings footer: Footer informing user DND has custom settings. -->
    <string name="zen_mode_settings_dnd_custom_settings_footer">Do Not Disturb is on for <xliff:g id="rule_names" example="Sleeping and Work">%s</xliff:g> with custom settings.</string>

    <!-- [CHAR LIMIT=120] Zen mode settings footer: Link following zen_mode_settings_dnd_custom_settings_footer to see the currently applied custom dnd settings. -->
    <string name="zen_mode_settings_dnd_custom_settings_footer_link"><annotation id="link"> View custom settings</annotation></string>

    <!--[CHAR LIMIT=40] Zen Interruption level: Priority.  -->
    <string name="zen_interruption_level_priority">Priority only</string>

    <!-- [CHAR LIMIT=20] Accessibility string for current zen mode and selected exit condition. A template that simply concatenates existing mode string and the current condition description.  -->
    <string name="zen_mode_and_condition"><xliff:g id="zen_mode" example="Priority interruptions only">%1$s</xliff:g>. <xliff:g id="exit_condition" example="For one hour">%2$s</xliff:g></string>

    <!-- Sound settings screen, summary format of do not disturb when on with extra info. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_sound_summary_on_with_info">On / <xliff:g name="dnd_summary" example="No sound except alarms and media">%1$s</xliff:g></string>

    <!-- Sound settings screen, summary format of do not disturb when off with extra information. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_sound_summary_off_with_info">Off / <xliff:g name="dnd_summary" example="1 schedule can turn on automatically">%1$s</xliff:g></string>

    <!-- Sound settings screen, summary format of do not disturb when off with no extra information. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_sound_summary_off">Off</string>

    <!-- Sound settings screen, summary format of do not disturb when on with no extra information. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_sound_summary_on">On</string>

    <!--  Do not disturb: Summary for zen mode duration setting indicating user will be prompted to set dnd duration whenever dnd is manually toggled on [CHAR LIMIT=NONE]-->
    <string name="zen_mode_duration_summary_always_prompt">Ask every time</string>

    <!--  Do not disturb: Summary for zen mode duration setting indicating how long dnd will last when dnd is manually toggled on [CHAR LIMIT=NONE] -->
    <string name="zen_mode_duration_summary_forever">Until you turn off</string>

    <!--  Do not disturb: Summary for zen mode duration setting indicating how long dnd will last when dnd is manually toggled on [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_summary_time_hours">
        <item quantity="one">1 hour</item>
        <item quantity="other"><xliff:g id="num_hours" example="3">%d</xliff:g> hours</item>
    </plurals>

    <!--  Do not disturb: Summary for zen mode duration setting indicating how long dnd will last when toggled on -->
    <string name="zen_mode_duration_summary_time_minutes"><xliff:g id="num_minutes" example="5">%d</xliff:g> minutes</string>

    <!-- Summary for the Sound Do not Disturb option when at least one automatic rules is enabled. [CHAR LIMIT=NONE]-->
    <plurals name="zen_mode_sound_summary_summary_off_info">
        <item quantity="one">1 schedule can turn on automatically</item>
        <item quantity="other"><xliff:g id="on_count" example="3">%d</xliff:g> schedules can turn on automatically</item>
    </plurals>

    <!-- Do not disturb settings, main screen, category header [CHAR LIMIT=120]-->
    <string name="zen_category_behavior">Exceptions when Do Not Disturb is on</string>
    <!-- Do not disturb settings, main screen, field, dnd breakthrough [CHAR LIMIT=100]-->
    <string name="zen_category_people">People</string>
    <!-- Do not disturb settings, main screen, field, dnd breakthrough  [CHAR LIMIT=100]-->
    <string name="zen_category_apps">Apps</string>
    <!-- Do not disturb settings, main screen, field, dnd breakthrough  [CHAR LIMIT=100]-->
    <string name="zen_category_exceptions">Alarms &amp; other interruptions</string>
    <!-- Do not disturb settings, main screen, field, schedules [CHAR LIMIT=100]-->
    <string name="zen_category_schedule">Schedules</string>
    <!-- Do not disturb settings, main screen, field, dnd visuals [CHAR LIMIT=100]-->
    <string name="zen_category_visuals">Silenced notifications</string>

    <!-- Do not disturb settings, sound and vibrations screen footer [CHAR LIMIT=NONE]-->
    <string name="zen_sound_footer">When Do Not Disturb is on, sound and vibration will be muted, except for the items you allow above.</string>
    <!-- Do not disturb settings, sound and vibrations screen category [CHAR LIMIT=100]-->
    <string name="zen_sound_category_title">Mute all except</string>
    <!-- Do not disturb settings, sound and vibrations summary [CHAR LIMIT=100]-->
    <string name="zen_sound_all_muted">Muted</string>
    <!-- Do not disturb settings, sound and vibrations summary [CHAR LIMIT=100]-->
    <string name="zen_sound_none_muted">Not muted</string>
    <!-- Do not disturb settings, sound and vibrations summary [CHAR LIMIT=100]-->
    <string name="zen_sound_one_allowed">Muted, but allow <xliff:g id="sound_type" example="alarms">%1$s</xliff:g></string>
    <!-- Do not disturb settings, sound and vibrations summary [CHAR LIMIT=100]-->
    <string name="zen_sound_two_allowed">Muted, but allow <xliff:g id="sound_type" example="alarms">%1$s</xliff:g> and <xliff:g id="sound_type" example="media">%2$s</xliff:g></string>
    <!-- Do not disturb settings, sound and vibrations summary [CHAR LIMIT=100]-->
    <string name="zen_sound_three_allowed">Muted, but allow <xliff:g id="sound_type" example="alarms">%1$s</xliff:g>, <xliff:g id="sound_type" example="alarms">%2$s</xliff:g>, and <xliff:g id="sound_type" example="media">%3$s</xliff:g></string>

    <!-- Do not disturb custom settings dialog title [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_dialog_title">Custom settings</string>
    <!-- Do not disturb custom settings dialog button label [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_dialog_review_schedule">Review schedule</string>
    <!-- Do not disturb custom settings dialog button label [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_dialog_ok">Got it</string>
    <!-- Do not disturb custom settings notifications header [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_notifications_header">Notifications</string>
    <!-- Do not disturb custom settings duration header [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_duration_header">Duration</string>

    <!-- Do not disturb settings, messages, events and reminders title [CHAR LIMIT=100]-->
    <string name="zen_msg_event_reminder_title">Messages, events &amp; reminders</string>
    <!-- Do not disturb settings, messages, events and reminders footer [CHAR LIMIT=NONE]-->
    <string name="zen_msg_event_reminder_footer">When Do Not Disturb is on, messages, reminders, and events will be muted, except for the items you allow above. You can adjust messages settings to allow your friends, family, or other contacts to reach you.</string>

    <!-- Do not disturb onboarding dialog, accept new settings [CHAR LIMIT=30]-->
    <string name="zen_onboarding_ok">Done</string>
    <!-- Do not disturb onboarding dialog, on click user goes to dnd settings page [CHAR LIMIT=30]-->
    <string name="zen_onboarding_settings">Settings</string>

    <!-- Do not disturb onboarding dialog, title for radio button [CHAR LIMIT=80]-->
    <string name="zen_onboarding_new_setting_title">No visuals or sound from notifications</string>
    <!-- Do not disturb onboarding dialog, title for radio button [CHAR LIMIT=80]-->
    <string name="zen_onboarding_current_setting_title">No sound from notifications</string>
    <!-- Do not disturb onboarding dialog, secondary text for radio button [CHAR LIMIT=NONE]-->
    <string name="zen_onboarding_new_setting_summary">You won\u2019t see or hear notifications. Calls from starred contacts and repeat callers are allowed.</string>
    <!-- Do not disturb onboarding dialog, secondary text for radio button [CHAR LIMIT=NONE]-->
    <string name="zen_onboarding_current_setting_summary">(Current setting)</string>

    <!-- Do not disturb onboarding dialog, header prompt for settings [CHAR LIMIT=80]-->
    <string name="zen_onboarding_dnd_visual_disturbances_header">Change Do Not Disturb notification settings?</string>

    <!-- DO NOT TRANSLATE obsolete [CHAR LIMIT=NONE]-->
    <string name="zen_onboarding_dnd_visual_disturbances_description" translatable="false">Your phone can do more to help you focus.\n\nUpdate settings to:\n\n- Hide notifications completely\n\n- Allow calls from starred contacts and repeat callers</string>
    <!-- DO NOT TRANSLATE obsolete -->
    <string name="zen_onboarding_more_options" translatable="false">You can further customize this in Settings.</string>
    <!-- DO NOT TRANSLATE obsolete -->
    <string name="zen_onboarding_screen_on_title" translatable="false">Block when the screen is on</string>
    <!-- DO NOT TRANSLATE obsolete -->
    <string name="zen_onboarding_screen_off_title" translatable="false">Block when the screen is off</string>
    <!-- DO NOT TRANSLATE obsolete -->
    <string name="zen_onboarding_screen_off_summary" translatable="false">Don\'t turn on the screen or wake for notifications</string>
    <!-- DO NOT TRANSLATE obsolete -->
    <string name="zen_onboarding_screen_on_summary" translatable="false">Don\'t show notifications at all, except for basic phone activity and status</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">Sounds are the same for work and personal profiles</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 sound</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 sound</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 sounds?</string>

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

    <!-- Work Sound: Message for dialog shown when using the same sounds for work events as for personal events (notifications / ringtones / alarms). [CHAR LIMIT=none] -->
    <string name="work_sync_dialog_message">Your personal profile sounds will be used for your work profile</string>

    <!-- Sound installation: Title for the dialog to confirm that a new sound will be installed to the Ringtones, Notifications, or Alarms folder. [CHAR LIMIT=50] -->
    <string name="ringtones_install_custom_sound_title">Add custom sound?</string>

    <!-- Sound installation: Message for the dialog to confirm that a new sound will be installed to the Ringtones, Notifications, or Alarms folder. [CHAR LIMIT=none] -->
    <string name="ringtones_install_custom_sound_content">This file will be copied to the <xliff:g id="folder_name" example="Ringtones">%s</xliff:g> folder</string>

    <!-- Ringtones preference category: Title for the Ringotnes preference categories. [CHAR LIMIT=none] -->
    <string name="ringtones_category_preference_title">Ringtones</string>

    <!-- Other sounds and vibrations preference category: Title for the Other sounds and vibrations preference categories. [CHAR LIMIT=none] -->
    <string name="other_sound_category_preference_title">Other sounds and vibrations</string>

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

    <!-- notification header - apps that have recently sent notifications -->
    <string name="recent_notifications">Recently sent</string>

    <!-- Preference title for showing all apps on device [CHAR_LIMIT=50]-->
    <string name="recent_notifications_see_all_title">See all from last 7 days</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: section header for prioritizer settings  [CHAR LIMIT=80] -->
    <string name="smart_notifications_title">Adaptive notifications</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80 BACKUP_MESSAGE_ID=6691908606916292167] -->
    <string name="asst_capability_prioritizer_title">Adaptive notification priority</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_capability_prioritizer_summary">Automatically set lower priority notifications to Gentle</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80 BACKUP_MESSAGE_ID=6691908606916292167] -->
    <string name="asst_capability_ranking_title">Adaptive notification ranking</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_capability_ranking_summary">Automatically rank notifications by relevance</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80] -->
    <string name="asst_capabilities_actions_replies_title">Suggested actions and replies</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_capabilities_actions_replies_summary">Automatically show suggested actions &amp; replies</string>

    <!-- Configure notifications: settings summary [CHAR LIMIT=NONE] -->
    <string name="notification_history_summary">Turn on notification history to keep track of past notifications and snoozed notifications</string>

    <!-- Configure notifications: settings title [CHAR LIMIT=100] -->
    <string name="notification_history">Notification history</string>

    <!-- Configure notifications: settings title [CHAR LIMIT=100] -->
    <string name="notification_history_turn_on">Turn on history</string>

    <!-- Configure notifications: settings title [CHAR LIMIT=100] -->
    <string name="notification_history_turn_off">Turn off history</string>

    <!-- Notification history screen; summary when history is off [CHAR LIMIT=200] -->
    <string name="notification_history_off_title_extended">Notification history is turned off</string>

    <!-- Notification history screen; content description describing what happens when you tap on a notification history entry [CHAR LIMIT=NONE] -->
    <string name="notification_history_view_settings">view notification settings</string>

    <!-- Configure Notifications: setting title, whether the snooze menu is shown on notifications [CHAR LIMIT=80] -->
    <string name="snooze_options_title">Allow notification snoozing</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80] -->
    <string name="hide_silent_icons_title">Hide icons from gentle notifications</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=NONE] -->
    <string name="hide_silent_icons_summary">Icons from gentle notifications aren\'t shown in the status bar</string>

    <!-- Configure Notifications: Title for the notification badging option. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=5125022693565388760] -->
    <string name="notification_badging_title">Allow notification dots</string>

    <!-- Configure Notifications: Title for the people notification strip option. [CHAR LIMIT=60] -->
    <string name="notification_people_strip_title">Show strip of recent conversations</string>

    <!-- Configure Notifications: Title for the notification bubbles option. [CHAR LIMIT=60] -->
    <string name="notification_bubbles_title">Bubbles</string>
    <!-- Developer setting summary for bubbles [CHAR LIMIT=NONE] -->
    <string name="notification_bubbles_developer_setting_summary">Some notifications can appear as bubbles on the screen</string>
    <!-- Feature education for bubbles. [CHAR LIMIT=NONE] -->
    <string name="bubbles_feature_education">Some notifications and other content can appear as bubbles on the screen. To open a bubble, tap it. To dismiss it, drag it down the screen.</string>
    <!-- Title for the toggle shown on the app-level bubbles page  [CHAR LIMIT=60] -->
    <string name="bubbles_app_toggle_title">Bubbles</string>
    <!-- Summary for bubbles option on the conversation level screen -->
    <string name="bubbles_conversation_toggle_summary">New messages will appear on screen</string>
    <!-- Description for the toggle shown on the app-level bubbles page  [CHAR LIMIT=NONE] -->
    <string name="bubbles_app_toggle_summary">Allow <xliff:g id="app_name" example="YouTube">%1$s</xliff:g> to show some notifications as bubbles</string>
    <!-- Title of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=NONE] -->
    <string name="bubbles_feature_disabled_dialog_title">Turn on bubbles</string>
    <!-- Description of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=NONE] -->
    <string name="bubbles_feature_disabled_dialog_text">To turn on bubbles for this app, first you need to turn them on for your device. This affects other apps in which you previously turned on bubbles.</string>
    <!-- Button of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=60]-->
    <string name="bubbles_feature_disabled_button_approve">Turn on for device</string>
    <!-- Button to cancel out of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=60] -->
    <string name="bubbles_feature_disabled_button_cancel">Cancel</string>

    <!-- Configure notifications: title for swipe direction [CHAR LIMIT=60] -->
    <string name="swipe_direction_title">Swipe actions</string>

    <!-- Configure notifications: value for swipe direction [CHAR LIMIT=100] -->
    <string name="swipe_direction_ltr">Swipe right to dismiss, left to show menu</string>

    <!-- Configure notifications: value for swipe direction [CHAR LIMIT=100] -->
    <string name="swipe_direction_rtl">Swipe left to dismiss, right to show menu</string>

    <!-- Configure notifications: link to education/gentle notification settings [CHAR LIMIT=100] -->
    <string name="gentle_notifications_title">Gentle notifications</string>

    <!-- Gentle notifications settings : header for selecting where gentle notifications should appear [CHAR LIMIT=100] -->
    <string name="gentle_notifications_also_display">Also display in</string>

    <!-- Gentle notifications settings: display in status bar  [CHAR LIMIT=100] -->
    <string name="gentle_notifications_display_status">Status bar</string>

    <!-- Gentle notifications settings: display in lock screen  [CHAR LIMIT=100] -->
    <string name="gentle_notifications_display_lock">Lock screen</string>

    <!-- Gentle notifications footer: what are gentle notification  [CHAR LIMIT=NONE] -->
    <string name="gentle_notifications_education">Gentle notifications are always silent and always appear in the pull-down shade</string>

    <!-- Gentle notifications settings: display only in shade  [CHAR LIMIT=100] -->
    <string name="gentle_notifications_display_summary_shade">Display in pull-down shade only</string>

    <!-- Gentle notifications settings: display in shade and on the lock screen  [CHAR LIMIT=100] -->
    <string name="gentle_notifications_display_summary_shade_lock">Display in pull-down shade &amp; on lock screen</string>

    <!-- Gentle notifications settings: display in shade and on status bar  [CHAR LIMIT=100] -->
    <string name="gentle_notifications_display_summary_shade_status">Display in pull-down shade &amp; status bar</string>

    <!-- Gentle notifications settings: display on all surfaces  [CHAR LIMIT=100] -->
    <string name="gentle_notifications_display_summary_shade_status_lock">Display in pull-down shade, status bar &amp; on lock screen</string>

    <!-- Notification settings: suppress status bar/ambient icons for silent notifications -->
    <string name="silent_notifications_status_bar">Hide silent notifications in status bar</string>

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

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

    <!-- Configure lock screen: Title for the option of unlocking directly to home. [CHAR LIMIT=30] -->
    <string name="lockscreen_bypass_title">Skip lock screen</string>

    <!-- Configure lock screen: Summary for the option of unlocking directly to home. [CHAR LIMIT=100] -->
    <string name="lockscreen_bypass_summary">After face unlock, go directly to last used screen</string>

    <!-- Configure lock screen: Search keywords for the option of unlocking directly to home. [CHAR LIMIT=100] -->
    <string name="keywords_lockscreen_bypass">Lock screen, Lockscreen, Skip, Bypass</string>

    <!-- Configure Notifications: Title for the option controlling notifications for work profile. [CHAR LIMIT=30] -->
    <string name="locked_work_profile_notification_title">When work profile is locked</string>


    <!-- Configure notifications: Title for determining which notifications appear on the lock screen [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_title">Notifications on lockscreen</string>

    <!-- Configure notifications: Value for lockscreen notifications: all notifications shown
    regardless of noisiness [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_all">Show alerting and silent notifications</string>

    <!-- Configure notifications: Value for lockscreen notifications: show alerting notifications [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_alerting">Show alerting notifications only</string>

    <!-- Configure notifications: Value for lockscreen notifications: don't show notifications [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_none">Don\u2019t show notifications</string>

    <!-- Configure notifications: Title for redacting sensitive content on lockscreen [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_redact">Sensitive notifications</string>

    <!-- Configure notifications: Summary for redacting sensitive content on lockscreen [CHAR LIMIT=120] -->
    <string name="lock_screen_notifs_redact_summary">Show sensitive content when locked</string>

    <!-- Configure notifications: Title for redacting sensitive content on lockscreen, work profile [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_redact_work">Sensitive work profile notifications</string>

    <!-- Configure notifications: Summary for redacting sensitive content on lockscreen, work profile [CHAR LIMIT=120] -->
    <string name="lock_screen_notifs_redact_work_summary">Show sensitive work profile content when locked</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, but will be shown if the user is unlocked by either smart lock or via biometric unlock mechanism.
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_hide">Show sensitive content only when unlocked</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">How do you want the lock screen to display?</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Title for the screen asking the user how much notification content they want to see on their lock screen [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_interstitial_title">Lock screen</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 content</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 an individual app's notification settings. [CHAR LIMIT=30] -->
    <string name="notifications_title">Notifications</string>

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

    <!-- [CHAR LIMIT=100] Notification channel title -->
    <string name="notification_channel_title">Notification category</string>

    <!-- [CHAR LIMIT=200] Notification channel group title -->
    <string name="notification_group_title">Notification category group</string>

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

    <!-- [CHAR LIMIT=100 BACKUP_MESSAGE_ID=1820188704793497324] Notification Importance: unspecified importance level description -->
    <string name="notification_importance_unspecified">Allow sound</string>

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

    <!-- [CHAR LIMIT=100] Notification Importance template for the channel importance summary -->
    <string name="notification_importance_divider" translatable="false"><xliff:g id="importance_title">%1$s</xliff:g>: <xliff:g id="importance_summary">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=100] Header for a grouping on conversations-->
    <string name="conversations_category_title">Conversations</string>

    <!-- [CHAR LIMIT=100] Header for an individual conversation-->
    <string name="conversation_category_title">Conversation</string>

    <!-- [CHAR LIMIT=NONE] Conversation preference summary, the parent channel this conversation was spawned from (separator) the parent channel group (e.g. an account name)-->
    <string name="notification_conversation_summary" translatable="false">"<xliff:g id="parent_category_name">%1$s</xliff:g> • <xliff:g id="parent_category_group_name">%2$s</xliff:g>"</string>

    <!-- [CHAR LIMIT=100] Field on conversation settings page -->
    <string name="demote_conversation_title">Not a conversation</string>

    <!-- [CHAR LIMIT=NONE] Summary for demote_conversation_title on conversation settings page -->
    <string name="demote_conversation_summary">Remove from the conversation section</string>

    <!-- [CHAR LIMIT=100] Field on notification channel settings page -->
    <string name="promote_conversation_title">This is a conversation</string>

    <!-- [CHAR LIMIT=NONE] Summary for promote_conversation_title on notifications settings page -->
    <string name="promote_conversation_summary">Add to the conversation section</string>

    <!-- [CHAR LIMIT=100] link to page listing all conversations -->
    <string name="manage_conversations">Manage conversations</string>

    <!-- [CHAR LIMIT=100] preference category title -->
    <string name="important_conversations">Important conversations</string>

    <!-- [CHAR LIMIT=100] preference category title -->
    <string name="all_conversations">All conversations</string>

    <!-- [CHAR LIMIT=100] Setting to automatically bubble all notifications from favorite conversations -->
    <string name="important_bubble">Bubble important conversations</string>

    <!-- [CHAR LIMIT=NONE] description of how notifications from important conversations behave -->
    <string name="important_conversation_behavior_summary">Important conversations show at the top of the pull-down shade. You can also set them to bubble and interrupt Do Not Disturb.</string>

    <!-- Importance title strings for the Importance page. Also the second part of the importance
     summary on the channel page-->

    <!-- [CHAR LIMIT=100] Notification Importance: min importance level description -->
    <string name="notification_importance_min">Show silently and minimize</string>

    <!-- [CHAR LIMIT=100] Notification Importance: low importance level description -->
    <string name="notification_importance_low">Show silently</string>

    <!-- [CHAR LIMIT=100] Notification Importance: normal importance level description -->
    <string name="notification_importance_default">Make sound</string>

    <!-- [CHAR LIMIT=100] Notification Importance: high importance level description -->
    <string name="notification_importance_high">Make sound and pop on screen</string>

    <!-- [CHAR LIMIT=100] Notification Importance: high importance level description,
     when the user has picked high importance but disabled sound for it -->
    <string name="notification_importance_high_silent">Pop on screen</string>

    <!-- Importance title strings for the Importance page. Also the first part of the importance
     summary on the channel page-->

    <!-- [CHAR LIMIT=100] Notification Importance title: min importance level title -->
    <string name="notification_importance_min_title">Minimize</string>

    <!-- [CHAR LIMIT=100] Notification Importance title: low importance level title -->
    <string name="notification_importance_low_title">Medium</string>

    <!-- [CHAR LIMIT=100] Notification Importance title: normal importance level title -->
    <string name="notification_importance_default_title">High</string>

    <!-- [CHAR LIMIT=100] Notification Importance title: high importance level title -->
    <string name="notification_importance_high_title">Pop on screen</string>

    <!-- [CHAR LIMIT=100] Notification Importance title -->
    <string name="notification_block_title">Block</string>

    <!-- [CHAR LIMIT=100] Notification Importance title -->
    <string name="notification_silence_title">Silent</string>

    <!-- [CHAR LIMIT=100] Notification Importance title -->
    <string name="notification_alert_title">Alerting</string>

    <!-- [CHAR LIMIT=40] Notification importance title. This setting controls how notifications in older apps may alert the user (eg, sound, visual, vibrate). -->
    <string name="allow_interruption">Allow interruptions</string>

    <!-- [CHAR LIMIT=180] Notification importance description. More details from allow_interruption string - specifics of how notifications may interrupt. -->
    <string name="allow_interruption_summary">Let the app make sound, vibrate, and/or pop notifications on screen</string>

    <!-- Channel summaries for the app notification page -->

    <!-- [CHAR LIMIT=150] Notification Importance title: min importance level summary -->
    <string name="notification_channel_summary_min">In the pull-down shade, collapse notifications to one line</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: low importance level summary -->
    <string name="notification_channel_summary_low">Helps you focus without sound or vibration</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: normal importance level summary -->
    <string name="notification_channel_summary_default">Gets your attention with sound or vibration</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: high importance level summary -->
    <string name="notification_channel_summary_high">When device is unlocked, show notifications as a banner across the top of the screen</string>

    <!-- [CHAR LIMIT=100] Label for on/off toggle -->
    <string name="notification_switch_label">All <xliff:g id="app_name" example="Android Services">%1$s</xliff:g> notifications</string>

    <!-- Default Apps > Default notification assistant -->
    <string name="default_notification_assistant">Adaptive Notifications</string>

    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <plurals name="notifications_sent_daily">
        <item quantity="one">~<xliff:g id="number">%d</xliff:g> notification per day</item>
        <item quantity="other">~<xliff:g id="number">%d</xliff:g> notifications per day</item>
    </plurals>
    <plurals name="notifications_sent_weekly">
        <item quantity="one">~<xliff:g id="number">%d</xliff:g> notification per week</item>
        <item quantity="other">~<xliff:g id="number">%d</xliff:g> notifications per week</item>
    </plurals>
    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <string name="notifications_sent_never">Never</string>

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

    <!-- Notification Access section: Indicates that the work profile admin doesn't allow this
         notification listener to access work profile notifications [CHAR LIMIT=100] -->
    <string name="work_profile_notification_access_blocked_summary">Access to work profile notifications is blocked</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>

    <!-- Title for Notification Assistant Picker screen [CHAR LIMIT=30]-->
    <string name="notification_assistant_title">Adaptive Notifications</string>

    <!-- Label for no NotificationAssistantService [CHAR_LIMIT=NONE] -->
    <string name="no_notification_assistant">None</string>

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

    <!-- Button title that grants 'notification access' permission to an app [CHAR_LIMIT=60]-->
    <string name="notification_access_detail_switch">Allow notification access</string>

    <!-- Title for a warning message about security implications of enabling a notification
      assistant, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="notification_assistant_security_warning_title">Allow notification access for
         <xliff:g id="service" example="NotificationAssistant">%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_assistant_security_warning_summary">
        <xliff:g id="notification_assistant_name" example="Notification Assistant">%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 modify or 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>

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

    <!-- Special access > Title for managing Picture-in-picture settings. [CHAR LIMIT=50] -->
    <string name="picture_in_picture_title">Picture-in-picture</string>

    <!-- Special access > Picture-in-picture > Text to display when the list is empty. [CHAR LIMIT=NONE] -->
    <string name="picture_in_picture_empty_text">No installed apps support Picture-in-picture</string>

    <!-- Special access > Picture-in-picture > Additional keywords to search for. [CHAR LIMIT=NONE] -->
    <string name="picture_in_picture_keywords">pip picture in</string>

    <!-- Apps > App Details > Advanced section string title. [CHAR LIMIT=NONE] -->
    <string name="picture_in_picture_app_detail_title">Picture-in-picture</string>

    <!-- Apps > App Details > Picture-in-picture > Switch title. [CHAR LIMIT=NONE] -->
    <string name="picture_in_picture_app_detail_switch">Allow picture-in-picture</string>

    <!-- Apps > App Details > Picture-in-picture > Description. [CHAR LIMIT=NONE] -->
    <string name="picture_in_picture_app_detail_summary">Allow this app to create a picture-in-picture window while the app is open or after you leave it (for example, to continue watching a video).  This window displays on top of other apps you\'re using.</string>

    <!-- Special access > Title for managing the settings where users opt-in to connect a work app
    to its personal equivalent, allowing cross-profile communication. [CHAR LIMIT=50] -->
    <string name="interact_across_profiles_title" translatable="false">Connected personal and work apps</string>

    <!-- Special access > Connected personal and work apps > Text to display when the list is empty. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_empty_text" translatable="false">No connected apps</string>

    <!-- Special access > Connected personal and work apps > Additional keywords to search for. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_keywords" translatable="false">cross profile connected app apps work and personal</string>

    <!-- Apps > App Details > Advanced section string title. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_app_detail_title" translatable="false">Connected personal and work apps</string>

    <!-- Apps > App Details > Connected personal and work apps > Switch title. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_switch_enabled" translatable="false">Connected</string>

    <!-- Apps > App Details > Connected personal and work apps > Switch title. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_switch_disabled" translatable="false">Connect these apps</string>

    <!-- Apps > App Details > Connected personal and work apps > Description. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_summary_1" translatable="false">Connected apps share permissions and can access each other\u2019s data.</string>

    <!-- Apps > App Details > Connected personal and work apps > Description. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_summary_2" translatable="false">Only connect apps that you trust with your personal data. Work apps may expose your data to your IT admin.</string>

    <!-- Apps > App Details > Connected personal and work apps > Consent dialog title. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_title" translatable="false">Trust work %1$s with your personal data?</string>

    <!-- Apps > App Details > Connected personal and work apps > Consent dialog description. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_summary" translatable="false">%1$s may expose your personal data to your IT admin.</string>

    <!-- Apps > App Details > Connected personal and work apps > Consent dialog App data title. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_app_data_title" translatable="false">App data</string>

    <!-- Apps > App Details > Connected personal and work apps > Consent dialog App data description. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_app_data_summary" translatable="false">It can access data in your personal %1$s app.</string>

    <!-- Apps > App Details > Connected personal and work apps > Consent dialog Permissions title. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_permissions_title" translatable="false">Permissions</string>

    <!-- Apps > App Details > Connected personal and work apps > Consent dialog Permissions description. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_permissions_summary" translatable="false">It can use your personal %1$s app\u2019s permissions, like access to location, storage, or contacts.</string>

    <!-- Summary of preference to manage connected personal and work apps, informing the user that currently no apps are connected -->
    <string name="interact_across_profiles_number_of_connected_apps_none" translatable="false">No apps connected</string>

    <!-- Summary of preference to manage connected personal and work apps, informing the user how many apps are connected -->
    <plurals name="interact_across_profiles_number_of_connected_apps" translatable="false">
        <item quantity="one"><xliff:g id="count">%d</xliff:g> app connected</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> apps connected</item>
    </plurals>

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

    <!-- Button title that grants 'Do Not Disturb' permission to an app [CHAR_LIMIT=60]-->
    <string name="zen_access_detail_switch">Allow Do Not Disturb</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] Text appearing when app notifications are off -->
    <string name="app_notifications_off_desc">At your request, Android is blocking this app\'s notifications from appearing on this device</string>

    <!-- [CHAR LIMIT=NONE] Text appearing when channel notifications are off -->
    <string name="channel_notifications_off_desc">At your request, Android is blocking this category of notifications from appearing on this device</string>

    <!-- [CHAR LIMIT=NONE] Text appearing when channel group notifications are off -->
    <string name="channel_group_notifications_off_desc">At your request, Android is blocking this group of notifications from appearing on this device</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: channels title -->
    <string name="notification_channels">Categories</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: non-grouped-channels title -->
    <string name="notification_channels_other">Other</string>

    <!-- [CHAR LIMIT=45] App notification settings, group summary-->
    <plurals name="notification_group_summary">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> category</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> categories</item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] App notification settings: no channels -->
    <string name="no_channels">This app has not posted any notifications</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: link to app notification settings-->
    <string name="app_settings_link">Additional settings in the app</string>

    <!-- [CHAR LIMIT=45] App notification listing summary, blocked apps -->
    <string name="app_notification_listing_summary_zero">On for all apps</string>
    <!-- [CHAR LIMIT=45] App notification listing summary, blocked apps -->
    <plurals name="app_notification_listing_summary_others">
        <item quantity="one">Off for <xliff:g id="count" example="1">%d</xliff:g> app</item>
        <item quantity="other">Off for <xliff:g id="count" example="10">%d</xliff:g> apps</item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] Footer listing a count of deleted channels. -->
    <plurals name="deleted_channels">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> category deleted</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> categories deleted</item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] App notification settings: notifications enabled-->
    <string name="notification_toggle_on">On</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: notifications disabled-->
    <string name="notification_toggle_off">Off</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 these notifications</string>

    <!-- [CHAR LIMIT=NONE] Channel notification settings: Block option title -->
    <string name="notification_content_block_title">Show notifications</string>

    <!-- [CHAR LIMIT=NONE] Channel notification settings: Block option description-->
    <string name="notification_content_block_summary">Never show notifications in the shade or on peripheral devices</string>

    <!-- [CHAR LIMIT=NONE BACKUP_MESSAGE_ID:7166470350070693657] App notification settings: Badging option title -->
    <string name="notification_badge_title">Allow notification dot</string>

    <!-- [CHAR LIMIT=NONE BACKUP_MESSAGE_ID:7166470350070693657] Channel notification settings: Badging option title -->
    <string name="notification_channel_badge_title">Show notification dot</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 on</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Visibility override option title -->
    <string name="app_notification_visibility_override_title">Lock screen</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications row summary when allowed -->
    <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">Blink light</string>

    <!-- [CHAR LIMIT=180] Notification settings: vibration -->
    <string name="notification_vibrate_title">Vibration</string>

    <!-- [CHAR LIMIT=180] Notification settings: sound -->
    <string name="notification_channel_sound_title">Sound</string>

    <!-- [CHAR LIMIT=180] Notification conversation: important -->
    <string name="notification_conversation_important">Important</string>

    <!-- [CHAR LIMIT=180] Notification conversation: add to home screen -->
    <string name="notification_conversation_add_to_home">Add to home</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule delete button -->
    <string name="zen_mode_rule_delete_button">Delete</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule name edit button -->
    <string name="zen_mode_rule_rename_button">Rename</string>

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

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

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

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

    <!-- [CHAR LIMIT=40] Zen mode settings: Add event-based rule, set rule name title -->
    <string name="zen_mode_add_event_rule">Add event schedule</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Add time-based rule, set rule name title -->
    <string name="zen_mode_add_time_rule">Add time schedule</string>

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

    <!-- [CHAR LIMIT=60] Zen mode settings: Choose rule type dialog title -->
    <string name="zen_mode_choose_rule_type">Choose schedule 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 name if unknown -->
    <string name="zen_mode_rule_type_unknown">Unknown</string>

    <!-- [CHAR LIMIT=NONE] Zen mode behavior settings footer: footer describing why the user cannot change the current do not disturb behavior settings -->
    <string name="zen_mode_app_set_behavior">These settings can\'t be changed right now. An app (<xliff:g id="app_name" example="Android Services">%1$s</xliff:g>) has automatically turned on Do Not Disturb with custom behavior."</string>

    <!-- [CHAR LIMIT=NONE] Zen mode behavior settings footer: footer describing why the user cannot change the current do not disturb behavior settings -->
    <string name="zen_mode_unknown_app_set_behavior">These settings can\'t be changed right now. An app has automatically turned on Do Not Disturb with custom behavior."</string>

    <!-- [CHAR LIMIT=NONE] Zen mode behavior settings footer: footer describing why the user cannot change the current do not disturb behavior settings -->
    <string name="zen_mode_qs_set_behavior">These settings can\'t be changed right now. Do Not Disturb was manually turned on with custom behavior."</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Schedule rule type name -->
    <string name="zen_schedule_rule_type_name">Time</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</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">Schedule turns off when an alarm rings</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Title for preference to allow custom behavior for the dnd schedule -->
    <string name="zen_mode_custom_behavior_title">Do Not Disturb behavior</string>

    <!-- [CHAR LIMIT=120] Zen mode settings: Summay text indicating the currenty dnd schedule is using the default dnd settings -->
    <string name="zen_mode_custom_behavior_summary_default">Use default settings</string>

    <!-- [CHAR LIMIT=120] Zen mode settings: Summay text indicating the currenty dnd schedule is using custom behavior -->
    <string name="zen_mode_custom_behavior_summary">Create custom settings for this schedule</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Category text indicating the schedule this custom behavior will be configured for-->
    <string name="zen_mode_custom_behavior_category_title">For \u2018<xliff:g id="schedule_name" example="Schedule 1">%1$s</xliff:g>\u2019</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">Allow calls</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Allow calls toggle title -->
    <string name="zen_mode_calls_title">Calls</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Calls screen footer -->
    <string name="zen_mode_calls_footer">To be sure allowed calls make sound, check whether your device is set to ring, vibrate, or silent.</string>

    <!-- [CHAR LIMIT=NONE] Zen mode custom rule settings: Calls screen footer -->
    <string name="zen_mode_custom_calls_footer">For \u2018<xliff:g id="schedule_name" example="Schedule 1">%1$s</xliff:g>\u2019 incoming calls are blocked. You can adjust settings to allow your friends, family, or other contacts to reach you.</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Starred contacts preference title -->
    <string name="zen_mode_starred_contacts_title">Starred contacts</string>

    <!-- Zen mode settings: Starred contacts summary [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts">
        <item quantity="one">1 other</item>
        <item quantity="other"><xliff:g id="num_people" example="3">%d</xliff:g> others</item>
    </plurals>

    <string name="zen_mode_conversations_title">Conversations</string>
    <string name="zen_mode_from_all_conversations">From all conversations</string>
    <string name="zen_mode_from_important_conversations">From important conversations</string>
    <string name="zen_mode_from_no_conversations">Don\u2019t allow any conversations</string>

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

    <!-- Do not disturb settings, messages, events and reminders footer [CHAR LIMIT=NONE]-->
    <string name="zen_mode_messages_footer">To be sure allowed messages make sound, check whether your device is set to ring, vibrate, or silent.</string>

    <!-- [CHAR LIMIT=NONE] Zen mode custom rule settings: Messages screen footer -->
    <string name="zen_mode_custom_messages_footer">For \u2018<xliff:g id="schedule_name" example="Schedule 1">%1$s</xliff:g>\u2019 incoming messages are blocked. You can adjust settings to allow your friends, family, or other contacts to reach you.</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Allow messages to bypass DND title -->
    <string name="zen_mode_messages_title">SMS, MMS, and messaging apps</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>

    <!-- Do not disturb settings, calls summary [CHAR LIMIT=100]-->
    <string name="zen_calls_summary_starred_repeat">From starred contacts and repeat callers</string>

    <!-- Do not disturb settings, calls summary [CHAR LIMIT=100]-->
    <string name="zen_calls_summary_contacts_repeat">From contacts and repeat callers</string>

    <!-- Do not disturb settings, calls summary [CHAR LIMIT=100]-->
    <string name="zen_calls_summary_repeat_only">From repeat callers only</string>

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

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls option value: No calls allowed -->
    <string name="zen_mode_from_none_calls">Don\u2019t allow any calls</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Messages option value: No messages allowed -->
    <string name="zen_mode_from_none_messages">Don\u2019t allow any messages</string>

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

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow alarms summary -->
    <string name="zen_mode_alarms_summary">From timers, alarms, security systems, and other apps</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Alarms option (ie: sound from alarm clock) -->
    <string name="zen_mode_alarms_list">alarms</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow media (sound from video) to bypass dnd -->
    <string name="zen_mode_media">Media sounds</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow media (sound from video) to bypass dnd  summary-->
    <string name="zen_mode_media_summary">From videos, games, and other media</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Media (ie: sound from video) -->
    <string name="zen_mode_media_list">media</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: allow touch sounds to bypass DND  -->
    <string name="zen_mode_system">Touch sounds</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: allow touch sounds to bypass DND summary  -->
    <string name="zen_mode_system_summary">From your keyboard and other buttons</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: System sounds (ie: touch sounds) -->
    <string name="zen_mode_system_list">touch sounds</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow reminder notifications/sounds to bypass DND  -->
    <string name="zen_mode_reminders">Reminders</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow reminder notifications/sounds to bypass DND summary  -->
    <string name="zen_mode_reminders_summary">From tasks and reminders</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Reminders (ie: calendar reminders are allowed to bypass dnd) -->
    <string name="zen_mode_reminders_list">reminders</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow event notifications/sounds to bypass DND -->
    <string name="zen_mode_events">Events</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow event notifications/sounds to bypass DND summary -->
    <string name="zen_mode_events_summary">From upcoming calendar events</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Allow apps to bypass DND -->
    <string name="zen_mode_bypassing_apps">Allow apps to override</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Allow apps to bypass DND title-->
    <string name="zen_mode_bypassing_apps_title">App exceptions</string>

    <!-- [CHAR LIMIT=120] Zen mode settings: No apps are bypassing DND -->
    <string name="zen_mode_bypassing_apps_subtext_none">No apps can override Do Not Disturb</string>

    <!-- [CHAR LIMIT=120] Zen mode settings: Allow apps to bypass DND -->
    <plurals name="zen_mode_bypassing_apps_subtext">
        <item quantity="zero">No apps can override Do Not Disturb</item>
        <item quantity="one">Notifications from 1 app can override Do Not Disturb</item>
        <item quantity="other">Notifications from <xliff:g id="number" example="2">%1$d</xliff:g> apps can override Do Not Disturb</item>
    </plurals>

    <!-- [CHAR LIMIT=50] Zen mode settings: Events (ie: calendar events) -->
    <string name="zen_mode_events_list">events</string>

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

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

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

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

    <!-- [CHAR LIMIT=50] Zen mode settings: Repeat callers (ie: repeat callers are allowed to bypass dnd) -->
    <string name="zen_mode_repeat_callers_list">repeat callers</string>

    <!-- [CHAR LIMIT=70] Zen mode settings: Allow repeat callers toggle title -->
    <string name="zen_mode_repeat_callers_title">Allow repeat callers</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: calls summary -->
    <string name="zen_mode_calls_summary_one">Allow from <xliff:g id="caller type" example="contacts">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=50] Zen mode settings: calls summary -->
    <string name="zen_mode_calls_summary_two">Allow from <xliff:g id="caller type" example="starred contacts">%1$s</xliff:g> and <xliff:g id="callert tpye" example="repeat callers">%2$s</xliff:g></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</string>

    <!-- [CHAR LIMIT=50] Zen mode settings dnd beahvior description: when a user has chosen custom sounds to bypass DND -->
    <string name="zen_mode_behavior_summary_custom">Custom</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 signals: screen is on: title -->
    <string name="zen_mode_screen_on">When the screen is on</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual signals: screen is on: summary -->
    <string name="zen_mode_screen_on_summary">Let notifications silenced by Do Not Disturb pop on screen and show a status bar icon</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: visual signals: screen is off: title -->
    <string name="zen_mode_screen_off">When the screen is off</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is off: summary -->
    <string name="zen_mode_screen_off_summary">Let notifications silenced by Do Not Disturb turn on the screen and blink the light</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is off: summary -->
    <string name="zen_mode_screen_off_summary_no_led">Let notifications silenced by Do Not Disturb turn on the screen</string>

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

    <!-- Generic label for suggestion card's ok button [CHAR LIMIT=20] -->
    <string name="suggestion_button_text">Ok</string>

    <!-- Strings for suggestion card's close button [CHAR LIMIT=20] -->
    <string name="suggestion_button_close">Close</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 admin 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 Overview\n\n3. Tap the app icon at the top of the screen, then tap Pin</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>

    <!-- [CHAR LIMIT=60] turn eSim deletion confirmation on/off  -->
    <string name="confirm_sim_deletion_title">Confirm SIM deletion</string>
    <!-- [CHAR LIMIT=NONE] eSim deletion confirmation description  -->
    <string name="confirm_sim_deletion_description">Verify it\u0027s you before erasing a downloaded SIM</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>

    <!-- 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. Require PIN to start your device?
   </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. Require pattern to start your device?
   </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. Require password to start your device?
   </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. Require PIN to start your device?</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. Require pattern to start your device?</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. Require password to start your device?</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 face unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pin_for_face">In addition to using your face 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. Require PIN to start your device?</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 face unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pattern_for_face">In addition to using your face 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. Require pattern to start your device?</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 face unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_password_for_face">In addition to using your face 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. Require password to start your device?</string>

    <!-- Button label to say yes to the question of whether to require PIN/password/pattern to start your device. [CHAR LIMIT=20] -->
    <string name="encryption_interstitial_yes">Yes</string>
    <!-- Button label to say no to the question of whether to require PIN/password/pattern to start your device. [CHAR LIMIT=20] -->
    <string name="encryption_interstitial_no">No</string>

    <!-- Label to say yes to the question of whether app is restricted. [CHAR LIMIT=20] -->
    <string name="restricted_true_label">Restricted</string>
    <!-- Label to say no to the question of whether app is restricted. [CHAR LIMIT=20] -->
    <string name="restricted_false_label">App can use battery in background</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: If you restart your phone and have a screen lock set, 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>

    <!-- 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">On</string>
    <!-- App notification summary with notifications enabled [CHAR LIMIT=40] -->
    <string name="notifications_enabled_with_info"><xliff:g id="notifications_sent" example="~6 per week">%1$s</xliff:g> / <xliff:g id="notifications_categories_off" example="3 categories turned off">%2$s</xliff:g> </string>
    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="notifications_disabled">Off</string>
    <!-- Label for showing apps with some blocked notifications in list [CHAR LIMIT=30] -->
    <string name="notifications_partly_blocked"><xliff:g id="count" example="1">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$d</xliff:g> categories turned off</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>
    <!-- App notification summary channel divider-->
    <string name="notification_summary_channel"><xliff:g id="channel_name">%1$s</xliff:g> \u2022 <xliff:g id="group_name">%2$s</xliff:g></string>

    <!-- Permissions preference summary [CHAR LIMIT=40] -->
    <plurals name="notifications_categories_off">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> category turned off</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> categories turned off</item>
    </plurals>

    <!-- 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">Installed apps</string>
    <!-- Label for showing instant apps in list [CHAR LIMIT=40] -->
    <string name="filter_instant_apps">Instant apps</string>

    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_all_apps">Apps: All</string>
    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_blocked_apps">Turned off</string>
    <!-- Label for showing categories with urgent notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_urgent_channels">Categories: Urgent importance</string>
    <!-- Label for showing categories with low importance notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_low_channels">Categories: Low importance</string>
    <!-- Label for showing categories with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_blocked_channels">Categories: Turned off</string>
    <!-- Label for showing categories with notifications that override dnd in list [CHAR LIMIT=30] -->
    <string name="filter_notif_dnd_channels">Categories: Overrides Do Not Disturb</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">Permission manager</string>
    <!-- Summary of permissions currently granted to apps [CHAR LIMIT=60] -->
    <string name="app_permissions_summary">Apps using <xliff:g id="apps" example="location">%1$s</xliff:g></string>
    <!-- Summary of permissions currently granted to apps [CHAR LIMIT=60] -->
    <string name="app_permissions_summary_more">Apps using <xliff:g id="apps" example="location">%1$s</xliff:g>, and more</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>

    <!-- Summary of open web links settings when no app can open supported links [CHAR LIMIT=NONE] -->
    <string name="domain_urls_apps_summary_off">No app opening supported links</string>

    <!-- Summary of open web links settings when at least one app can open supported links [CHAR LIMIT=NONE] -->
    <plurals name="domain_urls_apps_summary_on">
        <item quantity="one">One app opening supported links</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> apps opening 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">Allow app to open supported links</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 allow app to open links</string>

    <!-- Summary for allow app to open supported links [CHAR LIMIT=42] -->
    <plurals name="app_link_open_always_summary">
        <item quantity="one">App claims to handle <xliff:g id="count">%d</xliff:g> link</item>
        <item quantity="other">App claims to handle <xliff:g id="count">%d</xliff:g> links</item>
    </plurals>

    <!-- Footer of open supported links settings [CHAR LIMIT=NONE] -->
    <string name="open_supported_links_footer">App claims to handle following links:</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">Digital assistant app</string>

    <!-- Title for Default Assist settings [CHAR LIMIT=30] -->
    <string name="default_digital_assistant_title">Default digital assistant 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>

    <!-- Link title to show stats about how much time user spent in an app [CHAR LIMIT=45] -->
    <string name="time_spent_in_app_pref_title">Screen time</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>

    <!-- Label for menu to launch a screen showing usage alerts for battery [CHAR LIMIT=30] -->
    <string name="additional_battery_info">Usage alerts</string>

    <!-- Label for menu to show battery usage in the device [CHAR LIMIT=45] -->
    <string name="show_all_apps">Show full device usage</string>

    <!-- Label for menu to show app usage [CHAR LIMIT=30] -->
    <string name="hide_extra_apps">Show app usage</string>

    <!-- Summary for high usage item, showing app/apps are behaving abnormally [CHAR LIMIT=80] -->
    <plurals name="power_high_usage_summary">
        <item quantity="one"><xliff:g id="app">%1$s</xliff:g> behaving abnormally</item>
        <item quantity="other"><xliff:g id="number">%2$d</xliff:g> apps behaving abnormally</item>
    </plurals>

    <!-- Title for high usage item, showing app/apps are draining battery [CHAR LIMIT=80] -->
    <plurals name="power_high_usage_title">
        <item quantity="one"><xliff:g id="app">%1$s</xliff:g> draining battery</item>
        <item quantity="other">Apps draining battery</item>
    </plurals>

    <!-- 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">Let app always run in background?</string>

    <!-- Body text of prompt dialog app can invoke to turn off optimization [CHAR LIMIT=NONE] -->
    <string name="high_power_prompt_body">
        Allowing <xliff:g id="app_name" example="Settings">%1$s</xliff:g> to always run in the background may reduce battery life.
        \n\nYou can change this later from Settings > Apps &amp; notifications.</string>
    <!-- Summary of power usage for an app [CHAR LIMIT=NONE] -->
    <string name="battery_summary"><xliff:g id="percentage" example="2">%1$s</xliff:g> use since last full charge</string>

    <!-- Title of a group of settings that let you manage settings that affect battery life [CHAR LIMIT=60] -->
    <string name="battery_power_management">Power management</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">No data transfer</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">Charge connected device</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring files via MTP. -->
    <string name="usb_use_file_transfers">File Transfer</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">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 USB tethering. -->
    <string name="usb_use_tethering">USB tethering</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for entering MIDI mode. -->
    <string name="usb_use_MIDI">MIDI</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for entering MIDI mode. -->
    <string name="usb_use_MIDI_desc">Use 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. These options are more commonly used.
         Choices are usb_use_file_transfer.-->
    <string name="usb_use">Use USB for</string>
    <!-- The label that leads to the Default USB configuration window. -->
    <string name="usb_default_label">Default USB configuration</string>
    <!-- Description at the footer of the default USB configuration window that describes how the setting works. -->
    <string name="usb_default_info">When another device is connected and your phone is unlocked, these settings will be applied. Only connect to trusted devices.</string>

    <!-- Settings item title for USB preference [CHAR LIMIT=35] -->
    <string name="usb_pref">USB</string>
    <!-- Settings screen title for USB preference [CHAR LIMIT=35] -->
    <string name="usb_preference">USB Preferences</string>

    <!-- The title used in USB Preferences which lets the user select whether USB
         should be in host or device mode. -->
    <string name="usb_control_title">USB controlled by</string>
    <!-- The option in USB Preferences for selecting USB to be in host mode. This allows
         the user to connect peripherals such as a mouse or flash drive to the device. -->
    <string name="usb_control_host">Connected device</string>
    <!-- The option in USB Preferences for selecting USB to be in device mode. This allows
         the device to provide services such as file transfer or tethering to another device. -->
    <string name="usb_control_device">This device</string>
    <!-- The summary text that appears under a USB control option while it is in the process of
         switching control or power. -->
    <string name="usb_switching">Switching...</string>
    <!-- The summary text that appears under a USB control option when switching control or power has
         failed. -->
    <string name="usb_switching_failed">Couldn\'t switch</string>

    <!-- Settings item summary for USB preference when set to charging only [CHAR LIMIT=NONE] -->
    <string name="usb_summary_charging_only">Charging this device</string>
    <!-- Settings item summary for USB preference when set to powering the other device only [CHAR LIMIT=NONE] -->
    <string name="usb_summary_power_only">Charging connected device</string>
    <!-- Settings item summary for USB preference when set to transferring files via MTP [CHAR LIMIT=NONE] -->
    <string name="usb_summary_file_transfers">File transfer</string>
    <!-- Settings item summary for USB preference when set to USB tethering [CHAR LIMIT=NONE] -->
    <string name="usb_summary_tether">USB tethering</string>
    <!-- Settings item summary for USB preference when set to transferring photos via PTP [CHAR LIMIT=NONE] -->
    <string name="usb_summary_photo_transfers">PTP</string>
    <!-- Settings item summary for USB preference when set to entering MIDI mode [CHAR LIMIT=NONE] -->
    <string name="usb_summary_MIDI">MIDI</string>
    <!-- Settings item summary for USB preference when set to transferring files via MTP
          and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_file_transfers_power">File transfer and supplying power</string>
    <!-- Settings item summary for USB preference when set to USB tethering
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_tether_power">USB tethering and supplying power</string>
    <!-- Settings item summary for USB preference when set to transferring photos via PTP
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_photo_transfers_power">PTP and supplying power</string>
    <!-- Settings item summary for USB preference when set to entering MIDI mode
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_MIDI_power">MIDI and supplying power</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. App will no longer be restricted from using background battery.</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\'t
        prevent your admin from 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 display overlay screen [CHAR LIMIT=30] -->
    <string name="draw_overlay">Display over other apps</string>
    <!-- Settings title in main settings screen for SYSTEM_ALERT_WINDOW [CHAR LIMIT=45] -->
    <string name="system_alert_window_settings">Display 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 display over other apps [CHAR LIMIT=60] -->
    <string name="system_alert_window_access_title">Display over other apps</string>
    <!-- Label for setting which controls whether app can display over other apps [CHAR LIMIT=45] -->
    <string name="permit_draw_overlay">Allow display over other apps</string>
    <!-- Description of allowing overlay setting [CHAR LIMIT=NONE] -->
    <string name="allow_overlay_description">Allow this app to display on top of other apps you\u2019re using. It may interfere with your use of those apps or change the way they seem to appear or behave.</string>

    <!-- Manager External Storage settings title [CHAR LIMIT=40] -->
    <string name="manage_external_storage_title">All files access</string>
    <!-- Label for a setting which controls whether an app can manage external storage [CHAR LIMIT=45] -->
    <string name="permit_manage_external_storage">Allow access to manage all files</string>
    <!-- Description for a setting which controls whether an app can manage external storage
         [CHAR LIMIT=NONE] -->
    <string name="allow_manage_external_storage_description">Allow this app to read, modify and delete all files on this device or any connected storage volumes. If granted, app may access files without your explicit knowledge.</string>
    <!-- Label for showing apps that can manage external storage[CHAR LIMIT=45] -->
    <string name="filter_manage_external_storage">Can access all files</string>

    <!-- Keyword for VR setting -->
    <string name="keywords_vr_listener">vr virtual reality listener stereo helper service</string>
    <!-- Main settings screen item's title to go into the overlay settings screen [CHAR LIMIT=30] -->
    <string name="overlay_settings">Display over other apps</string>

    <!-- Summary of number of apps currently can display over other apps [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 display over other apps</string>

    <!-- Label for showing apps that can display over other apps [CHAR LIMIT=45] -->
    <string name="filter_overlay_apps">Apps with permission</string>

    <!-- Preference summary text for an app when it is allowed for a permission. [CHAR LIMIT=45] -->
    <string name="app_permission_summary_allowed">Allowed</string>

    <!-- Preference summary text for an app when it is disallowed for a permission. [CHAR LIMIT=45] -->
    <string name="app_permission_summary_not_allowed">Not allowed</string>

    <!-- Keywords for setting screen for controlling apps that can install other apps on device -->
    <string name="keywords_install_other_apps">install apps unknown sources</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 write system settings [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 install other apps [CHAR LIMIT=45] -->
    <string name="filter_install_sources_apps">Can install other apps</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>
    <!-- Label for setting which controls whether app can write system settings [CHAR LIMIT=45] -->
    <string name="permit_write_settings">Allow modifying 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 switch preference that controls whether an external app source is trusted or not [CHAR LIMIT=50] -->
    <string name="external_source_switch_title">Allow from this source</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">Not connected</string>

    <!-- Physical keyboard state - Disconnected [CHAR LIMIT=NONE] -->
    <string name="keyboard_disconnected">Not connected</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 data usage [CHAR LIMIT=NONE] -->
    <string name="data_usage_wifi_format"><xliff:g id="amount" example="50%">^1</xliff:g> used on Wi\u2011Fi</string>

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

    <!-- Summary of notifications when no apps are blocked [CHAR LIMIT=NONE] -->
    <string name="notification_summary_none">On for all apps</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="percentage" example="54%">%1$s</xliff:g> used - <xliff:g id="free_space" example="32GB">%2$s</xliff:g> free</string>

    <!-- Summary of storage usage when there is SD card [CHAR LIMIT=NONE] -->
    <string name="storage_summary_with_sdcard">Internal storage: <xliff:g id="percentage" example="54%">%1$s</xliff:g> used - <xliff:g id="free_space" example="32GB">%2$s</xliff:g> free</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>
    <!-- Summary for Display settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="display_dashboard_summary">Wallpaper, sleep, font size</string>

    <!-- Summary for Display settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="display_dashboard_summary_with_style">Styles, wallpapers, screen timeout, font size</string>

    <!-- Summary for Display settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="display_dashboard_nowallpaper_summary">Sleep, font size</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 settings [CHAR LIMIT=NONE] -->
    <string name="users_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>

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

    <!-- Summary of Android version info [CHAR LIMIT=NONE] -->
    <string name="android_version_summary">Updated to Android <xliff:g id="version" example="6.0">%1$s</xliff:g></string>
    <!-- Summary of Android version info (when there is a pending upgrade available) [CHAR LIMIT=NONE] -->
    <string name="android_version_pending_update_summary">Update available</string>

    <!-- Title for dialog displayed when user selects on a setting locked by an admin [CHAR LIMIT=30 BACKUP_MESSAGE_ID:4867639270211833535] -->
    <string name="disabled_by_policy_title">Action not allowed</string>
    <!-- Title for dialog displayed to tell user that changing volume was disallowed by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_adjust_volume">Can’t change volume</string>
    <!-- Title for dialog displayed to tell user that outgoing calls were disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_outgoing_calls">Calling not allowed</string>
    <!-- Title for dialog displayed to tell user that sending SMS were disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_sms">SMS not allowed</string>
    <!-- Title for dialog displayed to tell user that the camera was disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_camera">Camera not allowed</string>
    <!-- Title for dialog displayed to tell user that screenshots are disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_screen_capture">Screenshot not allowed</string>
    <!-- Title for dialog displayed to tell user that the app was suspended by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_suspend_packages">Can’t open this app</string>
    <!-- Shown when the user tries to change a settings locked by an admin [CHAR LIMIT=200] -->
    <string name="default_admin_support_msg">If you have questions, contact your IT admin</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 admin 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 admin 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 admin 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 active</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">Networks unavailable</string>

    <!-- Title of condition that do not disturb is on [CHAR LIMIT=36] -->
    <string name="condition_zen_title">Do Not Disturb is on</string>

    <!-- Summary of condition that do not disturb is on and all exceptions set to off [CHAR LIMIT=38] -->
    <string name="condition_zen_summary_phone_muted">Phone muted</string>

    <!-- Summary of condition that do not disturb is on and some exceptions are allowed [CHAR LIMIT=36] -->
    <string name="condition_zen_summary_with_exceptions">With exceptions</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">Features restricted</string>

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

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

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

    <!-- Summary of condition that background data is off [CHAR LIMIT=NONE] -->
    <string name="condition_bg_data_summary">Features restricted</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">For apps &amp; notifications</string>

    <!-- Action label on device muted card - clicking action will turn on ringtone sound [CHAR LIMIT=50] -->
    <string name="condition_device_muted_action_turn_on_sound">Turn on sound</string>

    <!-- Title of condition that indicates device is muted [CHAR LIMIT=50] -->
    <string name="condition_device_muted_title">Ringer muted</string>

    <!-- Summary of condition that indicates device is muted -->
    <string name="condition_device_muted_summary">For calls &amp; notifications</string>

    <!-- Title of condition that indicates device is set to vibrate [CHAR LIMIT=50] -->
    <string name="condition_device_vibrate_title">Vibration only</string>

    <!-- Summary of condition that indicates device is set to vibrate -->
    <string name="condition_device_vibrate_summary">For calls &amp; notifications</string>

    <!--  Night display: Title for the night display option Suggestion (renamed "Night Light" with title caps). [CHAR LIMIT=46] -->
    <string name="night_display_suggestion_title">Set Night Light schedule</string>

    <!--  Night display: Summary for the night display option Suggestion (renamed "Night Light" with title caps). [CHAR LIMIT=55] -->
    <string name="night_display_suggestion_summary">Automatically tint screen every night</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 tinted amber</string>

    <!-- Title of condition that gray scale is on [CHAR LIMIT=NONE] -->
    <string name="condition_grayscale_title">Grayscale</string>

    <!-- Summary of condition that gray scale is on [CHAR LIMIT=NONE] -->
    <string name="condition_grayscale_summary">Display only in gray color</string>

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

    <!-- Content description for condition footer button. In talkback mode, double tapping will cause condition list to collapse [CHAR LIMIT=NONE]-->
    <string name="homepage_condition_footer_content_description">Collapse</string>

    <!-- Title for the suggestions section on the dashboard [CHAR LIMIT=30] -->
    <string name="suggestions_title_v2">Suggested for You</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>

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

    <!-- Title for the collapsed suggestions section on the dashboard, representing number of suggestions. [CHAR LIMIT=30] -->
    <plurals name="suggestions_collapsed_title">
        <item quantity="one">1 suggestion</item>
        <item quantity="other"><xliff:g id="count" example="10">%1$d</xliff:g> suggestions</item>
    </plurals>

    <!-- Summary for the collapsed suggestions section on the dashboard, representing number of suggestions. [CHAR LIMIT=30] -->
    <plurals name="suggestions_collapsed_summary">
        <item quantity="one">+1 suggestion</item>
        <item quantity="other">+<xliff:g id="count" example="10">%1$d</xliff:g> suggestions</item>
    </plurals>

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

    <!-- Title for Camera laser sensor switch [CHAR LIMIT=NONE] -->
    <string name="camera_laser_sensor_switch">Camera Laser Sensor</string>

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

    <!-- Summary for the setting to disable the automatic update -->
    <string name="ota_disable_automatic_update_summary">Apply updates when device restarts</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">Mobile data usage</string>

    <!-- App data usage, as seen from the platform, in data usage screen [CHAR LIMIT=60] -->
    <string name="app_cellular_data_usage">App data usage</string>

    <!-- Label for wifi data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="wifi_data_usage">Wi\u2011Fi 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> mobile 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>

    <!-- Title of button and screen for billing cycle preferences [CHAR LIMIT=40] -->
    <string name="billing_cycle">Data warning &amp; limit</string>

    <!-- Title of button for application usage cycle preferences [CHAR LIMIT=40] -->
    <string name="app_usage_cycle">App data usage cycle</string>

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

    <!-- Format for a summary describing the amount of data the limit is set to [CHAR LIMIT=NONE] -->
    <string name="cell_data_limit"><xliff:g name="amount" example="1 GB">^1</xliff:g> data limit</string>

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

    <!-- Summary describing when the billing cycle for their phone carrier starts [CHAR LIMIT=NONE] -->
    <string name="billing_cycle_fragment_summary">Monthly on day <xliff:g name="day_of_month" example="17">%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>

    <!-- Summary showing how many networks restrictions [CHAR LIMIT=NONE] -->
    <plurals name="network_restrictions_summary">
        <item quantity="one">1 restriction</item>
        <item quantity="other"><xliff:g id="count" example="10">%1$d</xliff:g> restrictions</item>
    </plurals>

    <!-- 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 footnote on Data warning and limit page to warn of device discrepancies -->
    <string name="data_warning_footnote">Data warning and data limit are measured by your device. This may be different from carrier data.</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 <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>

    <!-- Data usage title text [CHAR LIMIT=30] -->
    <string name="data_usage_title">Primary data</string>

    <!-- Alternative data usage title text for Wi-Fi only mode [CHAR LIMIT=30] -->
    <string name="data_usage_wifi_title">Wi\u2011Fi data</string>

    <!-- Data usage remaining string [CHAR LIMIT=30] -->
    <string name="data_used"><xliff:g name="bytes" example="2 GB">^1</xliff:g> used</string>

    <!-- Data usage remaining string [CHAR LIMIT=13] -->
    <string name="data_used_formatted"><xliff:g name="value" example="500">^1</xliff:g> <xliff:g name="units" example="GB">^2</xliff:g> used</string>

    <!-- Shows the amount of data the user has used over their data limit [CHAR LIMIT=13] -->
    <string name="data_overusage"><xliff:g name="bytes" example="2 GB">^1</xliff:g> over</string>

    <!-- Optional part of data usage showing the remaining amount [CHAR LIMIT=13] -->
    <string name="data_remaining"><xliff:g name="bytes" example="2 GB">^1</xliff:g> left</string>

    <!-- Brief content description for data usage chart [CHAR LIMIT=NONE] -->
    <string name="data_usage_chart_brief_content_description">Graph showing data usage between <xliff:g id="start_date" example="August 19">%1$s</xliff:g> and <xliff:g id="end_date" example="September 16">%2$s</xliff:g>.</string>

    <!-- Content description for data usage chart when data is not available [CHAR LIMIT=NONE] -->
    <string name="data_usage_chart_no_data_content_description">No data in this date range</string>

    <!-- Informational text about time left in billing cycle [CHAR LIMIT=60] -->
    <plurals name="billing_cycle_days_left">
        <item quantity="one">%d day left</item>
        <item quantity="other">%d days left</item>
    </plurals>

    <!-- Informational text about time left in billing cycle [CHAR LIMIT=60] -->
    <string name="billing_cycle_none_left">No time remaining</string>

    <!-- Informational text about time left in billing cycle [CHAR LIMIT=60] -->
    <string name="billing_cycle_less_than_one_day_left">Less than 1 day left</string>

    <!-- Informational text about carrier and update time [CHAR LIMIT=32] -->
    <string name="carrier_and_update_text">Updated by <xliff:g name="carrier" example="T-mobile">^1</xliff:g> <xliff:g name="time" example="3m">^2</xliff:g> ago</string>

    <!-- Informational text about update time only, without carrier. First argument intentionally skipped. [CHAR LIMIT=30] -->
    <string name="no_carrier_update_text">Updated <xliff:g name="time" example="3m">^2</xliff:g> ago</string>

    <!-- Informational text about a recent carrier and update time [CHAR LIMIT=34] -->
    <string name="carrier_and_update_now_text">Updated by <xliff:g name="carrier" example="T-mobile">^1</xliff:g> just now</string>

    <!-- Informational text about recent update time only, without carrier [CHAR LIMIT=30] -->
    <string name="no_carrier_update_now_text">Updated just now</string>

    <!-- Button to launch external data plan app [CHAR LIMIT=30] -->
    <string name="launch_mdp_app_text">View plan</string>

    <!-- Alternate launch button text for Wi-Fi only mode [CHAR LIMIT=30] -->
    <string name="launch_wifi_text">View details</string>

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

    <!-- Switch label to enable the Data Saver feature [CHAR LIMIT=NONE] -->
    <string name="data_saver_switch_title">Use Data Saver</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=46] -->
    <string name="suggestion_additional_fingerprints">Add another fingerprint</string>

    <!-- Summary for suggestion adding more fingerprints [CHAR LIMIT=55] -->
    <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</string>

    <!-- Summary of battery saver when it is off and scheduled [CHAR LIMIT=NONE] -->
    <string name="battery_saver_off_scheduled_summary">Will turn on at <xliff:g id="battery_percentage" example="15%">%1$s</xliff:g></string>

    <!-- Summary of battery saver when it is off and scheduled [CHAR LIMIT=NONE] -->
    <string name="battery_saver_off_summary">Off</string>

    <!--  Battery saver: Label for button that will turn on battery saver. [CHAR LIMIT=30] -->
    <string name="battery_saver_button_turn_on">Turn on now</string>

    <!--  Battery saver: Label for button that will turn off battery saver. [CHAR LIMIT=30] -->
    <string name="battery_saver_button_turn_off">Turn off now</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=45] Title for the master switch for spell checker, turning off will disable entire spell check feature. -->
    <string name="spell_checker_master_switch_title">Use 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 importance -->
    <string name="notification_log_details_badge">can show badge</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 alert info -->
    <string name="notification_log_details_alerted">notification alerted</string>
    <string name="notification_log_channel">channel</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=NONE] Developer Settings: Label for the option that turns off customizations for a given category.-->
    <string name="theme_customization_device_default">Device default</string>

    <!-- [CHAR_LIMIT=NONE] Developer Settings: Title of the setting which turns on emulation of a display cutout. -->
    <string name="display_cutout_emulation">Display cutout</string>

    <!-- [CHAR_LIMIT=NONE] Developer Settings: Search keywords for the setting which turns on emulation of a display cutout. -->
    <string name="display_cutout_emulation_keywords">display cutout, notch</string>

    <!-- [CHAR_LIMIT=NONE] Developer Settings: Label for the option that turns off all overlays in a given category. -->
    <string name="overlay_option_device_default">Device default</string>
    <!-- [CHAR_LIMIT=NONE] Developer Settings: Toast displayed to the user when an overlay fails to apply. -->
    <string name="overlay_toast_failed_to_apply">Failed to apply overlay</string>

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

    <!-- Summary for special access settings [CHAR_LIMIT=NONE] -->
    <plurals name="special_access_summary">
        <item quantity="one">1 app can use unrestricted data</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> apps can use unrestricted data</item>
    </plurals>

    <!-- Title for the See more preference item in Special app access settings [CHAR LIMIT=30] -->
    <string name="special_access_more">See more</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 info on lock screen</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=25] -->
    <string name="page_tab_title_support">Tips &amp; support</string>

    <!-- Summary of developer options to set the smallest width of the screen [CHAR LIMIT=60]-->
    <string name="density_pixel_summary" translatable="false"><xliff:g name="count" example="320">%1$s</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>

    <!-- Summary for Bluetooth when disabled. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disabled">Off</string>

    <!-- Summary for Bluetooth when connected to one device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connected_summary">Connected to <xliff:g name="device">%1$s</xliff:g></string>

    <!-- Summary for Bluetooth when connected to multiple devices. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connected_multiple_devices_summary">Connected to multiple devices</string>

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

    <!-- [CHAR LIMIT=60] Name of setting that changes the UI to dark -->
    <string name="dark_ui_mode">Dark theme</string>

    <!-- [CHAR LIMIT=60] Summary string on dark theme explaining why the toggle is disabled while the setting is still on-->
    <string name="dark_ui_mode_disabled_summary_dark_theme_on">On / Temporarily disabled due to Battery Saver</string>

    <!-- [CHAR LIMIT=60] Summary string on dark theme explaining why the toggle is disabled while the setting is off-->
    <string name="dark_ui_mode_disabled_summary_dark_theme_off">Temporarily turned on due to Battery Saver</string>

    <!-- [CHAR_LIMIT=NONE] Summary that is shown in the footer when dark mode is selected -->
    <string name="dark_ui_settings_dark_summary">Supported apps will also switch to dark theme</string>

    <!-- [CHAR_LIMIT=40] Positive button text in dark theme notification -->
    <string name="dark_ui_settings_dialog_acknowledge">Got it</string>

    <!-- [CHAR_LIMIT=50] Title string in the dark theme slice(suggestion) -->
    <string name="dark_theme_slice_title">Try Dark theme</string>

    <!-- [CHAR_LIMIT=50] Subtitle string in the dark theme slice(suggestion) -->
    <string name="dark_theme_slice_subtitle">Helps extend battery life</string>

    <!-- [CHAR LIMIT=60] Name of dev option to enable extra quick settings tiles -->
    <string name="quick_settings_developer_tiles">Quick settings developer tiles</string>

    <!-- [CHAR LIMIT=25] Title of developer tile to toggle winscope trace -->
    <string name="winscope_trace_quick_settings_title">Winscope Trace</string>

    <!-- [CHAR LIMIT=25] Title of developer tile to toggle sensors -->
    <string name="sensors_off_quick_settings_title">Sensors Off</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>
    <!-- [CHAR LIMIT=NONE] Settings label. This setting lets the user show their work events on their personal calendar. The adjective 'Cross-profile' is referring to the work and personal profiles a user has on their phone. -->
    <string name="cross_profile_calendar_title">Cross-profile calendar</string>
    <!-- [CHAR LIMIT=NONE] Setting description. If the user turns on this setting, they can see their work events on their personal calendar. -->
    <string name="cross_profile_calendar_summary">Show work events on your personal calendar</string>
    <!-- [CHAR LIMIT=NONE] The preference summary when cross-profile calendar is restricted. -->
    <string name="cross_profile_calendar_restricted_summary">Your organization doesn\u2019t allow personal apps to access your work calendar</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>

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

    <!-- Used in the storage manager settings screen to control turning on/off the feature entirely -->
    <string name="automatic_storage_manager_master_switch_title">Use 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=40 BACKUP_MESSAGE_ID:5280023307132819052]-->
    <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 for settings suggestion for double tap power for camera [CHAR LIMIT=60] -->
    <string name="double_tap_power_for_camera_suggestion_title">Open camera quickly</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 for settings suggestion for double twist for camera [CHAR LIMIT=60] -->
    <string name="double_twist_for_camera_suggestion_title">Take selfies faster</string>

    <!-- Title text for system navigation [CHAR LIMIT=60] -->
    <string name="system_navigation_title">System navigation</string>

    <!-- Title text for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_title">2-button navigation</string>
    <!-- Summary text for swipe up to switch apps  [CHAR LIMIT=250] -->
    <string name="swipe_up_to_switch_apps_summary">To switch apps, swipe up on the Home button. To see all apps, swipe up again. To go back, tap the back button.</string>
    <!-- Title for settings suggestion for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_suggestion_title">Try the new Home button</string>
    <!-- Summary for settings suggestion for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_suggestion_summary">Turn on the new gesture to switch apps</string>

    <!-- Title text for edge to edge navigation [CHAR LIMIT=60] -->
    <string name="edge_to_edge_navigation_title">Gesture navigation</string>
    <!-- Summary text for edge to edge navigation [CHAR LIMIT=NONE] -->
    <string name="edge_to_edge_navigation_summary">To go Home, swipe up from the bottom of the screen. To switch apps, swipe up from the bottom, hold, then release. To go back, swipe from either the left or right edge.</string>

    <!-- Title text for 3-button navigation [CHAR LIMIT=60] -->
    <string name="legacy_navigation_title">3-button navigation</string>
    <!-- Summary text for 3-button navigation  [CHAR LIMIT=NONE] -->
    <string name="legacy_navigation_summary">Go back, Home, and switch apps with buttons at the bottom of your screen.</string>

    <!-- Search keywords for System Navigation settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_system_navigation">system navigation, 2 button navigation, 3 button navigation, gesture navigation</string>

    <!-- Message for the alert dialog which says that the current default home app does not support gesture navigation. [CHAR LIMIT=NONE] -->
    <string name="gesture_not_supported_dialog_message">Not supported by your default home app, <xliff:g id="default_home_app" example="Pixel Launcher">%s</xliff:g></string>

    <!-- Positive button for the alert dialog when gesture nav not supported by launcher [CHAR LIMIT=60] -->
    <string name="gesture_not_supported_positive_button">Switch default home app</string>

    <!-- Content description for the Information icon [CHAR LIMIT=30] -->
    <string name="information_label">Information</string>

    <!-- Label on the left side of sensitivity adjustment slider [CHAR LIMIT=30] -->
    <string name="low_label">Low</string>
    <!-- Label on the right side of sensitivity adjustment slider [CHAR LIMIT=30] -->
    <string name="high_label">High</string>

    <!-- Label for the slider to set sensitivity of the left edge of the screen [CHAR LIMIT=40] -->
    <string name="left_edge">Left edge</string>
    <!-- Label for the slider to set sensitivity of the right edge of the screen [CHAR LIMIT=40] -->
    <string name="right_edge">Right edge</string>

    <!-- Message for the dialog that explains how increasing sensitivity can affect gestures along the edges. [CHAR LIMIT=NONE] -->
    <string name="back_sensitivity_dialog_message">Higher sensitivity may conflict with any app gestures along the edges of the screen.</string>

    <!-- Title for the dialog that is shown to adjust the back sensitivity [CHAR LIMIT=60] -->
    <string name="back_sensitivity_dialog_title">Back Sensitivity</string>

    <!-- Title for the screen to show all the gesture navigation settings [CHAR LIMIT=80] -->
    <string name="gesture_settings_activity_title">Gesture Settings</string>

    <!-- Keywords for the gesture navigation settings. [CHAR LIMIT=NONE] -->
    <string name="keywords_gesture_navigation_settings">gesture navigation, back sensitivity, back gesture</string>

    <!-- Preference and settings suggestion title text for ambient display double tap (phone) [CHAR LIMIT=60]-->
    <string name="ambient_display_title" product="default">Double-tap to check phone</string>
    <!-- Preference and settings suggestion title text for ambient display double tap (tablet) [CHAR LIMIT=60]-->
    <string name="ambient_display_title" product="tablet">Double-tap to check tablet</string>
    <!-- Preference and settings suggestion 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=NONE]-->
    <string name="ambient_display_summary">To check time, notifications, and other info, double-tap your screen.</string>

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

    <!-- Preference and settings suggestion title text for display wake-up gesture [CHAR LIMIT=60]-->
    <string name="ambient_display_wake_screen_title">Wake up display</string>

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

    <!-- Preference and settings suggestion title text for ambient display tap (phone) [CHAR LIMIT=60]-->
    <string name="ambient_display_tap_screen_title" product="default">Tap to check phone</string>
    <!-- Preference and settings suggestion title text for ambient display tap (tablet) [CHAR LIMIT=60]-->
    <string name="ambient_display_tap_screen_title" product="tablet">Tap to check tablet</string>
    <!-- Preference and settings suggestion title text for ambient display tap (device) [CHAR LIMIT=60]-->
    <string name="ambient_display_tap_screen_title" product="device">Tap to check device</string>

    <!-- Summary text for ambient display tap [CHAR LIMIT=NONE]-->
    <string name="ambient_display_tap_screen_summary">To check time, notifications, and other info, tap your screen.</string>

    <!-- Summary text for global actions panel [CHAR LIMIT=NONE] [DO NOT TRANSLATE]-->
    <string name="global_actions_panel_summary" translatable="false">To show the global actions panel, press &amp; hold Power button</string>
    <!-- Preference and settings suggestion title text for global actions panel [CHAR LIMIT=60] [DO NOT TRANSLATE]-->
    <string name="global_actions_panel_title" translatable="false">Show global actions</string>
    <!-- Short title text for global actions panel [CHAR LIMIT=40] [DO NOT TRANSLATE]-->
    <string name="global_actions_panel_short_title" translatable="false">Global actions</string>

    <!-- Title text for swiping downwards on fingerprint sensor for notifications [CHAR LIMIT=80]-->
    <string name="fingerprint_swipe_for_notifications_title">Swipe fingerprint for notifications</string>
    <!-- Title text for fingerprint gesture preference screen [CHAR LIMIT=25] -->
    <string name="fingerprint_gesture_screen_title">Swipe fingerprint</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>

    <!-- Title for settings suggestion for fingerprint swipe for notifications [CHAR LIMIT=60] -->
    <string name="fingerprint_swipe_for_notifications_suggestion_title">See notifications quickly</string>

    <!-- Title text for the assist gesture [CHAR LIMIT=60] DO NOT TRANSLATE -->
    <string name="assist_gesture_title" translatable="false">Assist gesture</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>
    <!-- Information displayed after user locks OEM lock [Char Limit=None]-->
    <string name="oem_lock_info_message">Please restart the device to enable device protection feature.</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>

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

    <!-- Summary text for enabling web actions. [CHAR_LIMIT=250] -->
    <string name="web_action_enable_summary">Open links in apps, even if they’re not installed</string>

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

    <!-- Preference label for an tappable preference that will open the instant apps settings. [CHAR LIMIT=60] -->
    <string name="instant_apps_settings">Instant Apps preferences</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 for <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>

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

    <!-- Switch label to enable auto sync account [CHAR LIMIT=60] -->
    <string name="auto_sync_account_title">Automatically sync data</string>
    <!-- Switch label to enable auto sync personal account [CHAR LIMIT=60] -->
    <string name="auto_sync_personal_account_title">Automatically sync personal data</string>
    <!-- Switch label to enable auto sync work account [CHAR LIMIT=60] -->
    <string name="auto_sync_work_account_title">Automatically sync work data</string>
    <!-- Switch summary to enable auto sync account [CHAR LIMIT=NONE] -->
    <string name="auto_sync_account_summary">Let apps refresh data automatically</string>
    <!-- Preference label to sync account [CHAR LIMIT=60] -->
    <string name="account_sync_title">Account sync</string>
    <!-- Preference summary for account sync when syncing is on for some items [CHAR LIMIT=NONE] -->
    <string name="account_sync_summary_some_on">Sync on for <xliff:g name="count" example="5">%1$d</xliff:g> of <xliff:g name="total" example="8">%2$d</xliff:g> items</string>
    <!-- Preference summary for account sync when syncing is on for everything [CHAR LIMIT=NONE] -->
    <string name="account_sync_summary_all_on">Sync on for all items</string>
    <!-- Preference summary for account sync when syncing is off for everything [CHAR LIMIT=NONE] -->
    <string name="account_sync_summary_all_off">Sync off for all items</string>

    <!-- Enterprise Privacy --> <skip />

    <!-- Title of setting on security settings screen. This will take the user to a screen with information about admin powers and their impact on the user's privacy on a managed device. Shown on enterprise-managed devices only. Note: "Device" is singular and refers to the device (e.g. phone or tablet) that the user is holding in their hand. -->
    <string name="enterprise_privacy_settings">Managed device info</string>
    <!-- Summary for Enterprise Privacy settings, explaining what the user can expect to find under it [CHAR LIMIT=NONE]-->
    <string name="enterprise_privacy_settings_summary_generic">Changes &amp; settings managed by your organization</string>
    <!-- Summary for Enterprise Privacy settings, explaining what the user can expect to find under it [CHAR LIMIT=NONE]-->
    <string name="enterprise_privacy_settings_summary_with_name">Changes &amp; settings managed by <xliff:g id="organization_name" example="Foo, Inc.">%s</xliff:g></string>
    <!-- Enterprise Privacy settings activity header, summarizing the powers that the admin has. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_header">To provide access to your work data, your organization may change settings and install software on your device.\n\nFor more details, contact your organization\'s admin.</string>
    <!-- Title for the 'Types of information your organization can see' preference category. [CHAR LIMIT=60] -->
    <string name="enterprise_privacy_exposure_category">Types of information your organization can see</string>
    <!-- Title for the 'Changes made by your organization’s admin' preference category. [CHAR LIMIT=60] -->
    <string name="enterprise_privacy_exposure_changes_category">Changes made by your organization\'s admin</string>
    <!-- Title for the 'Your access to this device' preference category. [CHAR LIMIT=60] -->
    <string name="enterprise_privacy_device_access_category">Your access to this device</string>
    <!-- Label explaining that the admin can see data associated with his/her work account. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_enterprise_data">Data associated with your work account, such as email and calendar</string>
    <!-- Label explaining that the admin can see apps installed on the device. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_installed_packages">List of apps on your device</string>
    <!-- Label explaining that the admin can see app usage statistics. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_usage_stats">Amount of time and data spent in each app</string>
    <!-- Label explaining that the admin can retrieve network logs on the device. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_network_logs">Most recent network traffic log</string>
    <!-- Label explaining that the admin can request bug reports on the device. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_bug_reports">Most recent bug report</string>
    <!-- Label explaining that the admin can retrieve security on from the device. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_security_logs">Most recent security log</string>
    <!-- Label indicating that the the admin never took a given action so far (e.g. did not retrieve security logs or request bug reports). -->
    <string name="enterprise_privacy_none">None</string>
    <!-- Label indicating that the admin installed one or more apps on the device. -->
    <string name="enterprise_privacy_enterprise_installed_packages">Apps installed</string>
    <!-- Label explaining that the the number of apps is an estimation. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_apps_count_estimation_info">Number of apps is estimated. It may not include apps installed outside of the Play Store.</string>
    <!-- Summary indicating the number of apps that a label (e.g. installed apps or apps granted a particular permission) refers to. The number shown is a minimum as there may be additional apps we do not know about. [CHAR LIMIT=NONE] -->
    <plurals name="enterprise_privacy_number_packages_lower_bound">
        <item quantity="one">Minimum <xliff:g id="count">%d</xliff:g> app</item>
        <item quantity="other">Minimum <xliff:g id="count">%d</xliff:g> apps</item>
    </plurals>
    <!-- Label indicating that the admin granted one or more apps access to the device's location. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_location_access">Location permissions</string>
    <!-- Label indicating that the admin granted one or more apps access to the microphone. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_microphone_access">Microphone permissions</string>
    <!-- Label indicating that the admin granted one or more apps access to the camera. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_camera_access">Camera permissions</string>
    <!-- Label indicating that the admin set one or more apps as defaults for common actions (e.g. open browser, send e-mail). [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_enterprise_set_default_apps">Default apps</string>
    <!-- Summary indicating the number of apps that a label (e.g. installed apps or apps granted a particular permission) refers to. [CHAR LIMIT=NONE] -->
    <plurals name="enterprise_privacy_number_packages">
        <item quantity="one"><xliff:g id="count">%d</xliff:g> app</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> apps</item>
    </plurals>
    <!-- Label explaining that the current input method was set by the admin. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_input_method">Default keyboard</string>
    <!-- Summary indicating the input method set by the admin. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_input_method_name">Set to <xliff:g id="app_label" example="Example Keyboard">%s</xliff:g></string>
    <!-- Label explaining that an always-on VPN was set by the admin for the entire device. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_always_on_vpn_device">Always-on VPN turned on</string>
    <!-- Label explaining that an always-on VPN was set by the admin in the personal profile. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_always_on_vpn_personal">Always-on VPN turned on in your personal profile</string>
    <!-- Label explaining that an always-on VPN was set by the admin in the work profile. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_always_on_vpn_work">Always-on VPN turned on in your work profile</string>
    <!-- Label explaining that a global HTTP proxy was set by the admin. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_global_http_proxy">Global HTTP proxy set</string>
    <!-- Label explaining that the admin installed trusted CA certificates for the entire device. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_ca_certs_device">Trusted credentials</string>
    <!-- Label explaining that the admin installed trusted CA certificates in personal profile. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_ca_certs_personal">Trusted credentials in your personal profile</string>
    <!-- Label explaining that the admin installed trusted CA certificates in work profile. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_ca_certs_work">Trusted credentials in your work profile</string>
    <!-- Summary indicating the number of trusted CA certificates installed by the admin. The number shown is a minimum as there may be additional CA certificates we do not know about. [CHAR LIMIT=NONE] -->
    <plurals name="enterprise_privacy_number_ca_certs">
        <item quantity="one">Minimum <xliff:g id="count">%d</xliff:g> CA certificate</item>
        <item quantity="other">Minimum <xliff:g id="count">%d</xliff:g> CA certificates</item>
    </plurals>
    <!-- Label explaining that the admin can lock the device and change the user's password. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_lock_device">Admin can lock the device and reset password</string>
    <!-- Label explaining that the admin can wipe the device remotely. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_wipe_device">Admin can delete all device data</string>
    <!-- Label explaining that the admin configured the device to wipe itself when the password is mistyped too many times. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_failed_password_wipe_device">Failed password attempts before deleting all device data</string>
    <!-- Label explaining that the admin configured the work profile to wipe itself when the password is mistyped too many times. [CHAR LIMIT=NONE] -->
    <string name="enterprise_privacy_failed_password_wipe_work">Failed password attempts before deleting work profile data</string>
    <!-- Summary indicating the number of mistyped passwords after which the device or work profile wipes itself. [CHAR LIMIT=NONE] -->
    <plurals name="enterprise_privacy_number_failed_password_wipe">
        <item quantity="one"><xliff:g id="count">%d</xliff:g> attempt</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> attempts</item>
    </plurals>
    <!-- Message indicating that the device is enterprise-managed by a Device Owner [CHAR LIMIT=NONE] -->
    <string name="do_disclosure_generic">This device is managed by your organization.</string>
    <!-- Message indicating that the device is enterprise-managed by a Device Owner [CHAR LIMIT=NONE] -->
    <string name="do_disclosure_with_name">This device is managed by <xliff:g id="organization_name" example="Foo, Inc.">%s</xliff:g>.</string>
    <!-- Message indicating that the device is enterprise-managed: Space that separates the main text and the "learn more" link that follows it. [CHAR LIMIT=NONE] -->
    <string name="do_disclosure_learn_more_separator">" "</string>
    <!-- Button label to allow the user to view additional information [CHAR LIMIT=NONE BACKUP_MESSAGE_ID=2416766240581561009] -->
    <string name="learn_more">Learn more</string>

    <!-- Strings for displaying which applications were set as default for specific actions. -->
    <!-- Title for the apps that have been set as default handlers of camera-related intents. [CHAR LIMIT=30] -->
    <plurals name="default_camera_app_title">
        <item quantity="one">Camera app</item>
        <item quantity="other">Camera apps</item>
    </plurals>
    <!-- Title for the app that has been set as default handler of calendar-related intents. [CHAR LIMIT=30] -->
    <string name="default_calendar_app_title">Calendar app</string>
    <!-- Title for the app that has been set as default handler of contacts-related intents. [CHAR LIMIT=30] -->
    <string name="default_contacts_app_title">Contacts app</string>
    <!-- Title for the apps that have been set as default handlers of new email intents. [CHAR LIMIT=30] -->
    <plurals name="default_email_app_title">
        <item quantity="one">Email client app</item>
        <item quantity="other">Email client apps</item>
    </plurals>
    <!-- Title for the app that has been set as default handler of geo-related intents. [CHAR LIMIT=30] -->
    <string name="default_map_app_title">Map app</string>
    <!-- Title for the apps that have been set as default handlers of call-related intents. [CHAR LIMIT=30] -->
    <plurals name="default_phone_app_title">
        <item quantity="one">Phone app</item>
        <item quantity="other">Phone apps</item>
    </plurals>
    <!-- Template for concatenating two app names -->
    <string name="app_names_concatenation_template_2"><xliff:g id="first_app_name">%1$s</xliff:g>, <xliff:g id="second_app_name">%2$s</xliff:g></string>
    <!-- Template for concatenating three app names -->
    <string name="app_names_concatenation_template_3"><xliff:g id="first_app_name">%1$s</xliff:g>, <xliff:g id="second_app_name">%2$s</xliff:g>, <xliff:g id="third_app_name">%3$s</xliff:g></string>

    <!-- Preference label for the Photos & Videos storage section. [CHAR LIMIT=50] -->
    <string name="storage_photos_videos">Photos &amp; videos</string>

    <!-- Preference label for the Music & Audio storage section. [CHAR LIMIT=50] -->
    <string name="storage_music_audio">Music &amp; audio</string>

    <!-- Preference label for the Games storage section. [CHAR LIMIT=50] -->
    <string name="storage_games">Games</string>

    <!-- Preference label for the Other apps storage section. [CHAR LIMIT=50] -->
    <string name="storage_other_apps">Other apps</string>

    <!-- Preference label for the Files storage section. [CHAR LIMIT=50] -->
    <string name="storage_files">Files</string>

    <!-- Summary of a single storage volume used space. [CHAR LIMIT=24] -->
    <string name="storage_size_large_alternate"><xliff:g id="number" example="128">^1</xliff:g><small> <font size="20"><xliff:g id="unit" example="KB">^2</xliff:g></font></small></string>
    <!-- Summary of a single storage volume total space. [CHAR LIMIT=48]-->
    <string name="storage_volume_total">Used of <xliff:g id="total" example="32GB">%1$s</xliff:g></string>
    <!-- Follows the percent of storage used by a storage volume. Exposed inside of a donut graph. [CHAR LIMIT=7]-->
    <string name="storage_percent_full">used</string>


    <!-- Label for button allow user to remove the instant app from the device. -->
    <string name="clear_instant_app_data">Clear app</string>
    <!-- Confirmation message displayed when the user taps Clear app, to ensure they want to remove
         the instant app from the device. -->
    <string name="clear_instant_app_confirmation">Do you want to remove this instant app?</string>
    <!-- Label for button that allows user to launch the instant app. -->
    <string name="launch_instant_app">Open</string>

    <!-- Title of games app storage screen [CHAR LIMIT=30] -->
    <string name="game_storage_settings">Games</string>

    <!-- Title for audio files preference. [CHAR LIMIT=50] -->
    <string name="audio_files_title">Audio files</string>

    <!-- Title for the installed app info storage page. The total storage space taken up by this app. [CHAR LIMIT=40]-->
    <string name="app_info_storage_title">Space used</string>

    <!-- UI webview setting: WebView uninstalled-for-user explanatory text [CHAR LIMIT=30] -->
    <string name="webview_uninstalled_for_user">(uninstalled for user <xliff:g id="user" example="John Doe">%s</xliff:g>)</string>
    <!-- UI webview setting: WebView disabled-for-user explanatory text [CHAR LIMIT=30] -->
    <string name="webview_disabled_for_user">(disabled for user <xliff:g id="user" example="John Doe">%s</xliff:g>)</string>

    <!-- AutoFill strings -->
    <!-- Preference label for choosing auto-fill service. [CHAR LIMIT=60] -->
    <string name="autofill_app">Autofill service</string>
    <!-- Keywords for the auto-fill feature. [CHAR LIMIT=NONE] -->
    <string name="autofill_keywords">auto, fill, autofill</string>

    <!-- Message of the warning dialog for setting the auto-fill app. [CHAR_LIMIT=NONE] -->
    <string name="autofill_confirmation_message">
        <![CDATA[
        <b>Make sure you trust this app</b>
        <br/>
        <br/>
        <xliff:g id="app_name" example="Google Autofill">%1$s</xliff:g> uses what\'s on
        your screen to determine what can be autofilled.
        ]]>
    </string>

    <!-- Preference category for autofill debugging development settings. [CHAR LIMIT=25] -->
    <string name="debug_autofill_category">Autofill</string>

    <!-- UI debug setting: logging level for Android Autofill [CHAR LIMIT=25] -->
    <string name="autofill_logging_level_title">Logging level</string>

    <!-- Title of developer options to set the maximum number of requests per session [CHAR LIMIT=60]-->
    <string name="autofill_max_partitions">Max requests per session</string>

    <!-- Title of developer options to set the maximum number of visible datasets in the autofill UX [CHAR LIMIT=60]-->
    <string name="autofill_max_visible_datasets">Max visible datasets</string>

    <!-- Reset all autofill developer options to their default values.[CHAR_LIMIT=60] -->
    <string name="autofill_reset_developer_options">Reset to default values</string>

    <!-- Toast message shown when autofill_reset_developer_options has been performed. [CHAR_LIMIT=none] -->
    <string name="autofill_reset_developer_options_complete">Autofill developer options have been reset</string>

    <!-- Name of setting for switching device theme [CHAR LIMIT=60] -->
    <string name="device_theme">Device theme</string>
    <!-- Name of default device theme [CHAR LIMIT=60] -->
    <string name="default_theme">Default</string>
    <!-- Temporary reboot string, will be removed -->
    <string name="change_theme_reboot" translatable="false">Changing the theme requires a restart.</string>

    <!-- Switch label to show operator name in the status bar [CHAR LIMIT=60] -->
    <string name="show_operator_name_title">Network name</string>
    <!-- Switch summary to show operator name in the status bar [CHAR LIMIT=NONE] -->
    <string name="show_operator_name_summary">Display network name in status bar</string>

    <!-- Indicates if the automatic storage manager is enabled or not. [CHAR_LIMIT=40] -->
    <string name="storage_manager_indicator">Storage Manager: <xliff:g id="status" example="on">^1</xliff:g></string>

    <!-- Off status for the automatic storage manager. [CHAR_LIMIT=10] -->
    <string name="storage_manager_indicator_off">Off</string>

    <!-- On status for the automatic storage manager. [CHAR_LIMIT=10] -->
    <string name="storage_manager_indicator_on">On</string>

    <!-- Added as the value of a header field indicating this is an instant app (as opposed to installed normally) -->
    <string name="install_type_instant">Instant app</string>

    <!-- Warning for when the automatic storage manager is turned off. [CHAR LIMIT=NONE] -->
    <string name="automatic_storage_manager_deactivation_warning">Turn off the storage manager?</string>

    <!-- Preference label for the Movies & TV apps section [CHAR LIMIT=50] -->
    <string name="storage_movies_tv">Movie &amp; TV apps</string>

    <!-- Carrier Provisioning Info [CHAR LIMIT=NONE] -->
    <string name="carrier_provisioning">Carrier Provisioning Info</string>
    <!-- Trigger Carrier Provisioning [CHAR LIMIT=NONE] -->
    <string name="trigger_carrier_provisioning">Trigger Carrier Provisioning</string>

    <!-- Help URI, USB Audio [DO NOT TRANSLATE] -->
    <string name="help_url_audio_accessory_not_supported" translatable="false"></string>

    <!-- Help URI, USB Contaminant [DO NOT TRANSLATE] -->
    <string name="help_url_usb_contaminant_detected" translatable="false"></string>

    <!-- Help URI, restricted apps page [DO NOT TRANSLATE] -->
    <string name="help_uri_restricted_apps" translatable="false"></string>

    <!-- Help URI, battery saver page [DO NOT TRANSLATE] -->
    <string name="help_url_battery_saver_settings" translatable="false"></string>

    <!-- Help URI, smart battery page [DO NOT TRANSLATE] -->
    <string name="help_uri_smart_battery_settings" translatable="false"></string>

    <!-- Help URI, prevent ringing gesture [DO NOT TRANSLATE] -->
    <string name="help_uri_prevent_ringing_gesture" translatable="false"></string>

    <!-- Title label for dnd suggestion, which is displayed in Settings homepage [CHAR LIMIT=100] -->
    <string name="zen_suggestion_title">Update Do Not Disturb</string>

    <!-- Summary label for dnd suggestion, which is displayed in Settings homepage [CHAR LIMIT=100] -->
    <string name="zen_suggestion_summary">Pause notifications to stay focused</string>

    <!-- The divider symbol between different parts of the notification header including spaces. not translatable [CHAR LIMIT=3] -->
    <string name="notification_header_divider_symbol_with_spaces" translatable="false">" • "</string>

    <!-- Title of a message for an empty state screen. A user will see this message if they try to use a certain feature, but the feature was turned off so it won't slow down their phone. [CHAR LIMIT=NONE] -->
    <string name="disabled_feature">Feature not available</string>
    <!-- Part of a message for an empty state screen. A user will see this message if they try to use a certain feature, but the feature was turned off so it won't slow down their phone. [CHAR LIMIT=NONE] -->
    <string name="disabled_feature_reason_slow_down_phone">This feature has been turned off because it slows down your phone</string>

    <!-- UI debug setting: preference title - enforce full raw GNSS satellite measurements [CHAR LIMIT=60] -->
    <string name="enable_gnss_raw_meas_full_tracking">Force full GNSS measurements</string>
    <!-- UI debug setting: preference summary - describes the behavior of forcing full raw GNSS satellite measurements [CHAR LIMIT=NONE] -->
    <string name="enable_gnss_raw_meas_full_tracking_summary">Track all GNSS constellations and frequencies with no duty cycling</string>

    <!-- UI debug setting: preference title - show all crash dialogs [CHAR LIMIT=60] -->
    <string name="show_first_crash_dialog">Always show crash dialog</string>
    <!-- UI debug setting: preference summary - describes the behavior of showing a dialog every time an app crashes [CHAR LIMIT=NONE] -->
    <string name="show_first_crash_dialog_summary">Show dialog every time an app crashes</string>

    <!-- UI debug setting: select current app to use ANGLE [CHAR LIMIT=100] -->
    <string name="angle_enabled_app">Select ANGLE enabled app</string>
    <!-- UI debug setting: no ANGLE enabled app has been set [CHAR LIMIT=100] -->
    <string name="angle_enabled_app_not_set">No ANGLE enabled application set</string>
    <!-- UI debug setting: ANGLE enabled app has been set [CHAR LIMIT=NONE] -->
    <string name="angle_enabled_app_set">ANGLE enabled application: <xliff:g id="app_name" example="com.company.app">%1$s</xliff:g></string>

    <!-- Title for graphics driver dashboard where developers can configure apps to choose graphics driver [CHAR LIMIT=50] -->
    <string name="graphics_driver_dashboard_title">Graphics Driver Preferences</string>
    <!-- Summary for graphics driver dashboard [CHAR LIMIT=50] -->
    <string name="graphics_driver_dashboard_summary">Modify graphics driver settings</string>
    <!-- Footer text for graphics driver dashboard [CHAR LIMIT=NONE] -->
    <string name="graphics_driver_footer_text">When there are multiple graphics drivers, you can pick to use the updated graphics driver for Apps installed on the device.</string>
    <!-- Title for graphics Driver all apps preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_all_apps_preference_title">Enable for all apps</string>
    <!-- Title for graphics driver preference for app [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_title">Select Graphics Driver</string>
    <!-- The default value of graphics driver preference for app [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_default">Default</string>
    <!-- The game driver value for Game Driver app preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_game_driver">Game Driver</string>
    <!-- The prerelase driver value for Developer Driver app preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_prerelease_driver">Developer Driver</string>
    <!-- The system driver value for system graphics driver app preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_system">System Graphics Driver</string>
    <!-- All the graphics driver preference values for all apps globally [CHAR LIMIT=50] -->
    <string-array name="graphics_driver_all_apps_preference_values">
        <item>@string/graphics_driver_app_preference_default</item>
        <item>@string/graphics_driver_app_preference_game_driver</item>
        <item>@string/graphics_driver_app_preference_prerelease_driver</item>
    </string-array>
    <!-- All the values of graphics driver for app preference [CHAR LIMIT=50] -->
    <string-array name="graphics_driver_app_preference_values">
        <item>@string/graphics_driver_app_preference_default</item>
        <item>@string/graphics_driver_app_preference_prerelease_driver</item>
        <item>@string/graphics_driver_app_preference_game_driver</item>
        <item>@string/graphics_driver_app_preference_system</item>
    </string-array>

    <!-- Title for App Compatibility Changes dashboard where developers can configure per-app overrides for compatibility changes [CHAR LIMIT=50] -->
    <string name="platform_compat_dashboard_title">App Compatibility Changes</string>
    <!-- Summary for App Compatibility Changes dashboard [CHAR LIMIT=NONE] -->
    <string name="platform_compat_dashboard_summary">Toggle app compatibility changes</string>
    <!-- Summary for selected app [DO NOT TRANSLATE] -->
    <string name="platform_compat_selected_app_summary" translatable="false"><xliff:g id="app_name" example="com.google.android.chrome">%1$s</xliff:g> targetSdkVersion <xliff:g id="number" example="29">%2$d</xliff:g></string>
    <!-- Title for default enabled app compat changes category [CHAR LIMIT=50] -->
    <string name="platform_compat_default_enabled_title">Default enabled changes</string>
    <!-- Title for default disabled app compat changes category [CHAR LIMIT=50] -->
    <string name="platform_compat_default_disabled_title">Default disabled changes</string>
    <!-- Title for target SDK gated app compat changes category (do not translate 'targetSdkVersion') [CHAR LIMIT=50] -->
    <string name="platform_compat_target_sdk_title">Enabled for targetSdkVersion &gt; <xliff:g id="number" example="29">%d</xliff:g></string>

    <!-- Slices Strings -->

    <!-- Summary text on a card explaining that a setting does not exist / is not supported on the device [CHAR_LIMIT=NONE]-->
    <string name="unsupported_setting_summary" product="default">Setting isn’t supported on this phone</string>

    <!-- Summary text on a card explaining that a setting does not exist / is not supported on the device [CHAR_LIMIT=NONE]-->
    <string name="unsupported_setting_summary" product="tablet">Setting isn’t supported on this tablet</string>

    <!-- Summary text on a card explaining that a setting does not exist / is not supported on the device [CHAR_LIMIT=NONE]-->
    <string name="unsupported_setting_summary" product="device">Setting isn’t supported on this device</string>

    <!-- Summary text on a card explaining that a setting cannot be changed by the current user. [CHAR_LIMIT=NONE] -->
    <string name="disabled_for_user_setting_summary">Setting can’t be changed by current user</string>

    <!-- Summary text on a card explaining a setting cannot be changed right now because it needs another setting to be changed. [CHAR_LIMIT=NONE] -->
    <string name="disabled_dependent_setting_summary">Depends on another setting</string>

    <!-- Summary text on a card explaining a setting cannot be changed right now, but we don't know the reason. [CHAR_LIMIT=NONE] -->
    <string name="unknown_unavailability_setting_summary">Setting unavailable</string>


    <!-- Account type associated with the backup account. Empty for AOSP. [DO NOT TRANSLATE] -->
    <string name="account_type" translatable="false"></string>
    <!-- Package to target for Account credential confirmation. This will allow users to
         remind/rediscover their backup account password prior to a reset. Empty for AOSP.
         [DO NOT TRANSLATE] -->
    <string name="account_confirmation_package" translatable="false"></string>
    <!-- Class to target for Account credential confirmation. This will allow users to
         remind/rediscover their backup account password prior to a reset. Empty for AOSP.
         [DO NOT TRANSLATE] -->
    <string name="account_confirmation_class" translatable="false"></string>

    <!-- Title for preference showing the primary account on the device [CHAR LIMIT=60]-->
    <string name="my_device_info_account_preference_title">Account</string>
    <!-- Title for preference showing the name of the device. [CHAR LIMIT=60]-->
    <string name="my_device_info_device_name_preference_title">Device name</string>

    <!-- Title for Wifi Access settings [CHAR LIMIT=35] -->
    <string name="change_wifi_state_title">Wi-Fi control</string>

    <!-- Apps > App Details > Wifi access > Switch title. [CHAR LIMIT=NONE] -->
    <string name="change_wifi_state_app_detail_switch">Allow app to control Wi-Fi</string>

    <!-- Apps > App Details > Wifi access > Description. [CHAR LIMIT=NONE] -->
    <string name="change_wifi_state_app_detail_summary">Allow this app to turn Wi-Fi on or off, scan and connect to Wi-Fi networks, add or remove networks, or start a local-only hotspot</string>

    <!-- Title for media output settings -->
    <string name="media_output_title">Play media to</string>

    <!-- Summary for media output default settings. (this device) [CHAR LIMIT=30] -->
    <string name="media_output_default_summary">This device</string>

    <!-- Summary for media output settings. (phone) -->
    <string name="media_output_summary" product="default">Phone</string>

    <!-- Summary for media output settings. (tablet) -->
    <string name="media_output_summary" product="tablet">Tablet</string>

    <!-- Summary for media output settings. (device) -->
    <string name="media_output_summary" product="device">Device</string>

    <!-- Summary for media output settings when device is in ongoing call state. -->
    <string name="media_out_summary_ongoing_call_state">Unavailable during calls</string>

    <!-- Summary for media output settings when the media stream is being captured by something else. -->
    <string name="media_output_summary_unavailable">Unavailable</string>

    <!-- Title for the media output group dialog with media related devices [CHAR LIMIT=50] -->
    <string name="media_output_group_panel_title">Add outputs</string>

    <!-- Title for the media output slice with group devices [CHAR LIMIT=50] -->
    <string name="media_output_group">Group</string>

    <!-- Summary for media output group with only one device which is active [CHAR LIMIT=NONE] -->
    <string name="media_output_group_panel_single_device_summary">1 device selected</string>

    <!-- Summary for media output group with the active device count [CHAR LIMIT=NONE] -->
    <string name="media_output_group_panel_multiple_devices_summary"><xliff:g id="count" example="2">%1$d</xliff:g> devices selected</string>

    <!-- Summary for media output switching output [CHAR LIMIT=50] -->
    <string name="media_output_switching">Switching\u2026</string>

    <!-- Title for HFP(hands free profile) output switch button in settings. -->
    <string name="take_call_on_title">Take call on</string>

    <!-- Toast that appears when users tap an APN for which parameters cannot be viewed. [CHAR LIMIT=NONE] -->
    <string name="cannot_change_apn_toast">This APN cannot be changed.</string>

    <!--  Title for battery Suggestion. (tablet) [CHAR LIMIT=46] -->
    <string name="battery_suggestion_title" product="tablet" >Improve tablet\'s battery life</string>
    <!--  Title for battery Suggestion. (device) [CHAR LIMIT=46] -->
    <string name="battery_suggestion_title" product="device" >Improve device\'s battery life</string>
    <!--  Title for battery Suggestion. (phone) [CHAR LIMIT=46] -->
    <string name="battery_suggestion_title" product="default" >Improve phone\'s battery life</string>
    <!--  Summary for battery Suggestion. [CHAR LIMIT=55] -->
    <string name="battery_suggestion_summary"></string>

    <!-- Title for prevent ringing gesture screen [CHAR LIMIT=60]-->
    <string name="gesture_prevent_ringing_screen_title">Prevent ringing</string>
    <!-- Title for prevent ringing setting [CHAR LIMIT=60]-->
    <string name="gesture_prevent_ringing_title">Press Power &amp; Volume Up together to</string>
    <!-- Title for prevent ringing setting [CHAR LIMIT=60]-->
    <string name="gesture_prevent_ringing_sound_title">Shortcut to prevent ringing</string>
    <!-- Option for prevent ringing setting -->
    <string name="prevent_ringing_option_vibrate">Vibrate</string>
    <!-- Option for prevent ringing setting -->
    <string name="prevent_ringing_option_mute">Mute</string>
    <!-- Option for prevent ringing setting -->
    <string name="prevent_ringing_option_none">Do nothing</string>
    <!-- Summary for prevent ringing setting -->
    <string name="prevent_ringing_option_vibrate_summary">On (vibrate)</string>
    <!-- Summary for prevent ringing setting -->
    <string name="prevent_ringing_option_mute_summary">On (mute)</string>
    <!-- Summary for prevent ringing setting -->
    <string name="prevent_ringing_option_none_summary">Off</string>

    <!-- Title for detail page of wifi network [CHAR LIMIT=30] -->
    <string name="pref_title_network_details">Network details</string>

    <!--  Warning text about the visibility of device name. [CHAR LIMIT=NONE] -->
    <string name="about_phone_device_name_warning">Your device name is visible to apps on your phone. It may also be seen by other people when you connect to Bluetooth devices or set up a Wi-Fi hotspot.</string>

    <!-- Title for Connected device shortcut [CHAR LIMIT=30] -->
    <string name="devices_title">Devices</string>

    <!-- Homepage bottom menu. Title for display all Settings [CHAR LIMIT=30] -->
    <string name="homepage_all_settings">All Settings</string>

    <!-- Homepage bottom menu. Title for display personalized Settings [CHAR LIMIT=30] -->
    <string name="homepage_personal_settings">Suggestions</string>

    <!-- Available networks screen, name of button when user wants to select network manually [CHAR LIMIT=60] -->
    <string name="choose_network_title">Choose network</string>
    <!-- Available networks screen, text when no networks connected [CHAR LIMIT=60] -->
    <string name="network_disconnected">Disconnected</string>
    <!-- Available networks screen, text when network connected [CHAR LIMIT=60] -->
    <string name="network_connected">Connected</string>
    <!-- Available networks screen, text when a network is connecting [CHAR LIMIT=60] -->
    <string name="network_connecting">Connecting\u2026</string>
    <!-- Available networks screen, text when a network cannot be connected [CHAR LIMIT=60] -->
    <string name="network_could_not_connect">Couldn\u2019t connect</string>
    <!-- Available networks screen, text when no networks are found [CHAR LIMIT=NONE] -->
    <string name="empty_networks_list">No networks found.</string>
    <!-- Available networks screen, toast when an error is encountered when searching for networks [CHAR LIMIT=NONE] -->
    <string name="network_query_error">Couldn\u2019t find networks. Try again.</string>
    <!-- Text to show this network is forbidden [CHAR LIMIT=NONE] -->
    <string name="forbidden_network">(forbidden)</string>

    <!-- Message informs the user that has no SIM card in personalized Settings [CHAR LIMIT=30] -->
    <string name="no_sim_card">No SIM card</string>

    <!-- The following strings are summaries for preferred network modes in Mobile network settings,
     and have a character limit of 100 -->
    <!-- WCDMA preferred [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_wcdma_perf_summary">Preferred network mode: WCDMA preferred</string>
    <!-- GSM only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_gsm_only_summary">Preferred network mode: GSM only</string>
    <!-- WCDMA only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_wcdma_only_summary">Preferred network mode: WCDMA only</string>
    <!-- GSM / WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_gsm_wcdma_summary">Preferred network mode: GSM / WCDMA</string>
    <!-- CDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_summary">Preferred network mode: CDMA</string>
    <!-- CDMA / EvDo [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_evdo_summary">Preferred network mode: CDMA / EvDo</string>
    <!-- CDMA only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_only_summary">Preferred network mode: CDMA only</string>
    <!-- EvDo only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_evdo_only_summary">Preferred network mode: EvDo only</string>
    <!-- CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary">Preferred network mode: CDMA/EvDo/GSM/WCDMA</string>
    <!-- LTE [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_summary">Preferred network mode: LTE </string>
    <!-- GSM/WCDMA/LTE [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_gsm_wcdma_summary">Preferred network mode: GSM/WCDMA/LTE</string>
    <!-- CDMA+LTE/EVDO [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_cdma_evdo_summary">Preferred network mode: CDMA+LTE/EVDO</string>
    <!-- LTE/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary">Preferred network mode: LTE/CDMA/EvDo/GSM/WCDMA</string>
    <!-- Global [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_global_summary">Preferred network mode: Global</string>
    <!-- LTE / WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_wcdma_summary">Preferred network mode: LTE / WCDMA</string>
    <!-- LTE / GSM / UMTS [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_gsm_umts_summary">Preferred network mode: LTE / GSM / UMTS</string>
    <!-- LTE / CDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_cdma_summary">Preferred network mode: LTE / CDMA</string>
    <!-- TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_summary">Preferred network mode: TDSCDMA</string>
    <!-- TDSCDMA / WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_wcdma_summary">Preferred network mode: TDSCDMA / WCDMA</string>
    <!-- LTE / TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_summary">Preferred network mode: LTE / TDSCDMA</string>
    <!-- TDSCDMA / GSM [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_gsm_summary">Preferred network mode: TDSCDMA / GSM</string>
    <!-- LTE/GSM/TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary">Preferred network mode: LTE/GSM/TDSCDMA</string>
    <!-- TDSCDMA/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary">Preferred network mode: TDSCDMA/GSM/WCDMA</string>
    <!-- LTE/TDSCDMA/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary">Preferred network mode: LTE/TDSCDMA/WCDMA</string>
    <!-- LTE/TDSCDMA/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary">Preferred network mode: LTE/TDSCDMA/GSM/WCDMA</string>
    <!-- TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary">Preferred network mode: TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>
    <!-- LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary">Preferred network mode: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>
    <!-- NR only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_only_summary">Preferred network mode: NR only</string>
    <!-- NR / LTE [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_summary">Preferred network mode: NR / LTE</string>
    <!-- NR/LTE/CDMA/EvDo [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary">Preferred network mode: NR/LTE/CDMA/EvDo</string>
    <!-- NR/LTE/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary">Preferred network mode: NR/LTE/GSM/WCDMA</string>
    <!-- NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary">Preferred network mode: NR/LTE/CDMA/EvDo/GSM/WCDMA</string>
    <!-- NR/LTE/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_wcdma_summary">Preferred network mode: NR/LTE/WCDMA</string>
    <!-- NR/LTE/TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_summary">Preferred network mode: NR/LTE/TDSCDMA</string>
    <!-- NR/LTE/TDSCDMA/GSM [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary">Preferred network mode: NR/LTE/TDSCDMA/GSM</string>
    <!-- NR/LTE/TDSCDMA/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary">Preferred network mode: NR/LTE/TDSCDMA/WCDMA</string>
    <!-- NR/LTE/TDSCDMA/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary">Preferred network mode: NR/LTE/TDSCDMA/GSM/WCDMA</string>
    <!-- NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary">Preferred network mode: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>

    <!-- Text for Network mode recommended [CHAR LIMIT=NONE] -->
    <string name="network_recommended">\u0020(recommended)</string>
    <!-- Text for Network 5g [CHAR LIMIT=NONE] -->
    <string name="network_5G" translatable="false">5G</string>
    <!-- Text for Network lte [CHAR LIMIT=NONE] -->
    <string name="network_lte_pure" translatable="false">LTE</string>
    <!-- Text for Network 4g [CHAR LIMIT=NONE] -->
    <string name="network_4G_pure" translatable="false">4G</string>
    <!-- Text for Network lte [CHAR LIMIT=NONE] -->
    <string name="network_lte">LTE (recommended)</string>
    <!-- Text for Network 4g [CHAR LIMIT=NONE] -->
    <string name="network_4G">4G (recommended)</string>
    <!-- Text for Network 3g [CHAR LIMIT=NONE] -->
    <string name="network_3G" translatable="false">3G</string>
    <!-- Text for Network 2g [CHAR LIMIT=NONE] -->
    <string name="network_2G" translatable="false">2G</string>
    <!-- Text for Network 1x [CHAR LIMIT=NONE] -->
    <string name="network_1x" translatable="false">1x</string>
    <!-- Text for Network global [CHAR LIMIT=NONE] -->
    <string name="network_global" translatable="false">Global</string>
    <!-- Text for Network world mode CDMA LTE [CHAR LIMIT=NONE] -->
    <string name="network_world_mode_cdma_lte" translatable="false">LTE / CDMA</string>
    <!-- Text for Network world mode GSM LTE [CHAR LIMIT=NONE] -->
    <string name="network_world_mode_gsm_lte" translatable="false">LTE / GSM / UMTS</string>

    <!-- Available networks screen title/heading [CHAR LIMIT=NONE] -->
    <string name="label_available">Available networks</string>
    <!-- Mobile network settings screen, toast when searching for available networks [CHAR LIMIT=NONE] -->
    <string name="load_networks_progress">Searching\u2026</string>
    <!-- Available networks screen, toast when registering on a specific network [CHAR LIMIT=NONE] -->
    <string name="register_on_network">Registering on <xliff:g id="network" example="Verizon">%s</xliff:g>\u2026</string>
    <!-- Available networks screen, toast when SIM card isn't allowed on a network [CHAR LIMIT=NONE] -->
    <string name="not_allowed">Your SIM card doesn\u2019t allow a connection to this network.</string>
    <!-- Available networks screen, toast when unable to connect to a network temporarily [CHAR LIMIT=NONE] -->
    <string name="connect_later">Can\u2019t connect to this network right now. Try again later.</string>
    <!-- Available networks screen, toast when registered on a specific network [CHAR LIMIT=NONE] -->
    <string name="registration_done">Registered on network.</string>

    <!-- Available networks screen, name of switch button for whether to select network automatically [CHAR LIMIT=NONE] -->
    <string name="select_automatically">Automatically select network</string>

    <!-- A menu item in "Mobile network settings" that allows the user to update the phone
     with mobile operator specific settings. [CHAR LIMIT=25] -->
    <string name="carrier_settings_title">Carrier settings</string>
    <!-- Preference title for launching an account manager page for prepaid LTE [CHAR LIMIT=30] -->
    <string name="cdma_lte_data_service">Set up data service</string>
    <!-- Mobile network settings screen, title of Mobile Data switch preference [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_title">Mobile data</string>
    <!-- Mobile network settings screen, summary of Mobile data switch preference [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_summary">Access data using mobile network</string>
    <!-- Mobile network settings screen, summary of Mobile data switch preference when the network
         is opportunistic and will always be used when it is in range. [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_summary_auto_switch">
        Phone will automatically switch to this carrier when in range
    </string>

    <!-- Mobile network settings screen, title of item showing the name of the default subscription
     that will be used for calls. This only appears in multi-SIM mode. [CHAR LIMIT=NONE] -->
    <string name="calls_preference">Calls preference</string>
    <!-- Mobile network settings screen, title of item showing the name of the default subscription
     that will be used for SMS messages. This only appears in multi-SIM mode. [CHAR LIMIT=NONE] -->
    <string name="sms_preference">SMS preference</string>
    <!-- Mobile network settings screen, a label in a chooser dialog that appears when choosing the
    default subscription to use for either calls or SMS when in multi-SIM mode. This label means
    that the user will be asked which mobile network subscription to use every time they place a
    call or send an SMS, instead of defaulting to one particular subscription. [CHAR LIMIT=40]-->
    <string name="calls_and_sms_ask_every_time">Ask every time</string>

    <!-- Summary of the 'Mobile network' item on the Network & internet page when there is no mobile
         service setup yet (eg no SIM card inserted and no eSIM configured). Tapping it leads to a
         UI where the user can setup service. [CHAR LIMIT=50] -->
    <string name="mobile_network_summary_add_a_network">Add a network</string>
    <!-- Summary of the 'Mobile network' item on the Network & internet page when there is more than
         one mobile service configured (aka "dual SIM") - it shows a count of SIM/eSIM and tapping
         it leads to a page showing a list of the mobile service subscriptions. [CHAR LIMIT=40] -->
    <plurals name="mobile_network_summary_count">
        <item quantity="one"><xliff:g id="count" example="1">%1$d</xliff:g> SIM</item>
        <item quantity="other"><xliff:g id="count" example="2">%1$d</xliff:g> SIMs</item>
    </plurals>

    <!-- Network & internet page. Summary indicating that a SIM is used by default for calls when
         multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_calls">Default for calls</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for SMS messages
         when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_sms">Default for SMS</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for calls and SMS
         messages when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_calls_and_sms">Default for calls &amp; SMS</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for mobile data
         when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_mobile_data">Default for mobile data</string>
    <!-- Network & internet page. Summary indicating that a SIM has an active mobile data connection
         when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="mobile_data_active">Mobile data active</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for mobile data
         when multiple SIMs are present, but mobile data is currently turned off.
         [CHAR LIMIT=50] -->
    <string name="mobile_data_off">Mobile data off</string>
    <!-- Network & internet page. Summary indicating that a SIM is available to be used for services
         such as calls, SMS, or data when multiple SIMs are present, but is not currently the
          default SIM for any of those services. [CHAR LIMIT=50] -->
    <string name="subscription_available">Available</string>
    <!-- Network & internet page. Summary indicating that a SIM is configured and may be used for
         some services, and that network is currently in range but not being used. For instance, it
         may be able to provide a mobile data connection that we aren't using because we're already
         connected to wifi. [CHAR LIMIT=50] -->
    <string name="mobile_network_in_range">In range</string>
    <!-- Network & internet page. Summary indicating that a SIM is configured and may be used for
         some services, but the network not currently in range. [CHAR LIMIT=50] -->
    <string name="mobile_network_not_in_range">Not in range</string>

    <!-- Title of item shown at the bottom of the page listing multiple mobile service
         subscriptions; tapping it leads to a UI to add more [CHAR LIMIT=40] -->
    <string name="mobile_network_list_add_more">Add more</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is active and is tied to a physical SIM card [CHAR LIMIT=40] -->
    <string name="mobile_network_active_sim">Active / SIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is inactive and is tied to a physical SIM card [CHAR LIMIT=40] -->
    <string name="mobile_network_inactive_sim">Inactive / SIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is active and is tied to an eSIM profile [CHAR LIMIT=40] -->
    <string name="mobile_network_active_esim">Active / Downloaded SIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is inactive and is tied to an eSIM profile [CHAR LIMIT=40] -->
    <string name="mobile_network_inactive_esim">Inactive / Downloaded SIM</string>
    <!-- Title of a dialog that lets a user modify the display name used for a mobile network
         subscription in various places in the Settings app. The default name is typically just the
         carrier name, but especially in multi-SIM configurations users may want to use a different
         name. [CHAR LIMIT=40] -->
    <string name="mobile_network_sim_name">SIM name &amp; color</string>
    <!-- Label for an item listing the name of the SIM that the user has specified. [CHAR LIMIT=40] -->
    <string name="mobile_network_sim_name_label">Name</string>
    <!-- Label for an item listing the color of the SIM that the user has specified. [CHAR LIMIT=40] -->
    <string name="mobile_network_sim_color_label">Color (used by compatible apps)</string>
    <!-- Label on the confirmation button of a dialog that lets a user set the display name and
         color of a mobile network subscription [CHAR LIMIT=20] -->
    <string name="mobile_network_sim_name_rename">Save</string>
    <!-- Label for the on position of a switch on the mobile network details page which allows
         disabling/enabling a SIM. The SIM is enabled in this state. [CHAR LIMIT=40] -->
    <string name="mobile_network_use_sim_on">Use SIM</string>
    <!-- Label for the off position of a switch on the mobile network details page which allows
         disabling/enabling a SIM. The SIM is disabled in this state. [CHAR LIMIT=40] -->
    <string name="mobile_network_use_sim_off">Off</string>
    <!-- Text shown in an information footer on the SIM details page for a physical SIM notifying
         the user that the way to disable this SIM is to physically remove it. This is in contrast
         to eSIM's, which can disabled using an on/off toggle switch. [CHAR LIMIT=NONE] -->
    <string name="mobile_network_disable_sim_explanation">
        To disable this SIM, remove the SIM card
    </string>

    <!--Summary used when a physical SIM is disabled, indicating that tapping on the preference will
        enable the SIM. This may be used as the summary of the 'Mobile network' item on the
        Network & internet page (if there are no other SIMs), or on the mobile network list page.
        [CHAR LIMIT=50] -->
    <string name="mobile_network_tap_to_activate">
        Tap to activate <xliff:g id="carrier" example="T-mobile">%1$s</xliff:g>
    </string>

    <!-- Title for a confirmation dialog when the user is enabling an eSIM subscription and there
         is already another active eSIM subscription which will need to be disabled if they proceed.
         [CHAR LIMIT=60] -->
    <string name="mobile_network_esim_swap_confirm_title">
        Switch to <xliff:g id="carrier" example="T-mobile">%1$s</xliff:g>?
    </string>
    <!-- Body of a confirmation dialog when the user is enabling an eSIM subscription and there
         is already another active eSIM subscription which will need to be disabled if they proceed.
         [CHAR LIMIT=NONE] -->
    <string name="mobile_network_esim_swap_confirm_body">
        Only one downloaded SIM can be active at a time.\n\nSwitching to
        <xliff:g id="carrier1" example="T-mobile">%1$s</xliff:g> won\u0027t cancel your
        <xliff:g id="carrier2" example="Verizon">%2$s</xliff:g> service.
    </string>
    <!-- Ok button label on confirmation dialog when the user is enabling an eSIM subscription and
         there is already another active eSIM subscription which will need to be disabled if they
         proceed. [CHAR LIMIT=25] -->
    <string name="mobile_network_esim_swap_confirm_ok">
        Switch to <xliff:g id="carrier" example="T-mobile">%1$s</xliff:g>
    </string>

    <!-- Mobile network details page. Label for an option that lets the user delete an eSIM from
         the device. [CHAR LIMIT=60] -->
    <string name="mobile_network_erase_sim">Erase SIM</string>

    <!-- Title of a dialog indicating that an error ocurred when deleting an eSIM from the device
         [CHAR LIMIT=60] -->
    <string name="mobile_network_erase_sim_error_dialog_title">Can\u2019t erase SIM</string>
    <!-- Body of a dialog indicating that an error ocurred when deleting an eSIM from the device
         [CHAR LIMIT=NONE] -->
    <string name="mobile_network_erase_sim_error_dialog_body">
        This SIM can\u2019t be erased due to an error.\n\nRestart your device and try again.
    </string>

    <!-- Title for preferred network type [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_title">Preferred network type</string>
    <!-- Summary for preferred network type [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_summary">Change the network operating mode</string>
    <!-- Dialog title for preferred network type [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_dialogtitle">Preferred network type</string>
    <!-- Mobile network settings screen, name of the option to manage carrier profiles on devices which support embedded carrier profiles [CHAR LIMIT=NONE] -->
    <string name="carrier_settings_euicc">Carrier</string>
    <!-- Mobile network settings screen, a string showing the version of carrier settings for this
         subscription [CHAR LIMIT=NONE] -->
    <string name="carrier_settings_version">Settings version</string>

    <!-- Mobile network settings screen, name for call settings category [CHAR LIMIT=NONE] -->
    <string name="call_category">Calling</string>
    <!-- Mobile network settings screen, title of Video calling setting [CHAR LIMIT=NONE] -->
    <string name="video_calling_settings_title">Carrier video calling</string>

    <!-- Mobile network settings screen, setting option name [CHAR LIMIT=NONE] -->
    <string name="cdma_system_select_title">System select</string>
    <!-- Mobile network settings screen, setting summary text [CHAR LIMIT=NONE] -->
    <string name="cdma_system_select_summary">Change the CDMA roaming mode</string>
    <!-- System select settings screen title [CHAR LIMIT=NONE] -->
    <string name="cdma_system_select_dialogtitle">System select</string>

    <!-- Mobile network settings screen, name for network operator category [CHAR LIMIT=NONE] -->
    <string name="network_operator_category">Network</string>
    <!-- Available networks screen, name of button when user wants to select network manually [CHAR LIMIT=NONE] -->
    <string name="network_select_title">Network</string>

    <!-- Title for CDMA subscription [CHAR LIMIT=50] -->
    <string name="cdma_subscription_title">CDMA subscription</string>
    <!-- Summary for CDMA subscription [CHAR LIMIT=NONE] -->
    <string name="cdma_subscription_summary">Change between RUIM/SIM and NV</string>
    <!-- Dialog title for CDMA subscription [CHAR LIMIT=30] -->
    <string name="cdma_subscription_dialogtitle">subscription</string>

    <!-- Title to register automatically [CHAR LIMIT=NONE] -->
    <string name="register_automatically">Automatic registration\u2026</string>
    <!-- Mobile network settings screen, dialog message title when user selects the Data roaming check box [CHAR LIMIT=120] -->
    <string name="roaming_alert_title">Allow data roaming?</string>
    <!-- Mobile network settings screen, message asking the user to check their pricing with their Carrier, when enabling Data roaming. [CHAR LIMIT=NONE] -->
    <string name="roaming_check_price_warning">Check with your network provider for pricing.</string>

    <!-- Title for mobile data preference, to display the mobile data usage for each app. [CHAR LIMIT=NONE]-->
    <string name="mobile_data_usage_title">App data usage</string>
    <!-- Summary to show the current network mode is invalid. [CHAR LIMIT=NONE]-->
    <string name="mobile_network_mode_error">Invalid Network Mode <xliff:g id="networkModeId" example="0">%1$d</xliff:g>. Ignore.</string>
    <!-- Title for Apn settings in mobile network settings [CHAR LIMIT=60] -->
    <string name="mobile_network_apn_title">Access Point Names</string>

    <!-- Available networks screen, summary when button disallowed due to permanent automatic mode [CHAR LIMIT=NONE] -->
    <string name="manual_mode_disallowed_summary">Unavailable when connected to <xliff:g id="carrier" example="verizon">%1$s</xliff:g></string>

    <!-- See more items in contextual homepage [CHAR LIMIT=30]-->
    <string name="see_more">See more</string>
    <!-- See less items in contextual homepage [CHAR LIMIT=30]-->
    <string name="see_less">See less</string>

    <!-- Title for Network connection request Dialog [CHAR LIMIT=60] -->
    <string name="network_connection_request_dialog_title">Device to use with <xliff:g id="appName" example="ThirdPartyAppName">%1$s</xliff:g></string>
    <!-- Message for Network connection timeout Dialog [CHAR LIMIT=NONE] -->
    <string name="network_connection_timeout_dialog_message">No devices found. Make sure devices are turned on and available to connect.</string>
    <!-- OK button for Network connection timeout Dialog [CHAR LIMIT=30] -->
    <string name="network_connection_timeout_dialog_ok">Try again</string>
    <!-- Message for Network connection error state Dialog [CHAR LIMIT=NONE] -->
    <string name="network_connection_errorstate_dialog_message">Something came up. The application has cancelled the request to choose a device.</string>
    <!-- Toast message when connection is successful [CHAR LIMIT=30] -->
    <string name="network_connection_connect_successful">Connection successful</string>
    <!-- Neutral button for Network connection request Dialog [CHAR LIMIT=30] -->
    <string name="network_connection_request_dialog_showall">Show all</string>
    <!-- Message for Network connection searching progress Dialog. Searching for wifi ap. [CHAR LIMIT=40] -->
    <string name="network_connection_searching_message">Searching for device\u2026</string>
    <!-- Message for Network connection connecting progress Dialog. Try to connect to wifi ap.[CHAR LIMIT=40] -->
    <string name="network_connection_connecting_message">Connecting to device\u2026</string>

    <!-- Title for left bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_left_name">Left</string>
    <!-- Title for right bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_right_name">Right</string>
    <!-- Title for middle bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_middle_name">Case</string>

    <!-- Default title for the settings panel [CHAR LIMIT=NONE] -->
    <string name="settings_panel_title">Settings Panel</string>

    <!-- Title for the Internet Connectivity dialog (settings panel) with Internet related settings [CHAR LIMIT=50] -->
    <string name="internet_connectivity_panel_title">Internet Connectivity</string>

    <!-- Title for the Volume dialog (settings panel) with all volume streams[CHAR LIMIT=50] -->
    <string name="volume_connectivity_panel_title">Volume</string>

    <!-- Subtitle explaining that mobile data cannot be used while airplane mode is on [CHAR LIMIT=50] -->
    <string name="mobile_data_ap_mode_disabled">Unavailable during airplane mode</string>

    <!-- UI debug setting: force desktop mode [CHAR LIMIT=50] -->
    <string name="force_desktop_mode">Force desktop mode</string>
    <!-- UI debug setting: force desktop mode summary [CHAR LIMIT=NONE] -->
    <string name="force_desktop_mode_summary">Force experimental desktop mode on secondary displays</string>
    <!-- UI debug setting: enable non-resizables in freeform [CHAR LIMIT=50] -->
    <string name="enable_sizecompat_freeform">Enable freeform sizecompat</string>
    <!-- UI debug setting: enable non-resizables in freeform summary [CHAR LIMIT=NONE] -->
    <string name="enable_sizecompat_freeform_summary">Allows sizecompat apps to be in freeform</string>

    <!-- UI debug setting: Force enable "smart dark" UI rendering feature [CHAR LIMIT=60] -->
    <string name="hwui_force_dark_title">Override force-dark</string>
    <!-- UI debug setting: Force enable "smart dark" UI rendering feature summary [CHAR LIMIT=NONE] -->
    <string name="hwui_force_dark_summary">Overrides the force-dark feature to be always-on</string>

    <!-- Title for the top level Privacy Settings [CHAR LIMIT=30]-->
    <string name="privacy_dashboard_title">Privacy</string>
    <!-- Summary for the top level Privacy Settings [CHAR LIMIT=NONE]-->
    <string name="privacy_dashboard_summary">Permissions, account activity, personal data</string>

    <!-- Label for button in contextual card for users to remove the card [CHAR LIMIT=30] -->
    <string name="contextual_card_dismiss_remove">Remove</string>
    <!-- Label for button in contextual card for users to keep the card [CHAR LIMIT=30] -->
    <string name="contextual_card_dismiss_keep">Keep</string>
    <!-- String for contextual card dismissal [CHAR LIMIT=NONE] -->
    <string name="contextual_card_dismiss_confirm_message">Remove this suggestion?</string>
    <!-- String for snack bar message when users swipe to dismiss a contextual card [CHAR LIMIT=60]-->
    <string name="contextual_card_removed_message">Suggestion removed</string>
    <!-- Label for snack bar action allowing users to undo contextual card dismissal [CHAR LIMIT=30]-->
    <string name="contextual_card_undo_dismissal_text">Undo</string>

    <!-- Summary for low storage slice. [CHAR LIMIT=NONE] -->
    <string name="low_storage_summary">Storage is low. <xliff:g id="percentage" example="54%">%1$s</xliff:g> used - <xliff:g id="free_space" example="32GB">%2$s</xliff:g> free</string>

    <!-- Label for button in contextual card feedback dialog for users to send feedback [CHAR LIMIT=30] -->
    <string name="contextual_card_feedback_send">Send feedback</string>
    <!-- String for contextual card feedback dialog [CHAR LIMIT=NONE] -->
    <string name="contextual_card_feedback_confirm_message">Would you like to give us feedback on this suggestion?</string>

    <!-- Toast message for copy action of Copyable Slice [CHAR LIMIT=NONE] -->
    <string name="copyable_slice_toast"><xliff:g id="copy_content" example="Phone number">%1$s</xliff:g> copied to clipboard.</string>

    <!-- String for talkback on the account avatar of the search bar.  [CHAR LIMIT=NONE] -->
    <string name="search_bar_account_avatar_content_description"></string>

    <!-- Text to display when no app used permission.  [CHAR LIMIT=NONE] -->
    <string name="permission_bar_chart_empty_text">0 apps used permissions</string>

    <!-- Text for permission bar chart title in Privacy page.  [CHAR LIMIT=NONE] -->
    <string name="permission_bar_chart_title">Permission usage in last 24 hours</string>

    <!-- Text for permission bar chart details in Privacy page.  [CHAR LIMIT=NONE] -->
    <string name="permission_bar_chart_details">See all in Dashboard</string>

    <plurals name="permission_bar_chart_label">
        <item quantity="one">1 app</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> apps</item>
    </plurals>

    <!-- Title for the accessibility usage preference in the Privacy page.  [CHAR LIMIT=NONE] -->
    <string name="accessibility_usage_title">Accessibility usage</string>

    <!-- Summary for the accessibility usage preference in the Privacy page.  [CHAR LIMIT=NONE] -->
    <plurals name="accessibility_usage_summary">
        <item quantity="one">1 app has full access to your device</item>
        <item quantity="other"><xliff:g id="service_count">%1$d</xliff:g> apps have full access to your device</item>
    </plurals>

    <!-- Title for notification channel slice. [CHAR LIMIT=NONE] -->
    <string name="manage_app_notification">Manage <xliff:g id="app_name" example="Settings">%1$s</xliff:g> notifications</string>
    <!-- Title for no suggested app in notification channel slice. [CHAR LIMIT=NONE] -->
    <string name="no_suggested_app">No suggested application</string>
    <!-- Summary for the channels count is equal or less than 3 in notification channel slice. [CHAR LIMIT=NONE] -->
    <plurals name="notification_few_channel_count_summary">
        <item quantity="one"><xliff:g id="notification_channel_count" example="1">%1$d</xliff:g> notification channel.</item>
        <item quantity="other"><xliff:g id="notification_channel_count" example="3">%1$d</xliff:g> notification channels.</item>
    </plurals>
    <!-- Summary for the channels count is more than 3 in notification channel slice. [CHAR LIMIT=NONE] -->
    <string name="notification_many_channel_count_summary"><xliff:g id="notification_channel_count" example="4">%1$d</xliff:g> notification channels. Tap to manage all.</string>
    <!-- Summary for recently installed app in contextual notification channel slice. [CHAR LIMIT=NONE] -->
    <string name="recently_installed_app">You recently installed this app.</string>

    <!-- Title for the Switch output dialog (settings panel) with media related devices [CHAR LIMIT=50] -->
    <string name="media_output_panel_title">Switch output</string>
    <!-- Summary for represent which device is playing media [CHAR LIMIT=NONE] -->
    <string name="media_output_panel_summary_of_playing_device">Currently playing on <xliff:g id="device_name" example="Bose headphone">%1$s</xliff:g></string>
    <!-- Summary for disconnected status [CHAR LIMIT=50] -->
    <string name="media_output_disconnected_status"><xliff:g id="device_name" example="My device">%1$s</xliff:g> (disconnected)</string>
    <!-- Summary for switching error state [CHAR LIMIT=40] -->
    <string name="media_output_switch_error_text">Can\u2019t switch. Tap to try again.</string>

    <!-- Label for the title on wfc disclaimer fragment. [CHAR LIMIT=40] -->
    <string name="wfc_disclaimer_title_text">Important information</string>

    <!-- Label for the agree button on wfc disclaimer fragment. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_agree_button_text">CONTINUE</string>

    <!-- Label for the disagree button on wfc disclaimer fragment. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_disagree_text">NO THANKS</string>

    <!-- Label for the title on wfc disclaimer location. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_location_title_text">Location</string>

    <!-- Warn the user that the phone may share its location with the service provider. [CHAR LIMIT=NONE] -->
    <string name="wfc_disclaimer_location_desc_text">Your service provider may collect your location in order to provide this service.\n\nPlease review your service provider\u2019s privacy policy.</string>

    <!-- Message for forget passpoint dialog [CHAR LIMIT=none] -->
    <string name="forget_passpoint_dialog_message">You may lose access to any remaining time or data. Check with your provider before removing.</string>

    <!-- Keywords for Content Capture feature [CHAR_LIMIT=none] -->
    <string name="keywords_content_capture">content capture, app content</string>
    <!-- Title of the 'Content Capture' feature toggle in the Settings -> Privacy screen [CHAR LIMIT=none]-->
    <string name="content_capture">App content</string>
    <!-- Description of the 'Content Capture' feature toggle in the Settings -> Privacy screen [CHAR LIMIT=NONE]-->
    <string name="content_capture_summary">Allow apps to send content to the Android system</string>

    <!-- Title for the button to initiate a heap dump for the system server. [CHAR LIMIT=NONE] -->
    <string name="capture_system_heap_dump_title">Capture system heap dump</string>
    <!-- Toast that is shown when the user initiates capturing a heap dump for the system server. [CHAR LIMIT=NONE] -->
    <string name="capturing_system_heap_dump_message">Capturing system heap dump</string>
    <!-- Toast that is shown if there's an error capturing the user initiated heap dump. [CHAR LIMIT=NONE] -->
    <string name="error_capturing_system_heap_dump_message">Couldn\u2019t capture system heap dump</string>
    <!-- Title of toggle for whether to enable automatic heap dumps for the system server or not. [CHAR LIMIT=NONE] -->
    <string name="automatic_system_heap_dump_title">Automatically capture system heap dumps</string>
    <!-- Summary of toggle for whether to enable automatic heap dumps for the system server or not. [CHAR LIMIT=NONE] -->
    <string name="automatic_system_heap_dump_summary">Automatically capture a heap dump for Android System when it uses too much memory</string>

    <!-- Button label to disconnect a Wi-Fi network. [CHAR LIMIT=40] -->
    <string name="wifi_disconnect_button_text">Disconnect</string>

    <!-- Label for the title on wfc disclaimer location. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_emergency_limitation_title_text">Emergency calls</string>

    <!-- Warn the user that the phone have emergency call limitation. [CHAR LIMIT=NONE] -->
    <string name="wfc_disclaimer_emergency_limitation_desc_text">Emergency calls over Wi\u2011Fi Calling are not supported by your carrier.\nThe device switches automatically to a cellular network to place an emergency call.\nEmergency calls are only possible in areas with cellular coverage.</string>

    <!-- Summary for Wi-Fi calling to explain this feature [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_summary">Use Wi\u2011Fi for calls to improve quality</string>

    <!-- Title for enable MMS notification when trying to receive MMS.  [CHAR LIMIT=40] -->
    <string name="enable_receiving_mms_notification_title">Incoming MMS message</string>
    <!-- Title for enable MMS notification when trying to send MMS.  [CHAR LIMIT=40] -->
    <string name="enable_sending_mms_notification_title">Can\u2019t send MMS message</string>
    <!-- Message under title informing the user to touch to go to SIM Cards in Settings.  [CHAR LIMIT=100] -->
    <string name="enable_mms_notification_summary">Tap to allow MMS messaging on <xliff:g id="operator_name" example="T-Mobile">%1$s</xliff:g> when mobile data is off</string>

    <!-- Title for enable MMS notification channel.  [CHAR LIMIT=40] -->
    <string name="enable_mms_notification_channel_title">MMS message</string>

    <!-- Title for SIM combination warning. [CHAR LIMIT=80] -->
    <string name="sim_combination_warning_notification_title">Issue with SIM combination</string>
    <!-- Message for DSDS dual CDMA SIM combination warning. [CHAR LIMIT=100] -->
    <string name="dual_cdma_sim_warning_notification_summary">Using <xliff:g id="operator_names" example="T-Mobile &amp; Verizon">%1$s</xliff:g> may limit functionality. Tap to learn more.</string>

    <!-- Title for enable MMS notification channel.  [CHAR LIMIT=40] -->
    <string name="dual_cdma_sim_warning_notification_channel_title">SIM combination</string>

    <!-- Title of setting on privacy settings screen that will show work policy info. [CHAR LIMIT=NONE] -->
    <string name="work_policy_privacy_settings">Your work policy info</string>
    <!-- Summary for Enterprise Privacy settings, explaining what the user can expect to find under it [CHAR LIMIT=NONE]-->
    <string name="work_policy_privacy_settings_summary">Settings managed by your IT admin</string>

    <!-- Developer Settings: Search keywords for the Profile HWUI rendering. [CHAR_LIMIT=NONE] -->
    <string name="track_frame_time_keywords">GPU</string>

    <!-- DSU Loader. Do not translate. -->
    <string name="dsu_loader_title" translatable="false">DSU Loader</string>
    <!-- DSU Loader Description. Do not translate. -->
    <string name="dsu_loader_description" translatable="false">Load a Dynamic System Update Image</string>
    <!-- DSU Loader Loading. Do not translate. -->
    <string name="dsu_loader_loading" translatable="false">Loading...</string>

    <!-- Name of dev option called "Bug report handler" [CHAR LIMIT=NONE] -->
    <string name="bug_report_handler_title">Bug report handler</string>

    <!-- Developer Settings: Footer text for bug report handler picker [CHAR LIMIT=NONE] -->
    <string name="bug_report_handler_picker_footer_text">Determines which app handles the Bug Report shortcut on your device.</string>

    <!-- Subtext of personal profile app for current setting [CHAR LIMIT=NONE] -->
    <string name="personal_profile_app_subtext">Personal</string>

    <!-- Subtext of work profile app for current setting [CHAR LIMIT=NONE] -->
    <string name="work_profile_app_subtext">Work</string>

    <!-- Subtext of system default app for current setting [CHAR LIMIT=NONE] -->
    <string name="system_default_app_subtext">System default</string>

    <!-- Developer settings: text for the bug report handler selection toast shown if an invalid bug report handler was chosen. [CHAR LIMIT=NONE] -->
    <string name="select_invalid_bug_report_handler_toast_text">This choice is no longer valid. Try again.</string>

    <!-- Title for RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_title"></string>
    <!-- Subtext for showing the option of RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_no_visible"></string>
    <!-- Subtext for showing the option of RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_visible_during_call"></string>
    <!-- Subtext for showing the option of RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_always_visible"></string>

    <!-- Button label to stop casting on media device. [CHAR LIMIT=40 -->
    <string name="media_output_panel_stop_casting_button">Stop casting</string>
</resources>
