<?xml version="1.0" encoding="utf-8"?>
<!--
/*
**
** Copyright 2015 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">
    <!-- Toast message when Wi-Fi cannot scan for networks -->
    <string name="wifi_fail_to_scan">Can\'t scan for networks</string>
    <!-- Do not translate.  Concise terminology for wifi with WEP security -->
    <string name="wifi_security_short_wep" translatable="false">WEP</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA security -->
    <string name="wifi_security_short_wpa" translatable="false">WPA</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA2 security -->
    <string name="wifi_security_short_wpa2" translatable="false">WPA2</string>
    <!-- Do not translate.  Concise terminology for wifi with both WPA/WPA2 security -->
    <string name="wifi_security_short_wpa_wpa2" translatable="false">WPA/WPA2</string>
    <!-- Do not translate.  Concise terminology for wifi with unknown PSK type -->
    <string name="wifi_security_short_psk_generic" translatable="false">@string/wifi_security_short_wpa_wpa2</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP security -->
    <string name="wifi_security_short_eap" translatable="false">802.1x</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA 802.1x EAP security -->
    <string name="wifi_security_short_eap_wpa" translatable="false">WPA-EAP</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA2/WPA3 802.1x EAP security -->
    <string name="wifi_security_short_eap_wpa2_wpa3" translatable="false">RSN-EAP</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA3 security -->
    <string name="wifi_security_short_sae" translatable="false">WPA3</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA2/WPA3 transition security -->
    <string name="wifi_security_short_psk_sae" translatable="false">WPA2/WPA3</string>
    <!-- Do not translate.  Concise terminology for Wi-Fi with None/OWE transition mode security -->
    <string name="wifi_security_short_none_owe" translatable="false">None/OWE</string>
    <!-- Do not translate.  Concise terminology for wifi with OWE security -->
    <string name="wifi_security_short_owe" translatable="false">OWE</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP Suite-B-192 security -->
    <string name="wifi_security_short_eap_suiteb" translatable="false">Suite-B-192</string>

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

    <!-- Do not translate.  Terminology for wifi with WEP security -->
    <string name="wifi_security_wep" translatable="false">WEP</string>
    <!-- Do not translate.  Terminology for wifi with WPA security -->
    <string name="wifi_security_wpa" translatable="false">WPA-Personal</string>
    <!-- Do not translate.  Terminology for wifi with WPA2 security -->
    <string name="wifi_security_wpa2" translatable="false">WPA2-Personal</string>
    <!-- Do not translate.  Terminology for wifi with both WPA/WPA2 security, or unknown -->
    <string name="wifi_security_wpa_wpa2" translatable="false">WPA/WPA2-Personal</string>
    <!-- Do not translate.  Terminology for wifi with unknown PSK type -->
    <string name="wifi_security_psk_generic" translatable="false">@string/wifi_security_wpa_wpa2</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP security -->
    <string name="wifi_security_eap" translatable="false">WPA/WPA2/WPA3-Enterprise</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA 802.1x EAP security -->
    <string name="wifi_security_eap_wpa" translatable="false">WPA-Enterprise</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA2/WPA3 802.1x EAP security -->
    <string name="wifi_security_eap_wpa2_wpa3" translatable="false">WPA2/WPA3-Enterprise</string>
    <!-- Do not translate.  Concise terminology for Passpoint network -->
    <string name="wifi_security_passpoint" translatable="false">Passpoint</string>
    <!-- Do not translate.  Terminology for wifi with WPA3 security -->
    <string name="wifi_security_sae" translatable="false">WPA3-Personal</string>
    <!-- Do not translate.  Terminology for wifi with WPA2/WPA3 Transition mode security -->
    <string name="wifi_security_psk_sae" translatable="false">WPA2/WPA3-Personal</string>
    <!-- Do not translate.  Terminology for Wi-Fi with None/OWE transition mode security -->
    <string name="wifi_security_none_owe" translatable="false">None/Enhanced Open</string>
    <!-- Do not translate.  Terminology for wifi with OWE security -->
    <string name="wifi_security_owe" translatable="false">Enhanced Open</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP Suite-B-192 security -->
    <string name="wifi_security_eap_suiteb" translatable="false">WPA3-Enterprise 192-bit</string>

    <!-- Summary for the remembered network. -->
    <string name="wifi_remembered">Saved</string>
    <!-- Summary for the disconnected network. [CHAR LIMIT=40] -->
    <string name="wifi_disconnected">Disconnected</string>
    <!-- Status for networks disabled for unknown reason -->
    <string name="wifi_disabled_generic">Disabled</string>
    <!-- Status for networked disabled from a DNS or DHCP failure -->
    <string name="wifi_disabled_network_failure">IP Configuration Failure</string>
    <!-- Status for networks disabled by the network recommendation provider -->
    <string name="wifi_disabled_by_recommendation_provider">Not connected due to low quality network</string>
    <!-- Status for networked disabled from a wifi association failure -->
    <string name="wifi_disabled_wifi_failure">WiFi Connection Failure</string>
    <!-- Status for networks disabled from authentication failure (wrong password
         or certificate). -->
    <string name="wifi_disabled_password_failure">Authentication problem</string>

    <!-- Status detail for a network that can't be connected to for some reason -->
    <string name="wifi_cant_connect">Can\'t connect</string>
    <!-- Status for a named network that can't be connected to for some reason-->
    <string name="wifi_cant_connect_to_ap">Can\'t connect to \'<xliff:g id="ap_name">%1$s</xliff:g>\'</string>
    <!-- Message shown when the user likely entered an incorrect password for a wifi network -->
    <string name="wifi_check_password_try_again">Check password and try again</string>

    <!-- Summary for the remembered network but currently not in range. -->
    <string name="wifi_not_in_range">Not in range</string>
    <!-- Summary for the network but no internet connection was detected. -->
    <string name="wifi_no_internet_no_reconnect">Won\'t automatically connect</string>
    <!-- Summary for the remembered network but no internet connection was detected. -->
    <string name="wifi_no_internet">No internet access</string>
    <!-- Summary for saved networks -->
    <string name="saved_network">Saved by <xliff:g id="name">%1$s</xliff:g></string>

    <!-- Status message of Wi-Fi when it is automatically connected by a network recommendation provider. [CHAR LIMIT=NONE] -->
    <string name="connected_via_network_scorer">Automatically connected via %1$s</string>
    <!-- Status message of Wi-Fi when it is automatically connected by a default network recommendation provider. [CHAR LIMIT=NONE] -->
    <string name="connected_via_network_scorer_default">Automatically connected via network rating provider</string>
    <!-- Status message of Wi-Fi when it is connected by Passpoint configuration. [CHAR LIMIT=NONE] -->
    <string name="connected_via_passpoint">Connected via %1$s</string>
    <!-- Status message of Wi-Fi when it is connected by a app (via suggestion or network request). [CHAR LIMIT=NONE] -->
    <string name="connected_via_app">Connected via <xliff:g id="name" example="Wifi App">%1$s</xliff:g></string>
    <!-- Status message of Wi-Fi when network has matching passpoint credentials. [CHAR LIMIT=NONE] -->
    <string name="available_via_passpoint">Available via %1$s</string>
    <!-- Status message of OSU Provider network when not connected. [CHAR LIMIT=NONE] -->
    <string name="tap_to_sign_up">Tap to sign up</string>
    <!-- Package name for Settings app-->
    <string name="settings_package" translatable="false">com.android.settings</string>
    <!-- Package name for Certinstaller app-->
    <string name="certinstaller_package" translatable="false">com.android.certinstaller</string>

    <!-- Summary for Connected wifi network without internet -->
    <string name="wifi_connected_no_internet">No internet</string>

    <!-- Summary for connected network without internet due to private dns validation failed [CHAR LIMIT=NONE] -->
    <string name="private_dns_broken">Private DNS server cannot be accessed</string>

    <!-- Summary for connected wifi network with partial internet connectivity [CHAR LIMIT=50] -->
    <string name="wifi_limited_connection">Limited connection</string>

    <!-- Wi-Fi status indicating that the current network is connected, but has no internet access. -->
    <string name="wifi_status_no_internet">No internet</string>

    <!-- Wi-Fi status indicating that the current network is connected requires sign in to access the internet. -->
    <string name="wifi_status_sign_in_required">Sign in required</string>

    <!-- Summary for networks failing to connect due to association rejection status 17, AP full -->
    <string name="wifi_ap_unable_to_handle_new_sta">Access point temporarily full</string>

    <!-- Status message of Wi-Fi when it is connected to a Carrier Network. [CHAR LIMIT=NONE] -->
    <string name="connected_via_carrier">Connected via %1$s</string>
    <!-- Status message of Wi-Fi when an available network is a carrier network. [CHAR LIMIT=NONE] -->
    <string name="available_via_carrier">Available via %1$s</string>

    <!-- Status message of OSU Provider upon initiating provisioning flow [CHAR LIMIT=NONE] -->
    <string name="osu_opening_provider">Opening <xliff:g id="passpointProvider" example="Passpoint Provider">%1$s</xliff:g></string>
    <!-- Status message of OSU Provider when connection fails [CHAR LIMIT=NONE] -->
    <string name="osu_connect_failed">Couldn\u2019t connect</string>
    <!-- Status message of OSU Provider after user completes provisioning flow [CHAR LIMIT=NONE] -->
    <string name="osu_completing_sign_up">Completing sign-up\u2026</string>
    <!-- Status message of OSU Provider when sign up could not be completed [CHAR LIMIT=NONE] -->
    <string name="osu_sign_up_failed">Couldn\u2019t complete sign-up. Tap to try again.</string>
    <!-- Status message of OSU Provider on completing provisioning. [CHAR LIMIT=NONE] -->
    <string name="osu_sign_up_complete">Sign-up complete. Connecting\u2026</string>

    <!-- Speed label for very slow network speed -->
    <string name="speed_label_very_slow">Very Slow</string>
    <!-- Speed label for slow network speed -->
    <string name="speed_label_slow">Slow</string>
    <!-- Speed label for okay network speed -->
    <string name="speed_label_okay">OK</string>
    <!-- Speed label for medium network speed -->
    <string name="speed_label_medium">Medium</string>
    <!-- Speed label for fast network speed -->
    <string name="speed_label_fast">Fast</string>
    <!-- Speed label for very fast network speed -->
    <string name="speed_label_very_fast">Very Fast</string>

    <!-- Passpoint summary for an expired passpoint [CHAR LIMIT=40] -->
    <string name="wifi_passpoint_expired">Expired</string>

    <!-- Summary text separator for preferences including a short description (eg. "Fast / Connected"). -->
    <string name="preference_summary_default_combination"><xliff:g id="state" example="ON">%1$s</xliff:g> / <xliff:g id="description" example="High accuracy mode">%2$s</xliff:g></string>

    <!-- Bluetooth settings.  Message when a device is disconnected -->
    <string name="bluetooth_disconnected">Disconnected</string>
    <!-- Bluetooth settings.  Message when disconnecting from a device -->
    <string name="bluetooth_disconnecting">Disconnecting\u2026</string>
     <!-- Bluetooth settings.  Message when connecting to a device -->
    <string name="bluetooth_connecting">Connecting\u2026</string>
    <!-- Bluetooth settings.  Message when connected to a device. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected">Connected<xliff:g id="active_device">%1$s</xliff:g></string>
    <!--Bluetooth settings screen, summary text under individual Bluetooth devices when pairing -->
    <string name="bluetooth_pairing">Pairing\u2026</string>

    <!-- Bluetooth settings.  Message when connected to a device, except for phone audio. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_headset">Connected (no phone)<xliff:g id="active_device">%1$s</xliff:g></string>
    <!-- Bluetooth settings.  Message when connected to a device, except for media audio. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_a2dp">Connected (no media)<xliff:g id="active_device">%1$s</xliff:g></string>
    <!-- Bluetooth settings.  Message when connected to a device, except for map. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_map">Connected (no message access)<xliff:g id="active_device">%1$s</xliff:g></string>
    <!-- Bluetooth settings.  Message when connected to a device, except for phone/media audio. [CHAR LIMIT=40] -->
    <string name="bluetooth_connected_no_headset_no_a2dp">Connected (no phone or media)<xliff:g id="active_device">%1$s</xliff:g></string>

    <!-- Bluetooth settings.  Message when connected to a device, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connected_battery_level">Connected, battery <xliff:g id="battery_level_as_percentage">%1$s</xliff:g><xliff:g id="active_device">%2$s</xliff:g></string>
    <!-- Bluetooth settings.  Message when connected to a device, except for phone audio, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connected_no_headset_battery_level">Connected (no phone), battery <xliff:g id="battery_level_as_percentage">%1$s</xliff:g><xliff:g id="active_device">%2$s</xliff:g></string>
    <!-- Bluetooth settings.  Message when connected to a device, except for media audio, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connected_no_a2dp_battery_level">Connected (no media), battery <xliff:g id="battery_level_as_percentage">%1$s</xliff:g><xliff:g id="active_device">%2$s</xliff:g></string>
    <!-- Bluetooth settings.  Message when connected to a device, except for phone/media audio, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connected_no_headset_no_a2dp_battery_level">Connected (no phone or media), battery <xliff:g id="battery_level_as_percentage">%1$s</xliff:g><xliff:g id="active_device">%2$s</xliff:g></string>

    <!-- Connected devices settings. Message when Bluetooth is connected and active, showing remote device status and battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_active_battery_level">Active, <xliff:g id="battery_level_as_percentage">%1$s</xliff:g> battery</string>
    <!-- Connected devices settings. Message when Bluetooth is connected and active, showing remote device status and battery level for untethered headset. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_active_battery_level_untethered">Active, L: <xliff:g id="battery_level_as_percentage" example="25%">%1$s</xliff:g> battery, R: <xliff:g id="battery_level_as_percentage" example="25%">%2$s</xliff:g> battery</string>
    <!-- Connected devices settings. Message when Bluetooth is connected but not in use, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_battery_level"><xliff:g id="battery_level_as_percentage">%1$s</xliff:g> battery</string>
    <!-- Connected devices settings. Message when Bluetooth is connected but not in use, showing remote device battery level for untethered headset. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_battery_level_untethered">L: <xliff:g id="battery_level_as_percentage" example="25%">%1$s</xliff:g> battery, R: <xliff:g id="battery_level_as_percentage" example="25%">%2$s</xliff:g> battery</string>
    <!-- Connected devices settings. Message when Bluetooth is connected and active but no battery information, showing remote device status. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_active_no_battery_level">Active</string>

    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the A2DP profile. -->
    <string name="bluetooth_profile_a2dp">Media audio</string>
    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the headset or handsfree profile. -->
    <string name="bluetooth_profile_headset">Phone calls</string>
    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the OPP profile. -->
    <string name="bluetooth_profile_opp">File transfer</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the HID profile. -->
    <string name="bluetooth_profile_hid">Input device</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the PAN profile (accessing Internet through remote device). [CHAR LIMIT=40] -->
    <string name="bluetooth_profile_pan">Internet access</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the PBAP profile. [CHAR LIMIT=40] -->
    <string name="bluetooth_profile_pbap">Contact sharing</string>
    <!-- Bluetooth settings. The user-visible summary string that is used whenever referring to the PBAP profile (sharing contacts). [CHAR LIMIT=60] -->
    <string name="bluetooth_profile_pbap_summary">Use for contact sharing</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the PAN profile (sharing this device's Internet connection). [CHAR LIMIT=40] -->
    <string name="bluetooth_profile_pan_nap">Internet connection sharing</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the map profile. -->
    <string name="bluetooth_profile_map">Text Messages</string>
    <!-- Bluetooth settings. The user-visible string that is used whenever referring to the SAP profile (sharing SIM card). -->
    <string name="bluetooth_profile_sap">SIM Access</string>

    <!-- Bluetooth settings. The user-visible string for the setting controlling whether to use a high-quality codec if the device supports it, along with the name of the codec (eg AAC, LDAC, aptX) -->
    <string name="bluetooth_profile_a2dp_high_quality">HD audio: <xliff:g id="codec_name">%1$s</xliff:g></string>

    <!-- Bluetooth settings. Similar to bluetooth_profile_a2dp_high_quality, but used when the device supports high quality audio but we don't know which codec that will be used. -->
    <string name="bluetooth_profile_a2dp_high_quality_unknown_codec">HD audio</string>

    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the Hearing Aid profile. -->
    <string name="bluetooth_profile_hearing_aid">Hearing Aids</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the Hearing Aid checkbox preference when Hearing Aid is connected. -->
    <string name="bluetooth_hearing_aid_profile_summary_connected">Connected to Hearing Aids</string>

    <!-- Bluetooth settings.  Connection options screen.  The summary for the A2DP checkbox preference when A2DP is connected. -->
    <string name="bluetooth_a2dp_profile_summary_connected">Connected to media audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the headset checkbox preference when headset is connected. -->
    <string name="bluetooth_headset_profile_summary_connected">Connected to phone audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference when OPP is connected. -->
    <string name="bluetooth_opp_profile_summary_connected">Connected to file transfer server</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the map checkbox preference when map is connected. -->
    <string name="bluetooth_map_profile_summary_connected">Connected to map</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the sap checkbox preference when SAP is connected. -->
    <string name="bluetooth_sap_profile_summary_connected">Connected to SAP</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference when OPP is not connected. -->
    <string name="bluetooth_opp_profile_summary_not_connected">Not connected to file transfer server</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the HID checkbox preference when HID is connected. -->
    <string name="bluetooth_hid_profile_summary_connected">Connected to input device</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the checkbox preference when PAN is connected (user role). [CHAR LIMIT=25]-->
    <string name="bluetooth_pan_user_profile_summary_connected">Connected to device for internet access</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the checkbox preference when PAN is connected (NAP role). [CHAR LIMIT=25]-->
    <string name="bluetooth_pan_nap_profile_summary_connected">Sharing local internet connection with device</string>

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

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

    <!-- Message in pairing dialogs.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_will_share_phonebook">Pairing grants access to your contacts and call history when connected.</string>
    <!-- Message for the error dialog when BT pairing fails generically. -->
    <string name="bluetooth_pairing_error_message">Couldn\'t pair with <xliff:g id="device_name">%1$s</xliff:g>.</string>

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

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=4875089335641234463] -->
    <string name="bluetooth_talkback_computer">Computer</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=5140152177885220949] -->
    <string name="bluetooth_talkback_headset">Headset</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=4260255181240622896] -->
    <string name="bluetooth_talkback_phone">Phone</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=551146170554589119] -->
    <string name="bluetooth_talkback_imaging">Imaging</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=26580326066627664] -->
    <string name="bluetooth_talkback_headphone">Headphone</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=5165842622743212268] -->
    <string name="bluetooth_talkback_input_peripheral">Input Peripheral</string>

    <!-- Message for telling the user the kind of BT device being displayed in list. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=5615463912185280812] -->
    <string name="bluetooth_talkback_bluetooth">Bluetooth</string>

    <!-- Message for telling the user the left-side hearing aid device is doing its pairing operation [CHAR LIMIT=NONE] -->
    <string name="bluetooth_hearingaid_left_pairing_message">Pairing left hearing aid\u2026</string>
    <!-- Message for telling the user the right-side hearing aid device is doing its pairing operation [CHAR LIMIT=NONE] -->
    <string name="bluetooth_hearingaid_right_pairing_message">Pairing right hearing aid\u2026</string>
    <!-- Bluetooth settings.  Message when connected to a left-side Hearing Aid device, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_hearingaid_left_battery_level">Left - <xliff:g id="battery_level_as_percentage">%1$s</xliff:g> battery</string>
    <!-- Bluetooth settings.  Message when connected to a right-side Hearing Aid device, showing remote device battery level. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_hearingaid_right_battery_level">Right - <xliff:g id="battery_level_as_percentage">%1$s</xliff:g> battery</string>

    <!-- Content description of the WIFI signal when WIFI is disabled for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_off">Wifi off.</string>
    <!-- Content description of the WIFI signal when no signal for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_no_wifi">Wifi disconnected.</string>
    <!-- Content description of the WIFI signal when it is one bar for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_one_bar">Wifi one bar.</string>
    <!-- Content description of the WIFI signal when it is two bars for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_two_bars">Wifi two bars.</string>
    <!-- Content description of the WIFI signal when it is three bars for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_three_bars">Wifi three bars.</string>
    <!-- Content description of the WIFI signal when it is full for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_signal_full">Wifi signal full.</string>

    <!-- Content description of the Wi-Fi security type. This message indicates this is an open Wi-Fi (no password needed) [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_security_type_none">Open network</string>

    <!-- Content description of the Wi-Fi security type. This message indicates this is a secured Wi-Fi (password needed) [CHAR LIMIT=NONE] -->
    <string name="accessibility_wifi_security_type_secured">Secure network</string>

    <!-- Label for kernel threads in battery usage -->
    <string name="process_kernel_label">Android OS</string>
    <!-- Title of data usage item that represents all uninstalled applications. [CHAR LIMIT=48] -->
    <string name="data_usage_uninstalled_apps">Removed apps</string>
    <!-- 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>
    <!-- Title of data usage item that represents system updates (OTAs). [CHAR LIMIT=48] -->
    <string name="data_usage_ota">System updates</string>


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

    <!-- Title for a work profile. [CHAR LIMIT=25] -->
    <string name="managed_user_title">All work apps</string>

    <!-- Title for Guest user [CHAR LIMIT=35] -->
    <string name="user_guest">Guest</string>

    <!-- Manage apps, individual app screen, substituted for the application's label when the app's label CAN NOT be determined.-->
    <string name="unknown">Unknown</string>

    <!-- [CHAR LIMIT=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>

    <!-- Launch defaults preference summary with some set [CHAR LIMIT=40] -->
    <string name="launch_defaults_some">Some defaults set</string>
    <!-- Launch defaults preference summary with none set [CHAR LIMIT=40] -->
    <string name="launch_defaults_none">No defaults set</string>
    <!-- DO NOT TRANSLATE Empty summary for dynamic preferences -->
    <string name="summary_empty" translatable="false"></string>
    <!-- Text-To-Speech (TTS) settings --><skip />
    <!-- Name of the TTS package as listed by the package manager. -->
    <string name="tts_settings">Text-to-speech settings</string>
    <!-- TTS option item name in the main settings screen -->
    <string name="tts_settings_title">Text-to-speech output</string>
  <!-- On main TTS Settings screen, in default settings section, setting default speech rate for synthesized voice -->
    <string name="tts_default_rate_title">Speech rate</string>
    <!-- On main TTS Settings screen, summary for default speech rate for synthesized voice -->
    <string name="tts_default_rate_summary">Speed at which the text is spoken</string>
    <!-- On main TTS Settings screen, in default settings section, setting default pitch for synthesized voice -->
    <string name="tts_default_pitch_title">Pitch</string>
    <!-- On main TTS Settings screen, summary for default pitch for synthesized voice -->
    <string name="tts_default_pitch_summary">Affects the tone of the synthesized speech</string>
    <!-- On main TTS Settings screen, in default settings section, setting default language for synthesized voice -->
    <string name="tts_default_lang_title">Language</string>
    <!-- Entry in the TTS engine language/locale picker, when selected will try to default to the system language [CHAR LIMIT=50] -->
    <string name="tts_lang_use_system">Use system language</string>
    <!-- On main TTS Settings screen, language summary if it can't default to system language [CHAR LIMIT=50] -->
    <string name="tts_lang_not_selected">Language not selected</string>
    <!-- On main TTS Settings screen, summary for default language for synthesized voice -->
    <string name="tts_default_lang_summary">Sets the language-specific voice for the spoken text</string>
    <!-- On main TTS Settings screen, triggers playback of an example of speech synthesis -->
    <string name="tts_play_example_title">Listen to an example</string>
    <!-- On main TTS Settings screen, summary for triggering playback of an example of speech synthesis -->
    <string name="tts_play_example_summary">Play a short demonstration of speech synthesis</string>
    <!-- On main TTS Settings screen, click to install required speech synthesis data -->
    <string name="tts_install_data_title">Install voice data</string>
    <!-- On main TTS Settings screen, summary for click to install required speech synthesis data -->
    <string name="tts_install_data_summary">Install the voice data required for speech synthesis</string>
    <!-- Warning message about security implications of enabling a TTS engine, displayed as a dialog
         message when the user selects to enable an engine. -->
    <string name="tts_engine_security_warning">This speech synthesis engine may be able to collect
        all the text that will be spoken, including personal data like passwords and credit
        card numbers. It comes from the <xliff:g id="tts_plugin_engine_name">%s</xliff:g> engine.
        Enable the use of this speech synthesis engine?</string>
    <!-- Warning message about required internet conectivity for TTS synthesis, displayed as a dialog
         message when the user selects to play an example for network only locale and there's no internet connectivity. -->
    <string name="tts_engine_network_required">This language requires a working network connection for text-to-speech output.</string>
    <!-- Text spoken by the TTS engine as an example if the engine doesn't provide sample text [CHAR LIMIT=100] -->
    <string name="tts_default_sample_string">This is an example of speech synthesis</string>
    <!-- On main TTS Settings screen, title of a field explaining current TTS engine status for
         current default language [CHAR LIMIT=50] -->
    <string name="tts_status_title">Default language status</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         selected language is fully supported by the engine [CHAR LIMIT=150]-->
    <string name="tts_status_ok"><xliff:g id="locale" example="English (United States)">%1$s</xliff:g> is fully supported</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         selected language is supported by the engine only if there's a working network connection [CHAR LIMIT=150] -->
    <string name="tts_status_requires_network"><xliff:g id="locale" example="English (United States)">%1$s</xliff:g> requires network connection</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         selected language is not supported by the engine [CHAR LIMIT=150] -->
    <string name="tts_status_not_supported"><xliff:g id="locale" example="English (United States)">%1$s</xliff:g> is not supported</string>
    <!-- On main TTS Settings screen, current TTS engine status for the current default language,
         tts engine is queried for status [CHAR LIMIT=150] -->
    <string name="tts_status_checking">Checking&#8230;</string>
    <!-- Title for a preference in the main TTS settings screen, which
         launches the settings screen for a given TTS engine when clicked
         [CHAR LIMIT=30]-->
    <string name="tts_engine_settings_title">Settings for <xliff:g id="tts_engine_name">%s</xliff:g></string>
    <!-- [CHAR LIMIT=150] Text for screen readers / accessibility programs for
         the image that launches the TTS engine settings when clicked. -->
    <string name="tts_engine_settings_button">Launch engine settings</string>
    <!-- [CHAR LIMIT=50] The text for the settings section that users to set a
         preferred text to speech engine -->
    <string name="tts_engine_preference_section_title">Preferred engine</string>
    <!-- [CHAR LIMIT=50] Title of the settings section that displays general preferences
         that are applicable to all engines, such as the speech rate -->
    <string name="tts_general_section_title">General</string>
    <!-- On main TTS Settings screen, in default settings section,
         reset speech pitch of synthesized voice to 1x speech pitch. [CHAR LIMIT=50] -->
    <string name="tts_reset_speech_pitch_title">Reset speech pitch</string>
    <!--On main TTS Settings screen, summary for reset speech pitch of synthesized voice [CHAR LIMIT=150] -->
    <string name="tts_reset_speech_pitch_summary">Reset the pitch at which the text is spoken to default.</string>

    <!-- Default speech rate choices -->
    <string-array name="tts_rate_entries">
        <item>Very slow</item>
        <item>Slow</item>
        <item>Normal</item>
        <item>Fast</item>
        <item>Faster</item>
        <item>Very fast</item>
        <item>Rapid</item>
        <item>Very rapid</item>
        <item>Fastest</item>
    </string-array>
    <!-- Do not translate. -->
    <string-array name="tts_rate_values">
        <item>60</item>
        <item>80</item>
        <item>100</item>
        <item>150</item>
        <item>200</item>
        <item>250</item>
        <item>300</item>
        <item>350</item>
        <item>400</item>
    </string-array>

    <!-- Do not translate. -->
    <string-array name="tts_demo_strings" translatable="false">
        <item>This is an example of speech synthesis in English.</item>
        <item>Voici un échantillon de synthèse vocale en français.</item>
        <item>Dies ist ein Beispiel für Sprachsynthese in Deutsch.</item>
        <item>Questo è un esempio di sintesi vocale in italiano.</item>
        <item>Este es un ejemplo de síntesis de voz en español.</item>
        <item>이것은 한국어 음성 합성의 예입니다.</item>
    </string-array>
    <!-- Do not translate. -->
    <string-array name="tts_demo_string_langs" translatable="false">
        <item>eng</item>
        <item>fra</item>
        <item>deu</item>
        <item>ita</item>
        <item>spa</item>
        <item>kor</item>
    </string-array>

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

    <!-- Header for items under the personal user [CHAR LIMIT=30] -->
    <string name="category_personal">Personal</string>
    <!-- Header for items under the work user [CHAR LIMIT=30] -->
    <string name="category_work">Work</string>

    <!-- Full package name of OEM preferred device feedback reporter. Leave this blank, overlaid in Settings/TvSettings [DO NOT TRANSLATE] -->
    <string name="oem_preferred_feedback_reporter" translatable="false" />

    <!-- Development settings -->
    <skip/>
    <!-- Development Settings.  the title for the item to take the user to Development settings.  Development settings are settings meant for application developers.  -->
    <string name="development_settings_title">Developer options</string>
    <!-- Development settings enable title. -->
    <string name="development_settings_enable">Enable developer options</string>
    <!-- Development Settings summary.  The summary of the item to take the user to Development settings.  Development settings are settings meant for application developers. -->
    <string name="development_settings_summary">Set options for app development</string>
    <!-- Setting checkbox title for Whether to enable USB debugging support on the phone. -->
    <!-- Error message for users that aren't allowed to modify developer options [CHAR LIMIT=none] -->
    <string name="development_settings_not_available">Developer options are not available for this user</string>
    <!-- Error message for users that aren't allowed to modify VPN settings [CHAR LIMIT=none] -->
    <string name="vpn_settings_not_available">VPN settings are not available for this user</string>
    <!-- Error message for users that aren't allowed to modify Tethering settings [CHAR LIMIT=none] -->
    <string name="tethering_settings_not_available">Tethering settings are not available for this user</string>
    <!-- Error message for users that aren't allowed to modify Access Point Names settings [CHAR LIMIT=none] -->
    <string name="apn_settings_not_available">Access Point Name settings are not available for this user</string>
    <string name="enable_adb">USB debugging</string>
    <!-- Setting checkbox summary for Whether to enable USB debugging support on the phone -->
    <string name="enable_adb_summary">Debug mode when USB is connected</string>
    <!-- Setting title to revoke secure USB debugging authorizations -->
    <string name="clear_adb_keys">Revoke USB debugging authorizations</string>
    <!-- [CHAR LIMIT=32] Setting title for ADB wireless switch -->
    <string name="enable_adb_wireless">Wireless debugging</string>
    <!-- [CHAR LIMIT=NONE] Setting checkbox summary for whether to enable Wireless debugging support on the phone -->
    <string name="enable_adb_wireless_summary">Debug mode when Wi\u2011Fi is connected</string>
    <!-- [CHAR LIMIT=32] Summary text when ADB wireless has error -->
    <string name="adb_wireless_error">Error</string>
    <!-- [CHAR LIMIT=32] Setting title for ADB wireless fragment -->
    <string name="adb_wireless_settings">Wireless debugging</string>
    <!-- [CHAR LIMIT=NONE] Wireless debugging settings. text displayed when wireless debugging is off and network list is empty. -->
    <string name="adb_wireless_list_empty_off">To see and use available devices, turn on wireless debugging</string>
    <!-- [CHAR LIMIT=50] Title for adb wireless pair by QR code preference -->
    <string name="adb_pair_method_qrcode_title">Pair device with QR code</string>
    <!-- [CHAR LIMIT=NONE] Summary for adb wireless pair by QR code preference -->
    <string name="adb_pair_method_qrcode_summary">Pair new devices using QR code scanner</string>
    <!-- [CHAR LIMIT=50] Title for adb wireless pair by pairing code preference -->
    <string name="adb_pair_method_code_title">Pair device with pairing code</string>
    <!-- [CHAR LIMIT=NONE] Summary for adb wireless pair by pairing code preference -->
    <string name="adb_pair_method_code_summary">Pair new devices using six digit code</string>
    <!-- [CHAR LIMIT=50] Title for adb wireless paired devices category -->
    <string name="adb_paired_devices_title">Paired devices</string>
    <!-- [CHAR LIMIT=50] Summary for adb wireless paired device preference -->
    <string name="adb_wireless_device_connected_summary">Currently connected</string>
    <!-- [CHAR LIMIT=50] Title for the adb device details fragment -->
    <string name="adb_wireless_device_details_title">Device details</string>
    <!-- [CHAR LIMIT=16] Button label to forget an adb device -->
    <string name="adb_device_forget">Forget</string>
    <!-- [CHAR LIMIT=50] Title format for mac address preference in adb device details fragment -->
    <string name="adb_device_fingerprint_title_format">Device fingerprint: <xliff:g id="fingerprint_param" example="a1:b2:c3:d4:e5:f6">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=50] Title for adb wireless connection failed dialog -->
    <string name="adb_wireless_connection_failed_title">Connection unsuccessful</string>
    <!-- [CHAR LIMIT=NONE] Message for adb wireless connection failed dialog -->
    <string name="adb_wireless_connection_failed_message">Make sure <xliff:g id="device_name" example="Bob's Macbook">%1$s</xliff:g> is connected to the correct network</string>
    <!-- [CHAR LIMIT=32] Adb wireless pairing device dialog title -->
    <string name="adb_pairing_device_dialog_title">Pair with device</string>
    <!-- [CHAR LIMIT=32] Adb wireless pairing device dialog pairing code label -->
    <string name="adb_pairing_device_dialog_pairing_code_label">Wi\u2011Fi pairing code</string>
    <!-- [CHAR LIMIT=50] Adb Wireless pairing device failed dialog title -->
    <string name="adb_pairing_device_dialog_failed_title">Pairing unsuccessful</string>
    <!-- [CHAR LIMIT=NONE] Adb wireless pairing device failed dialog message -->
    <string name="adb_pairing_device_dialog_failed_msg">Make sure the device is connected to the same network.</string>
    <!-- [CHAR LIMIT=NONE] Adb wireless qr code scanner description -->
    <string name="adb_wireless_qrcode_summary">Pair device over Wi\u2011Fi by scanning a QR code</string>
    <!-- [CHAR LIMIT=NONE] Adb wireless QR code pairing in progress text -->
    <string name="adb_wireless_verifying_qrcode_text">Pairing device\u2026</string>
    <!-- [CHAR LIMIT=NONE] Adb wireless QR code failed message -->
    <string name="adb_qrcode_pairing_device_failed_msg">Failed to pair the device. Either the QR code was incorrect, or the device is not connected to the same network.</string>
    <!-- [CHAR LIMIT=50] Adb Wireless ip address and port title -->
    <string name="adb_wireless_ip_addr_preference_title">IP address \u0026 Port</string>
    <!-- [CHAR LIMIT=NONE] Adb Wireless QR code pairing scanner title -->
    <string name="adb_wireless_qrcode_pairing_title">Scan QR code</string>
    <!-- [CHAR LIMIT=NONE] Adb Wireless QR code pairing description -->
    <string name="adb_wireless_qrcode_pairing_description">Pair device over Wi\u2011Fi by scanning a QR code</string>
    <!-- [CHAR LIMIT=NONE] Toast message when trying to enable Wi-Fi debugging and no Wi-Fi network connected -->
    <string name="adb_wireless_no_network_msg">Please connect to a Wi\u2011Fi network</string>
    <!--Adb wireless search Keywords [CHAR LIMIT=NONE]-->
    <string name="keywords_adb_wireless">adb, debug, dev</string>
    <!-- [CHAR LIMIT=NONE] Setting checkbox title for Whether to include bug report item in power menu. -->
    <string name="bugreport_in_power">Bug report shortcut</string>
    <!-- [CHAR LIMIT=NONE] Setting checkbox summary for Whether to include bug report item in power -->
    <string name="bugreport_in_power_summary">Show a button in the power menu for taking a bug report</string>
    <!-- Setting Checkbox title whether to keep the screen on when plugged in to a power source -->
    <string name="keep_screen_on">Stay awake</string>
    <!-- setting Checkbox summary whether to keep the screen on when plugged in  -->
    <string name="keep_screen_on_summary">Screen will never sleep while charging</string>
    <!-- Setting Checkbox title whether to enable Bluetooth HCI snoop log -->
    <string name="bt_hci_snoop_log">Enable Bluetooth HCI snoop log</string>
    <!-- setting Checkbox summary whether to capture all Bluetooth HCI packets in a file [CHAR_LIMIT=100] -->
    <string name="bt_hci_snoop_log_summary">Capture Bluetooth packets. (Toggle Bluetooth after changing this setting)</string>
    <!-- setting Checkbox title whether to enable OEM unlock [CHAR_LIMIT=35] -->
    <string name="oem_unlock_enable">OEM unlocking</string>
    <!-- setting Checkbox summary whether to enable OEM unlock [CHAR_LIMIT=50] -->
    <string name="oem_unlock_enable_summary">Allow the bootloader to be unlocked</string>
    <!-- Confirmation dialog title to ensure user wishes to enable OEM unlock and disable theft protection features -->
    <string name="confirm_enable_oem_unlock_title">Allow OEM unlocking?</string>
    <!-- Warning dialog message to confirm user wishes to enable OEM unlock and disable theft protection features -->
    <string name="confirm_enable_oem_unlock_text">WARNING: Device protection features will not work on this device while this setting is turned on.</string>

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

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

    <!-- Setting Checkbox title whether to show options for wireless display certification -->
    <string name="wifi_display_certification">Wireless display certification</string>
    <!-- Setting Checkbox title whether to enable WiFi Verbose Logging. [CHAR LIMIT=40] -->
    <string name="wifi_verbose_logging">Enable Wi\u2011Fi Verbose Logging</string>
    <!-- Setting Checkbox title whether to disable WiFi Scan Throttling. [CHAR LIMIT=40] -->
    <string name="wifi_scan_throttling">Wi\u2011Fi scan throttling</string>
    <!-- Setting Checkbox title whether to enable WiFi enhanced mac randomization. [CHAR LIMIT=40] -->
    <string name="wifi_enhanced_mac_randomization">Wi\u2011Fi\u2011enhanced MAC randomization</string>
    <!-- Setting Checkbox title whether to always keep mobile data active. [CHAR LIMIT=80] -->
    <string name="mobile_data_always_on">Mobile data always active</string>
    <!-- Setting Checkbox title whether to enable hardware acceleration for tethering. [CHAR LIMIT=80] -->
    <string name="tethering_hardware_offload">Tethering hardware acceleration</string>
    <!-- Setting Checkbox title for showing Bluetooth devices without names -->
    <string name="bluetooth_show_devices_without_names">Show Bluetooth devices without names</string>
    <!-- Setting Checkbox title for disabling Bluetooth absolute volume -->
    <string name="bluetooth_disable_absolute_volume">Disable absolute volume</string>
    <!-- Setting Checkbox title for enabling Bluetooth Gabeldorsche. [CHAR LIMIT=40] -->
    <string name="bluetooth_enable_gabeldorsche">Enable Gabeldorsche</string>

    <!-- UI debug setting: Select Bluetooth AVRCP Version -->
    <string name="bluetooth_select_avrcp_version_string">Bluetooth AVRCP Version</string>
    <!-- UI debug setting: Select Bluetooth AVRCP Version -->
    <string name="bluetooth_select_avrcp_version_dialog_title">Select Bluetooth AVRCP Version</string>

    <!-- UI debug setting: Select Bluetooth MAP Version [CHAR LIMIT=NONE] -->
    <string name="bluetooth_select_map_version_string">Bluetooth MAP Version</string>
    <!-- UI debug setting: Select Bluetooth MAP Version [CHAR LIMIT=NONE] -->
    <string name="bluetooth_select_map_version_dialog_title">Select Bluetooth MAP Version</string>

    <!-- UI debug setting: Trigger Bluetooth Audio Codec Selection -->
    <string name="bluetooth_select_a2dp_codec_type">Bluetooth Audio Codec</string>
    <!-- UI debug setting: Trigger Bluetooth Audio Codec Selection -->
    <string name="bluetooth_select_a2dp_codec_type_dialog_title">Trigger Bluetooth Audio Codec\u000ASelection</string>

    <!-- UI debug setting: Trigger Bluetooth Audio Sample Rate Selection -->
    <string name="bluetooth_select_a2dp_codec_sample_rate">Bluetooth Audio Sample Rate</string>
    <!-- UI debug setting: Trigger Bluetooth Audio Codec Selection: Sample Rate -->
    <string name="bluetooth_select_a2dp_codec_sample_rate_dialog_title">Trigger Bluetooth Audio Codec\u000ASelection: Sample Rate</string>
    <!-- UI debug setting: Label for unsupported Bluetooth Audio Codec. [CHAR LIMIT=none] -->
    <string name="bluetooth_select_a2dp_codec_type_help_info">Gray-out means not supported by phone
        or headset</string>

    <!-- UI debug setting: Trigger Bluetooth Audio Bits Per Sample Selection -->
    <string name="bluetooth_select_a2dp_codec_bits_per_sample">Bluetooth Audio Bits Per Sample</string>
    <!-- UI debug setting: Trigger Bluetooth Audio Codec Selection: Bits Per Sample -->
    <string name="bluetooth_select_a2dp_codec_bits_per_sample_dialog_title">Trigger Bluetooth Audio Codec\u000ASelection: Bits Per Sample</string>

    <!-- UI debug setting: Trigger Bluetooth Audio Channel Mode Selection -->
    <string name="bluetooth_select_a2dp_codec_channel_mode">Bluetooth Audio Channel Mode</string>
    <!-- UI debug setting: Trigger Bluetooth Audio Codec Selection: Channel Mode -->
    <string name="bluetooth_select_a2dp_codec_channel_mode_dialog_title">Trigger Bluetooth Audio Codec\u000ASelection: Channel Mode</string>

    <!-- UI debug setting: Trigger Bluetooth Audio LDAC Playback Quality Selection -->
    <string name="bluetooth_select_a2dp_codec_ldac_playback_quality">Bluetooth Audio LDAC Codec: Playback Quality</string>
    <!-- UI debug setting: Select Bluetooth Audio LDAC Codec: LDAC Playback Quality -->
    <string name="bluetooth_select_a2dp_codec_ldac_playback_quality_dialog_title">Trigger Bluetooth Audio LDAC\u000ACodec Selection: Playback Quality</string>

    <!-- [CHAR LIMIT=NONE] Label for displaying Bluetooth Audio Codec Parameters while streaming -->
    <string name="bluetooth_select_a2dp_codec_streaming_label">Streaming: <xliff:g id="streaming_parameter">%1$s</xliff:g></string>

    <!-- Developer option setting for Private DNS -->
    <string name="select_private_dns_configuration_title">Private DNS</string>
    <string name="select_private_dns_configuration_dialog_title">Select Private DNS Mode</string>
    <string name="private_dns_mode_off">Off</string>
    <string name="private_dns_mode_opportunistic">Automatic</string>
    <string name="private_dns_mode_provider">Private DNS provider hostname</string>
    <string name="private_dns_mode_provider_hostname_hint">Enter hostname of DNS provider</string>
    <string name="private_dns_mode_provider_failure">Couldn\'t connect</string>

    <!-- setting Checkbox summary whether to show options for wireless display certification  -->
    <string name="wifi_display_certification_summary">Show options for wireless display certification</string>
    <!-- Setting Checkbox summary whether to enable Wifi verbose Logging [CHAR_LIMIT=NONE] -->
    <string name="wifi_verbose_logging_summary">Increase Wi\u2011Fi logging level, show per SSID RSSI in Wi\u2011Fi Picker</string>
    <!-- Setting Checkbox summary whether to disable Wifi scan throttling [CHAR LIMIT=NONE] -->
    <string name="wifi_scan_throttling_summary">Reduces battery drain &amp; improves network performance</string>
    <!-- Setting Checkbox title whether to enable WiFi enhanced mac randomization. [CHAR LIMIT=NONE] -->
    <string name="wifi_enhanced_mac_randomization_summary">When this mode is enabled, this device\u2019s MAC address may change each time it connects to a network that has MAC randomization enabled.</string>
    <!-- Label indicating network has been manually marked as metered -->
    <string name="wifi_metered_label">Metered</string>
    <!-- Label indicating network has been manually marked as unmetered -->
    <string name="wifi_unmetered_label">Unmetered</string>
    <!-- UI debug setting: limit size of Android logger buffers -->
    <string name="select_logd_size_title">Logger buffer sizes</string>
    <!-- UI debug setting: limit size of Android logger buffers [CHAR LIMIT=59] -->
    <string name="select_logd_size_dialog_title">Select Logger sizes per log buffer</string>
    <!-- UI debug setting: store logs persistently -->
    <string name="dev_logpersist_clear_warning_title">Clear logger persistent storage?</string>
    <!-- Warning text to user about the implications of enabling USB debugging -->
    <string name="dev_logpersist_clear_warning_message">When we no longer are monitoring with the persistent logger, we are required to erase the logger data resident on your device.</string>
    <!-- Title of setting: title for selection of logs to store persistently [CHAR LIMIT=60] -->
    <string name="select_logpersist_title">Store logger data persistently on device</string>
    <!-- UI debug setting: select which logs to store persistently [CHAR LIMIT=80] -->
    <string name="select_logpersist_dialog_title">Select log buffers to store persistently on device</string>
    <!-- UI debug setting: select USB configuration -->
    <string name="select_usb_configuration_title">Select USB Configuration</string>
    <!-- UI debug setting: limit size of Android logger buffers [CHAR LIMIT=59] -->
    <string name="select_usb_configuration_dialog_title">Select USB Configuration</string>
    <!-- Setting Checkbox title whether to allow mock locations -->
    <string name="allow_mock_location">Allow mock locations</string>
    <!-- setting Checkbox summary whether to allow mock locations  -->
    <string name="allow_mock_location_summary">Allow mock locations</string>
    <!-- Setting Checkbox title whether to enable view attribute inspection -->
    <string name="debug_view_attributes">Enable view attribute inspection</string>
    <string name="mobile_data_always_on_summary">Always keep mobile data active, even when Wi\u2011Fi is active (for fast network switching).</string>
    <string name="tethering_hardware_offload_summary">Use tethering hardware acceleration if available</string>
    <!-- Title of warning dialog about the implications of enabling USB debugging -->
    <string name="adb_warning_title">Allow USB debugging?</string>
    <!-- Warning text to user about the implications of enabling USB debugging -->
    <string name="adb_warning_message">USB debugging is intended for development purposes only. Use it to copy data between your computer and your device, install apps on your device without notification, and read log data.</string>
    <!-- Title of warning dialog about the implications of enabling USB debugging [CHAR LIMIT=NONE] -->
    <string name="adbwifi_warning_title">Allow wireless debugging?</string>
    <!-- Warning text to user about the implications of enabling USB debugging [CHAR LIMIT=NONE] -->
    <string name="adbwifi_warning_message">Wireless debugging is intended for development purposes only. Use it to copy data between your computer and your device, install apps on your device without notification, and read log data.</string>
    <!-- Message of dialog confirming that user wants to revoke access to adb from all computers they have authorized -->
    <string name="adb_keys_warning_message">Revoke access to USB debugging from all computers you\u2019ve previously authorized?</string>
    <!-- Title of warning dialog about the implications of enabling developer settings -->
    <string name="dev_settings_warning_title">Allow development settings?</string>
    <!-- Warning text to user about the implications of enabling USB debugging -->
    <string name="dev_settings_warning_message">These settings are intended for development use only.  They can cause your device and the applications on it to break or misbehave.</string>
    <!-- Title of checkbox setting to perform package verification on apps installed over USB/ADT/ADB [CHAR LIMIT=32] -->
    <string name="verify_apps_over_usb_title">Verify apps over USB</string>
    <!-- Summary of checkbox setting to perform package verification on apps installed over USB/ADT/ADB [CHAR LIMIT=NONE] -->
    <string name="verify_apps_over_usb_summary">Check apps installed via ADB/ADT for harmful behavior.</string>
    <!-- Summary of checkbox for showing Bluetooth devices without names -->
    <string name="bluetooth_show_devices_without_names_summary">Bluetooth devices without names (MAC addresses only) will be displayed</string>
    <!-- Summary of checkbox for disabling Bluetooth absolute volume -->
    <string name="bluetooth_disable_absolute_volume_summary">Disables the Bluetooth absolute volume feature in case of volume issues with remote devices such as unacceptably loud volume or lack of control.</string>
    <!-- Summary of checkbox for enabling Bluetooth Gabeldorche features [CHAR LIMIT=none] -->
    <string name="bluetooth_enable_gabeldorsche_summary">Enables the Bluetooth Gabeldorsche feature stack.</string>

    <!-- Summary of checkbox for enabling Enhanced Connectivity features [CHAR LIMIT=NONE] -->
    <string name="enhanced_connectivity_summary">Enables the Enhanced Connectivity feature.</string>

    <!-- Title of checkbox setting that enables the terminal app. [CHAR LIMIT=32] -->
    <string name="enable_terminal_title">Local terminal</string>
    <!-- Summary of checkbox setting that enables the terminal app. [CHAR LIMIT=64] -->
    <string name="enable_terminal_summary">Enable terminal app that offers local shell access</string>

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

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

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

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

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

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

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

    <!-- Preference category for hardware accelerated drawing debugging development settings. [CHAR LIMIT=50] -->
    <string name="debug_hw_drawing_category">Hardware accelerated rendering</string>

    <!-- Preference category for media development settings. [CHAR LIMIT=50] -->
    <string name="media_category">Media</string>

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

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

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

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

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

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

    <!-- UI debug setting: show when hardware layers get updated [CHAR LIMIT=25] -->
    <string name="show_hw_layers_updates">Show hardware layers updates</string>
    <!-- UI debug setting: show hardware layers updates summary [CHAR LIMIT=50] -->
    <string name="show_hw_layers_updates_summary">Flash hardware layers green when they update</string>

    <!-- UI debug setting: show the amount of overdraw in apps using the GPU [CHAR LIMIT=25] -->
    <string name="debug_hw_overdraw">Debug GPU overdraw</string>

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

    <!-- UI debug setting: simulate color space anomalies. [CHAR LIMIT=25] -->
    <string name="simulate_color_space">Simulate color space</string>

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

    <!-- UI debug setting: disable USB audio routing title [CHAR LIMIT=60] -->
    <string name="usb_audio_disable_routing">Disable USB audio routing</string>
    <!-- UI debug setting: disable USB audio routing summary [CHAR_LIMIT=NONE] -->
    <string name="usb_audio_disable_routing_summary">Disable automatic routing to USB audio peripherals</string>

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

    <!-- UI debug setting: force right to left layout [CHAR LIMIT=37] -->
    <string name="force_rtl_layout_all_locales">Force RTL layout direction</string>
    <!-- UI debug setting: force right to left layout summary [CHAR LIMIT=100] -->
    <string name="force_rtl_layout_all_locales_summary">Force screen layout direction to RTL for all locales</string>

    <!-- UI debug setting: force anti-aliasing to render apps [CHAR LIMIT=25] -->
    <string name="force_msaa">Force 4x MSAA</string>
    <!-- UI debug setting: force anti-aliasing summary [CHAR LIMIT=50] -->
    <string name="force_msaa_summary">Enable 4x MSAA in OpenGL ES 2.0 apps</string>

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

    <!-- UI debug setting: profile time taken by hardware acceleration to render apps [CHAR LIMIT=25] -->
    <string name="track_frame_time">Profile HWUI rendering</string>

    <!-- UI debug setting: enable gpu debug layers [CHAR LIMIT=25] -->
    <string name="enable_gpu_debug_layers">Enable GPU debug layers</string>
    <!-- UI debug setting: enable gpu debug layers summary [CHAR LIMIT=50] -->
    <string name="enable_gpu_debug_layers_summary">Allow loading GPU debug layers for debug apps</string>

    <!-- UI debug setting: enable verbose vendor logging [CHAR LIMIT=60] -->
    <string name="enable_verbose_vendor_logging">Enable verbose vendor logging</string>
    <!-- UI debug setting: enable verbose vendor logging summary [CHAR LIMIT=NONE] -->
    <string name="enable_verbose_vendor_logging_summary">Include additional device-specific vendor logs in bug reports, which may contain private information, use more battery, and/or use more storage.</string>

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

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

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

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

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

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

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

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

    <!-- UI debug setting: show missing channel toasts? [CHAR LIMIT=25] -->
    <string name="show_notification_channel_warnings">Show notification channel warnings</string>
    <!-- UI debug setting: show missing channel toasts summary [CHAR LIMIT=50] -->
    <string name="show_notification_channel_warnings_summary">Displays on-screen warning when an app posts a notification without a valid channel</string>

    <!-- UI debug setting: force allow apps on external storage [CHAR LIMIT=50] -->
    <string name="force_allow_on_external">Force allow apps on external</string>
    <!-- UI debug setting: force allow on external summary [CHAR LIMIT=150] -->
    <string name="force_allow_on_external_summary">Makes any app eligible to be written to external storage, regardless of manifest values</string>

    <!-- UI debug setting: force all activites to be resizable for multiwindow [CHAR LIMIT=50] -->
    <string name="force_resizable_activities">Force activities to be resizable</string>
    <!-- UI debug setting: force allow on external summary [CHAR LIMIT=150] -->
    <string name="force_resizable_activities_summary">Make all activities resizable for multi-window, regardless of manifest values.</string>

    <!-- UI debug setting: enable freeform window support [CHAR LIMIT=50] -->
    <string name="enable_freeform_support">Enable freeform windows</string>
    <!-- UI debug setting: enable freeform window support summary [CHAR LIMIT=150] -->
    <string name="enable_freeform_support_summary">Enable support for experimental freeform windows.</string>

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

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

    <!-- [CHAR LIMIT=30] Location mode screen, temporary summary text to show as the status of a location
      setting injected by an external app while the app is being queried for the actual value -->
    <string name="loading_injected_setting_summary">Loading\u2026</string>

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

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

    <!-- Settings item title for apps in standby (limiting background activity) [CHAR LIMIT=35] -->
    <string name="inactive_apps_title">Standby apps</string>
    <!-- Settings item summary for inactive app [CHAR LIMIT=100] -->
    <string name="inactive_app_inactive_summary">Inactive. Tap to toggle.</string>
    <!-- Settings item summary for active app [CHAR LIMIT=100] -->
    <string name="inactive_app_active_summary">Active. Tap to toggle.</string>

    <!-- Settings item summary for standby bucket value of an app. [CHAR LIMIT=100] -->
    <string name="standby_bucket_summary">App standby
        state:<xliff:g id="bucket"> %s</xliff:g></string>

    <!-- Services settings screen, setting option name for the user to go to the screen to view running services -->
    <string name="runningservices_settings_title">Running services</string>
    <!-- Services settings screen, setting option summary for the user to go to the screen to view running services  -->
    <string name="runningservices_settings_summary">View and control currently running services</string>

    <!-- Developer settings: select WebView provider title [CHAR LIMIT=30] -->
    <string name="select_webview_provider_title">WebView implementation</string>
    <!-- Developer settings: select WebView provider dialog title [CHAR LIMIT=30] -->
    <string name="select_webview_provider_dialog_title">Set WebView implementation</string>
    <!-- Developer settings: text for the WebView provider selection toast shown if an invalid provider was chosen (i.e. the setting list was stale). [CHAR LIMIT=NONE] -->
    <string name="select_webview_provider_toast_text">This choice is no longer valid. Try again.</string>

    <!-- Developer settings screen, convert userdata to file encryption option name -->
    <string name="convert_to_file_encryption">Convert to file encryption</string>
    <!-- Developer settings screen, convert userdata to file encryption summary when option is available -->
    <string name="convert_to_file_encryption_enabled">Convert\u2026</string>
    <!-- Developer settings screen, convert userdata to file encryption summary when option is already done -->
    <string name="convert_to_file_encryption_done">Already file encrypted</string>
    <!-- Title used on dialog with final prompt for converting to file encryption -->
    <string name="title_convert_fbe">Converting to file based encryption</string>
    <!-- Warning displayed on dialog with final prompt for converting to file encryption -->
    <string name="convert_to_fbe_warning">
        Convert data partition to file based encryption.\n
        !!Warning!! This will erase all your data.\n
        This feature is alpha, and may not work correctly.\n
        Press \'Wipe and convert\u2026\' to continue.</string>
    <!-- Button on dialog that triggers convertion to file encryption -->
    <string name="button_convert_fbe">Wipe and convert\u2026</string>

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

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

    <!-- Label for disabling color space adjustment [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_disabled">Disabled</string>
    <!-- Label for converting display colors to grayscale, which simulates monochromacy (complete color blindness). [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_monochromacy">Monochromacy</string>
    <!-- Label for deuteranomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_deuteranomaly">Deuteranomaly (red-green)</string>
    <!-- Label for protanomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_protanomaly">Protanomaly (red-green)</string>
    <!-- Label for tritanomaly (blue-yellow color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_tritanomaly">Tritanomaly (blue-yellow)</string>

    <!-- Title for the accessibility preference to configure display color space correction. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_daltonizer_preference_title">Color correction</string>
    <!-- Subtitle for the accessibility preference to configure display color space correction. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_daltonizer_preference_subtitle"><![CDATA[Color correction allows you to adjust how colors are displayed on your device]]></string>
    <!-- Summary shown for color space correction preference when its value is overridden by another preference [CHAR LIMIT=35] -->
    <string name="daltonizer_type_overridden">Overridden by <xliff:g id="title" example="Simulate color space">%1$s</xliff:g></string>

    <!-- [CHAR_LIMIT=NONE] Label for battery on main page of settings -->
    <string name="power_remaining_settings_home_page"><xliff:g id="percentage" example="10%">%1$s</xliff:g> - <xliff:g id="time_string" example="1 hour left based on your usage">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=40] Label for estimated remaining duration of battery discharging -->
    <string name="power_remaining_duration_only">About <xliff:g id="time_remaining">%1$s</xliff:g> left</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when discharging with duration -->
    <string name="power_discharging_duration">About <xliff:g id="time_remaining">%1$s</xliff:g> left (<xliff:g id="level">%2$s</xliff:g>)</string>
    <!-- [CHAR_LIMIT=60] Label for estimated remaining duration of battery discharging -->
    <string name="power_remaining_duration_only_enhanced">About <xliff:g id="time_remaining">%1$s</xliff:g> left based on your usage</string>
    <!-- [CHAR_LIMIT=60] Label for battery level chart when discharging with duration and using enhanced estimate -->
    <string name="power_discharging_duration_enhanced">About <xliff:g id="time_remaining">%1$s</xliff:g> left based on your usage (<xliff:g id="level">%2$s</xliff:g>)</string>
    <!-- [CHAR_LIMIT=20] Short label for estimated remaining duration of battery charging/discharging -->
    <string name="power_remaining_duration_only_short"><xliff:g id="time_remaining">%1$s</xliff:g></string>

    <!-- [CHAR_LIMIT=100] Label for enhanced estimated time that phone will run out of battery -->
    <string name="power_discharge_by_enhanced">Should last until about <xliff:g id="time">%1$s</xliff:g> based on your usage (<xliff:g id="level">%2$s</xliff:g>)</string>
    <!-- [CHAR_LIMIT=100] Label for enhanced estimated time that phone will run out of battery with no percentage -->
    <string name="power_discharge_by_only_enhanced">Should last until about <xliff:g id="time">%1$s</xliff:g> based on your usage</string>
    <!-- [CHAR_LIMIT=100] Label for estimated time that phone will run out of battery -->
    <string name="power_discharge_by">Should last until about <xliff:g id="time">%1$s</xliff:g> (<xliff:g id="level">%2$s</xliff:g>)</string>
    <!-- [CHAR_LIMIT=100] Label for estimated time that phone will run out of battery -->
    <string name="power_discharge_by_only">Should last until about <xliff:g id="time">%1$s</xliff:g></string>
    <!-- [CHAR_LIMIT=20] Label for estimated time that phone will run out of battery -->
    <string name="power_discharge_by_only_short">Until <xliff:g id="time" example="12 PM">%1$s</xliff:g></string>
    <!-- [CHAR_LIMIT=100] Label for estimated time that phone will run out of battery -->
    <string name="power_suggestion_battery_run_out">Battery may run out by <xliff:g id="time" example="12 PM">%1$s</xliff:g></string>

    <!-- [CHAR_LIMIT=60] label for estimated remaining duration of battery when under a certain amount -->
    <string name="power_remaining_less_than_duration_only">Less than <xliff:g id="threshold">%1$s</xliff:g> left</string>
    <!-- [CHAR_LIMIT=60] label for estimated remaining duration of battery when under a certain amount with the percentage -->
    <string name="power_remaining_less_than_duration">Less than <xliff:g id="threshold">%1$s</xliff:g> left (<xliff:g id="level">%2$s</xliff:g>)</string>

    <!-- Used to let users know that they have more than some amount of battery life remaining with percentage. ex: 75% - more than 1 day remaining [CHAR LIMIT = 80] -->
    <string name="power_remaining_more_than_subtext">More than <xliff:g id="time_remaining">%1$s</xliff:g> left (<xliff:g id="level">%2$s</xliff:g>)</string>
    <!-- Used to let users know that they have more than some amount of battery life remaining. ex: more than 1 day remaining [CHAR LIMIT = 40] -->
    <string name="power_remaining_only_more_than_subtext">More than <xliff:g id="time_remaining">%1$s</xliff:g> left</string>

    <!-- [CHAR_LIMIT=50] Short label for imminent shutdown warning of device -->
    <string name="power_remaining_duration_only_shutdown_imminent" product="default">Phone may shut down soon</string>
    <!-- [CHAR_LIMIT=50] Short label for imminent shutdown warning of device -->
    <string name="power_remaining_duration_only_shutdown_imminent" product="tablet">Tablet may shut down soon</string>
    <!-- [CHAR_LIMIT=50] Short label for imminent shutdown warning of device -->
    <string name="power_remaining_duration_only_shutdown_imminent" product="device">Device may shut down soon</string>
    <!-- [CHAR_LIMIT=60] Label for battery level chart when shutdown is imminent-->
    <string name="power_remaining_duration_shutdown_imminent" product="default">Phone may shut down soon (<xliff:g id="level">%1$s</xliff:g>)</string>
    <!-- [CHAR_LIMIT=60] Label for battery level chart when shutdown is imminent-->
    <string name="power_remaining_duration_shutdown_imminent" product="tablet">Tablet may shut down soon (<xliff:g id="level">%1$s</xliff:g>)</string>
    <!-- [CHAR_LIMIT=60] Label for battery level chart when shutdown is imminent-->
    <string name="power_remaining_duration_shutdown_imminent" product="device">Device may shut down soon (<xliff:g id="level">%1$s</xliff:g>)</string>

    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging -->
    <string name="power_charging"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="state">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=40] Label for estimated remaining duration of battery charging -->
    <string name="power_remaining_charging_duration_only"><xliff:g id="time">%1$s</xliff:g> left until charged</string>
    <!-- [CHAR_LIMIT=40] Label for battery level chart when charging with duration -->
    <string name="power_charging_duration"><xliff:g id="level">%1$s</xliff:g> - <xliff:g id="time">%2$s</xliff:g> until charged</string>
    <!-- [CHAR_LIMIT=80] Label for battery level chart when charge been limited -->
    <string name="power_charging_limited"><xliff:g id="level">%1$s</xliff:g> - Optimizing for battery health</string>

    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_unknown">Unknown</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging from an unknown source.  -->
    <string name="battery_info_status_charging">Charging</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging speed is fast.  -->
    <string name="battery_info_status_charging_fast">Charging rapidly</string>
    <!-- [CHAR_LIMIT=20] Battery use screen.  Battery status shown in chart label when charging speed is slow.  -->
    <string name="battery_info_status_charging_slow">Charging slowly</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_discharging">Not charging</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_not_charging">Plugged in, can\'t charge right now</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_full">Full</string>

    <!-- Summary for settings preference disabled by administrator [CHAR LIMIT=50] -->
    <string name="disabled_by_admin_summary_text">Controlled by admin</string>

    <!-- [CHAR LIMIT=25] Manage applications, text telling using an application is disabled. -->
    <string name="disabled">Disabled</string>
    <!-- Summary of app trusted to install apps [CHAR LIMIT=45] -->
    <string name="external_source_trusted">Allowed</string>
    <!-- Summary of app not trusted to install apps [CHAR LIMIT=45] -->
    <string name="external_source_untrusted">Not allowed</string>

    <!-- Title for settings screen for controlling apps that can install other apps on device [CHAR LIMIT=50] -->
    <string name="install_other_apps">Install unknown apps</string>

    <!-- Option in navigation drawer that leads to Settings main screen [CHAR LIMIT=30] -->
    <string name="home">Settings Home</string>

    <!-- Labels on the side of batter graph in Quick Settings and Settings [CHAR LIMIT=8] -->
    <string-array name="battery_labels">
        <item>0%</item>
        <item>50%</item>
        <item>100%</item>
    </string-array>

    <!-- Label for length of time since the battery graph started [CHAR LIMIT=20] -->
    <string name="charge_length_format"><xliff:g name="time" example="3 hours">%1$s</xliff:g> ago</string>

    <!-- Label for length of time until battery is charged [CHAR LIMIT=20] -->
    <string name="remaining_length_format"><xliff:g name="time" example="3 hours">%1$s</xliff:g> left</string>

    <!-- Hint text for the IP address -->
    <string name="wifi_ip_address_hint" translatable="false">192.168.1.128</string>
    <!-- Hint text for DNS -->
    <string name="wifi_dns1_hint" translatable="false">8.8.8.8</string>
    <!-- Hint text for DNS -->
    <string name="wifi_dns2_hint" translatable="false">8.8.4.4</string>
    <!-- Hint text for the gateway -->
    <string name="wifi_gateway_hint" translatable="false">192.168.1.1</string>
    <!-- Hint text for network prefix length -->
    <string name="wifi_network_prefix_length_hint" translatable="false">24</string>
    <!-- HTTP proxy settings. The hint text field for port. -->
    <string name="proxy_port_hint" translatable="false">8080</string>
    <!-- HTTP proxy settings. Hint for Proxy-Auto Config URL. -->
    <string name="proxy_url_hint" translatable="false">https://www.example.com/proxy.pac</string>
    <!-- HTTP proxy settings. The hint text for proxy exclusion list. -->
    <string name="proxy_exclusionlist_hint" translatable="false">example.com,mycomp.test.com,localhost</string>
    <!-- HTTP proxy settings. The hint text field for the hostname. -->
    <string name="proxy_hostname_hint" translatable="false">proxy.example.com</string>

    <!-- Description for the screen zoom level that makes interface elements small. [CHAR LIMIT=24] -->
    <string name="screen_zoom_summary_small">Small</string>
    <!-- Description for the device's default screen zoom level. [CHAR LIMIT=24] -->
    <string name="screen_zoom_summary_default">Default</string>
    <!-- Description for the screen zoom level that makes interface elements large. [CHAR LIMIT=24] -->
    <string name="screen_zoom_summary_large">Large</string>
    <!-- Description for the screen zoom level that makes interface elements larger. [CHAR LIMIT=24] -->
    <string name="screen_zoom_summary_very_large">Larger</string>
    <!-- Description for the screen zoom level that makes interface elements largest. [CHAR LIMIT=24] -->
    <string name="screen_zoom_summary_extremely_large">Largest</string>
    <!-- Description for a custom screen zoom level. This shows the requested display
         density in raw pixels per inch rather than using a relative description. [CHAR LIMIT=24] -->
    <string name="screen_zoom_summary_custom">Custom (<xliff:g id="densityDpi" example="160">%d</xliff:g>)</string>

    <!-- Content description for drawer menu button [CHAR_LIMIT=30]-->
    <string name="content_description_menu_button">Menu</string>

    <!-- Label for carrier demo mode factory reset confirmation dialog. [CHAR LIMIT=NONE] -->
    <string name="retail_demo_reset_message">Enter password to perform factory reset in demo mode</string>
    <!-- Label for positive button on carrier demo  mode factory reset confirmation dialog [CHAR LIMIT=40] -->
    <string name="retail_demo_reset_next">Next</string>
    <!-- Title for carrier demo mode factory reset confirmation dialog. [CHAR LIMIT=40] -->
    <string name="retail_demo_reset_title">Password required</string>

    <!-- Glyph to be overlaid atop the battery when the level is extremely low. Do not translate. -->
    <string name="battery_meter_very_low_overlay_symbol">!</string>

    <!-- Title for settings of active input methods in each IME [CHAR LIMIT=35] -->
    <string name="active_input_method_subtypes">Active input methods</string>
    <!-- Title for settings whether or not the framework will select input methods in an IME based
         on the current system locales. (The user can select multiple system locales)
         [CHAR LIMIT=35] -->
    <string name="use_system_language_to_select_input_method_subtypes">Use system languages</string>

    <!-- Toast that settings for an application is failed to open. -->
    <string name="failed_to_open_app_settings_toast">Failed to open settings for <xliff:g id="spell_application_name">%1$s</xliff:g></string>

    <!-- Warning message about security implications of enabling an input method, displayed as a dialog
         message when the user selects to enable an IME. -->
    <string name="ime_security_warning">This input method may be able to collect
        all the text you type, including personal data like passwords and credit
        card numbers.  It comes from the app
        <xliff:g id="ime_application_name">%1$s</xliff:g>.
        Use this input method?</string>

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

    <!--Label of IMS registration header -->
    <string name="ims_reg_title">"IMS registration state"</string>
    <!--Used when IMS registration state is registered -->
    <string name="ims_reg_status_registered">"Registered"</string>
    <!--Used when IMS registration state is not registered -->
    <string name="ims_reg_status_not_registered">"Not registered"</string>

    <!-- About phone, status item value if the actual value is not available. -->
    <string name="status_unavailable">Unavailable</string>

    <!-- About phone, status value for MAC address when MAC randomization feature is enabled and the device is disconnected. -->
    <string name="wifi_status_mac_randomized">MAC is randomized</string>

    <!-- Summary to show how many devices are connected in wifi hotspot [CHAR LIMIT=NONE] -->
    <plurals name="wifi_tether_connected_summary">
        <item quantity="one">%1$d device connected</item>
        <item quantity="other">%1$d devices connected</item>
    </plurals>

    <!-- Content description of zen mode time condition plus button (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_manual_zen_more_time">More time.</string>
    <!-- Content description of zen mode time condition minus button (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_manual_zen_less_time">Less time.</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>

    <!--  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: 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>
    <!-- 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>
    <!--[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>
    <!-- Warning text when an alarm might be silenced by Do Not Disturb [CHAR LIMIT=NONE] -->
    <string name="zen_alarm_warning_indef">You won\'t hear your next alarm <xliff:g id="when" example="at 7:00 AM">%1$s</xliff:g> unless you turn this off before then</string>
    <!-- Warning text when an alarm might be silenced by Do Not Disturb due to a time-based condition [CHAR LIMIT=NONE] -->
    <string name="zen_alarm_warning">You won\'t hear your next alarm <xliff:g id="when" example="at 7:00 AM">%1$s</xliff:g></string>
    <!-- Alarm template for near alarms [CHAR LIMIT=25] -->
    <string name="alarm_template">at <xliff:g id="when" example="7:00 AM">%1$s</xliff:g></string>
    <!-- Alarm template for far in the future alarms [CHAR LIMIT=25] -->
    <string name="alarm_template_far">on <xliff:g id="when" example="Fri 7:00 AM">%1$s</xliff:g></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">Duration</string>
    <!-- Do not disturb: Duration option to always prompt for the duration of dnd -->
    <string name="zen_mode_duration_always_prompt_title">Ask every time</string>
    <!-- Do not disturb: Duration option to always have DND on until it is manually turned off [CHAR LIMIT=60] -->
    <string name="zen_mode_forever">Until you turn off</string>

    <!-- time label for event have that happened very recently [CHAR LIMIT=60] -->
    <string name="time_unit_just_now">Just now</string>

    <!-- The notice header of Third-party licenses. not translatable -->
    <string name="notice_header" translatable="false"></string>

    <!-- Name of the phone device. [CHAR LIMIT=30] -->
    <string name="media_transfer_this_device_name">Phone speaker</string>

    <!-- Warning message to tell user is have problem during profile connect, it need to turn off device and back on. [CHAR_LIMIT=NONE] -->
    <string name="profile_connect_timeout_subtext">Problem connecting. Turn device off &amp; back on</string>

    <!-- Name of the 3.5mm audio device. [CHAR LIMIT=40] -->
    <string name="media_transfer_wired_device_name">Wired audio device</string>

    <!-- Help button label [CHAR LIMIT=40] -->
    <string name="help_label">Help &amp; feedback</string>

    <!-- Preference category for storage development settings. [CHAR LIMIT=50] -->
    <string name="storage_category">Storage</string>
    <!-- Storage: view and access information about shared blobs [CHAR LIMIT=50] -->
    <string name="shared_data_title">Shared data</string>
    <!-- Storage: shared data summary [CHAR LIMIT=80] -->
    <string name="shared_data_summary">View and modify shared data</string>
    <!-- Shared data: display text when there are no shared data blobs available [CHAR LIMIT=NONE] -->
    <string name="shared_data_no_blobs_text">There is no shared data for this user.</string>
    <!-- Shared data: text to display when there was an error while fetching shared data for the user [CHAR LIMIT=NONE] -->
    <string name="shared_data_query_failure_text">There was an error fetching shared data. Try again.</string>
    <!-- Shared data: shared data id [CHAR LIMIT=50] -->
    <string name="blob_id_text">Shared data ID: <xliff:g id="blob_id" example="100">%d</xliff:g></string>
    <!-- Shared data: label to indicate when the shared data expires [CHAR LIMIT=80] -->
    <string name="blob_expires_text">Expires at <xliff:g id="date" example="Mar 20, 2020 11:59:59 GMT">%s</xliff:g></string>
    <!-- Shared data: text to display when there was an error while deleting a shared data object [CHAR LIMIT=NONE] -->
    <string name="shared_data_delete_failure_text">There was an error deleting the shared data.</string>
    <!-- Shared data: dialog text when there are no acquired leases for a blob [CHAR LIMIT=NONE] -->
    <string name="shared_data_no_accessors_dialog_text">There are no leases acquired for this shared data. Would you like to delete it?</string>
    <!-- Shared data: title for screen showing list of packages accessing some shared data [CHAR LIMIT=50] -->
    <string name="accessor_info_title">Apps sharing data</string>
    <!-- Shared data: text indicating that no description was provided by the app for this shared data [CHAR LIMIT=80] -->
    <string name="accessor_no_description_text">No description provided by the app.</string>
    <!-- Shared data: label to indicate when the lease acquired by an app expires [CHAR LIMIT=80] -->
    <string name="accessor_expires_text">Lease expires at <xliff:g id="date" example="Mar 20, 2020 11:59:59 GMT">%s</xliff:g></string>
    <!-- Shared data: button text for deleting some shared data [CHAR LIMIT=50] -->
    <string name="delete_blob_text">Delete shared data</string>
    <!-- Shared data: confirmation dialog text when attempting delete some shared data [CHAR LIMIT=NONE] -->
    <string name="delete_blob_confirmation_text">Are you sure you want to delete this shared data?</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>
    <!-- Title for add user type dialog [CHAR LIMIT=45] -->
    <string name="user_add_user_type_title">Add</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>
    <!-- Text shown for title of user info setting [CHAR LIMIT=20]-->
    <string name="user_info_settings_title">User info</string>
    <!-- Text shown for title of profile info setting [CHAR LIMIT=20]-->
    <string name="profile_info_settings_title">Profile info</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>
    <!-- Label for switching to other user in the user switcher [CHAR LIMIT=35] -->
    <string name="user_switch_to_user">Switch to <xliff:g id="user_name" example="John Doe">%s</xliff:g></string>

    <!-- Label for adding a new guest in the user switcher [CHAR LIMIT=35] -->
    <string name="guest_new_guest">Add guest</string>
    <!-- Label for exiting and removing the guest session in the user switcher [CHAR LIMIT=35] -->
    <string name="guest_exit_guest">Remove guest</string>
    <!-- Name for the guest user [CHAR LIMIT=35] -->
    <string name="guest_nickname">Guest</string>

    <!-- List entry in developer settings to choose default device/system behavior for the app freezer [CHAR LIMIT=30]-->
    <string name="cached_apps_freezer_device_default">Device default</string>
    <!-- List entry in developer settings to disable the app freezer in developer settings [CHAR LIMIT=30]-->
    <string name="cached_apps_freezer_disabled">Disabled</string>
    <!-- List entry in developer settings to enable the app freezer in developer settings [CHAR LIMIT=30]-->
    <string name="cached_apps_freezer_enabled">Enabled</string>
    <!-- Developer setting dialog prompting the user to reboot after changing the app freezer setting [CHAR LIMIT=NONE]-->
    <string name="cached_apps_freezer_reboot_dialog_text">Your device must be rebooted for this change to apply. Reboot now or cancel.</string>

    <!-- Name of the 3.5mm and usb audio device. [CHAR LIMIT=50] -->
    <string name="media_transfer_wired_usb_device_name">Wired headphone</string>
</resources>
