<?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 WPA3 security -->
    <string name="wifi_security_short_sae" translatable="false">WPA3</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 security -->
    <string name="wifi_security_short_eap_suiteb" translatable="false">Suite-B</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-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 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 security -->
    <string name="wifi_security_eap_suiteb" translatable="false">WPA3-Enterprise</string>

    <!-- Summary for the remembered network. -->
    <string name="wifi_remembered">Saved</string>
    <!-- Status for networks disabled for unknown reason -->
    <string name="wifi_disabled_generic">Disabled</string>
    <!-- Status for networked disabled from a DNS or DHCP failure -->
    <string name="wifi_disabled_network_failure">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">Connected, no internet</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>

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

    <!-- 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: 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: 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=80] -->
    <string name="wifi_verbose_logging_summary">Increase Wi\u2011Fi logging level, show per SSID RSSI in Wi\u2011Fi Picker</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>
    <!-- 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>

    <!-- 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=32] -->
    <string name="usb_audio_disable_routing">Disable USB audio routing</string>
    <!-- UI debug setting: disable USB audio routing summary [CHAR LIMIT=50] -->
    <string name="usb_audio_disable_routing_summary">Disable automatic routing to USB audio peripherals</string>

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

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

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

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

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

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

    <!-- 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 all ANRs? [CHAR LIMIT=25] -->
    <string name="show_notification_channel_warnings">Show notification channel warnings</string>
    <!-- UI debug setting: show all ANRs 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">This feature is experimental and may affect performance.</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=40] 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=100] 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] Extend the battery life past a certain time -->
    <string name="power_suggestion_extend_battery">Extend battery life past <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> remaining</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> remaining (<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> remaining (<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> remaining</string>

    <!-- [CHAR_LIMIT=50] Short label for imminent shutdown warning of device -->
    <string name="power_remaining_duration_only_shutdown_imminent" product="default">Phone may shutdown 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 shutdown 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 shutdown 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 shutdown 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 shutdown 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 shutdown 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 fully 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 fully charged</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 with lower case.  Battery status shown in chart label when charging from an unknown source.  -->
    <string name="battery_info_status_charging_lower">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_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=NONE] -->
    <string name="media_transfer_phone_device_name">Phone speaker</string>
</resources>
