<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2014 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">

    <!-- Main app title [CHAR LIMIT=40] -->
    <string name="settings_app_name">Settings</string>

    <!-- Leanback Launcher App Title for main Settings app [CHAR LIMIT=40] -->
    <string name="launcher_settings_app_name">Settings</string>

    <!-- Leanback Launcher App Title for Network settings app [CHAR LIMIT=40] -->
    <string name="launcher_network_app_name">Network</string>

    <!-- Leanback Launcher App Title for Restricted Profile app [CHAR LIMIT=40] -->
    <string name="launcher_restricted_profile_app_name">Restricted Profile</string>

    <!-- Top level headers -->
    <skip />
    <!-- Header title for device [CHAR LIMIT=50] -->
    <string name="header_category_device">Device</string>
    <!-- Header title for preferences [CHAR LIMIT=50] -->
    <string name="header_category_preferences">Preferences</string>
    <!-- Header title for accessories [CHAR LIMIT=50] -->
    <string name="header_category_accessories">Remote &amp; accessories</string>
    <!-- Header title for personal [CHAR LIMIT=50] -->
    <string name="header_category_personal">Personal</string>

    <!-- Account preferences -->
    <skip />
    <!-- Preference which adds an account [CHAR LIMIT=50] -->
    <string name="add_account">Add account</string>
    <!-- Header for sync [CHAR LIMIT=50] -->
    <string name="account_header_sync">Sync</string>
    <!-- Header for remove account [CHAR LIMIT=50] -->
    <string name="account_header_remove_account">Remove account</string>
    <!-- Google services under account settings, title for Search -->
    <string name="search_title">Search</string>
    <!-- Sync item label: control sync settings [CHAR LIMIT=100] -->
    <string name="account_sync">Choose synced apps</string>
    <!-- Label for action to sync now [CHAR LIMIT=50] -->
    <string name="sync_now">Sync now</string>
    <!-- Label for action saying that we are syncing now [CHAR LIMIT=50] -->
    <string name="sync_cancel">Cancel sync</string>
    <!-- Sync status: in progress [CHAR LIMIT=50]-->
    <string name="sync_in_progress">Syncing\u2026</string>
    <!-- Sync status: last synced [CHAR LIMIT=50]-->
    <string name="last_synced">Last synced <xliff:g id="time">%1s</xliff:g></string>
    <!-- Sync status: disabled [CHAR LIMIT=50] -->
    <string name="sync_disabled">Disabled</string>
    <!-- Sync description if sync is failing [CHAR LIMIT=NONE] -->
    <string name="sync_is_failing">Sync isn\'t working right now. It will be back shortly.</string>
    <!-- Remove account item label: remove the account [CHAR LIMIT=30] -->
    <string name="account_remove">Remove account</string>
    <!-- Message posted if removing the account fails. [CHAR LIMIT=NONE] -->
    <string name="account_remove_failed">Can\'t remove account</string>

    <!-- Account details settings  [CHAR LIMIT=50] -->
    <string-array name="account_detail_settings">
        <item>Name</item>
        <item>Photo</item>
        <item>Security</item>
        <item>Google Wallet</item>
        <item>Purchase History</item>
        <item>Remove Account</item>
    </string-array>

    <!-- Connectivity preferences -->
    <skip />
    <!-- Top level network card title. [CHAR LIMIT=50] -->
    <string name="connectivity_network">Network</string>
    <!-- Preference which manages wifi settings. [CHAR LIMIT=50] -->
    <string name="connectivity_wifi">Wi-Fi</string>
    <!-- Preference which manages ethernet settings. [CHAR LIMIT=50] -->
    <string name="connectivity_ethernet">Ethernet</string>

    <!-- Device preferences -->
    <skip />
    <!-- Preference which changes daydream settings. [CHAR LIMIT=50] -->
    <string name="device_daydream">Daydream</string>
    <!-- Preference which changes display settings. [CHAR LIMIT=50] -->
    <string name="device_display">Display</string>
    <!-- Preference and title which changes system sounds settings. [CHAR LIMIT=50] -->
    <string name="device_sound_effects">System sounds</string>
    <!-- Preference which manages apps. [CHAR LIMIT=50] -->
    <string name="device_apps">Apps</string>
    <!-- Preference which shows storage status. [CHAR LIMIT=50] -->
    <string name="device_storage_reset">Storage &amp; reset</string>
    <!-- Preference which shows storage status. [CHAR LIMIT=50] -->
    <string name="device_storage">Storage</string>
    <!-- Preference which manages backup settings. [CHAR LIMIT=50] -->
    <string name="device_backup_restore">Backup &amp; restore</string>
    <!-- Preference which shows reset options [CHAR LIMIT=50] -->
    <string name="device_reset">Factory data reset</string>
    <!-- Preference which sets the device's display calibration. [CHAR LIMIT=50] -->
    <string name="device_calibration">Calibration</string>

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

    <!-- Browse Header for downloaded apps under device settings. [CHAR LIMIT=50] -->
    <string name="apps_downloaded">Downloaded apps</string>
    <!-- Browse Header for all apps under device settings. [CHAR LIMIT=50] -->
    <string name="apps_system">System apps</string>
    <!-- Browse Header for running apps under device settings. [CHAR LIMIT=50] -->
    <string name="apps_running">Running apps</string>

    <!-- Remote and Accessories -->
    <skip />
    <!-- Preference which manages remote control settings. [CHAR LIMIT=50] -->
    <string name="accessories_remote">Remote</string>
    <!-- Preference which manages camera settings. [CHAR LIMIT=50] -->
    <string name="accessories_camera">Camera</string>
    <!-- Preference which manages pairing new accessories. [CHAR LIMIT=50] -->
    <string name="accessories_add">Add accessory</string>
    <!-- Preference which manages WiFi display settings. [CHAR LIMIT=50] -->
    <string name="accessories_wifi_display">Wi-Fi Display</string>
    <!-- Device Paring Status: Pairing. [CHAR LIMIT=50] -->
    <string name="accessory_state_pairing">Pairing&#8230;</string>
    <!-- Device Paring Status: Connecting. [CHAR LIMIT=50] -->
    <string name="accessory_state_connecting">Connecting&#8230;</string>
    <!-- Device Paring Status: Error. [CHAR LIMIT=50] -->
    <string name="accessory_state_error">Couldn\'t pair</string>
    <!-- Device Paring Status: Canceled. [CHAR LIMIT=50] -->
    <string name="accessory_state_canceled">Canceled</string>
    <!-- Device Paring Status: Pairing Complete. [CHAR LIMIT=50] -->
    <string name="accessory_state_paired">Paired</string>
    <!-- Preference which manages a single Paired Bluetooth accessory. [CHAR LIMIT=50] -->
    <string name="accessory_options">Accessory</string>
    <!-- Preference for renaming a paired Bluetooth accessory[CHAR LIMIT=50] -->
    <string name="accessory_rename">Rename</string>
    <!-- Preference for unpairing a Bluetooth accessory[CHAR LIMIT=50] -->
    <string name="accessory_unpair">Unpair</string>
    <!-- Description shown while we are waiting for a device unpair operation to finish[CHAR LIMIT=50] -->
    <string name="accessory_unpairing">Unpairing device&#8230;</string>
    <!-- Description for Connected accessory[CHAR LIMIT=50] -->
    <string name="accessory_connected">Connected</string>

    <!-- Remote and Accessories -->
    <skip />
    <!-- Description text for new accessories pairing screen. [CHAR LIMIT=150] -->
    <string name="accessories_add_title">Searching for accessories&#8230;</string>
    <!-- Description text for bluetooth device pairing instructions. [CHAR LIMIT=150] -->
    <string name="accessories_add_bluetooth_inst">Before pairing your Bluetooth devices, make sure they\'re in pairing mode</string>
    <!-- Description text for autopairing when the user is in the pairing activity due to pressing the back HW button.  %1 will be replaced with the countdown value. [CHAR LIMIT=150] -->
    <string name="accessories_autopair_msg">A device was found and will automatically pair in <xliff:g id="countdown">%1$s</xliff:g> seconds</string>
    <!-- Description text for pairing screen with multiple devices found. [CHAR LIMIT=150] -->
    <string name="accessories_add_title_multiple">Multiple devices found</string>
    <!-- Description text for selecting a device to pair, when multiple devices are detected. [CHAR LIMIT=150] -->
    <string name="accessories_add_multiple">To choose a different device, press the pairing button on this device</string>
    <!-- Description text for pairing with the selected device, when multiple devices are detected. [CHAR LIMIT=150] -->
    <string name="accessories_add_multiple_select">To pair with the selected device, press &amp; hold this device’s pairing button for 5 seconds</string>
    <!-- Error message displayed to the user indicating that a selected action is not supported on this device. [CHAR LIMIT=150] -->
    <string name="error_action_not_supported">This action isn\'t supported</string>

    <!-- Title for the dialog to enter PIN. [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_request">Bluetooth pairing request</string>
    <!-- Message for confirmation of passkey to complete pairing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_confirm_passkey_msg">To pair with: &lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>, make sure it\'s showing this passkey: &lt;b><xliff:g id="passkey">%2$s</xliff:g>&lt;/b></string>
    <!-- Message when bluetooth incoming pairing request for (2.1 devices) dialog is showing [CHAR LIMIT=NONE] -->
    <string name="bluetooth_incoming_pairing_msg">From: &lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>Pair with this device?</string>
    <!-- Message when bluetooth dialog when passkey or pin needs to be displayed. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_display_passkey_pin_msg">To pair with: &lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>Type on it: &lt;b><xliff:g id="passkey">%2$s</xliff:g>&lt;/b>, then press Return or Enter.</string>
    <!-- Message when bluetooth dialog for pin entry is showing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_pin_msg">To pair with: &lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>, &lt;br>Type the device\'s required PIN:</string>
    <!-- Message when bluetooth dialog for passkey entry is showing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_passkey_msg">To pair with: &lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>, &lt;br>Type the device\'s required passkey:</string>
    <!-- Bluetooth PIN hint text (below the text entry box). [CHAR LIMIT=30] -->
    <string name="bluetooth_pin_values_hint">Usually 0000 or 1234</string>

    <!-- Action title for Confirming the Bluetooth secure Pair action [CHAR LIMIT=50] -->
    <string name="bluetooth_pair">Pair</string>
    <!-- Action title for Cancelling the Bluetooth secure Pair action [CHAR LIMIT=50] -->
    <string name="bluetooth_cancel">Cancel</string>

    <!-- System -->
    <skip />
    <!-- Preference which manages cast settings. [CHAR LIMIT=50] -->
    <string name="system_cast">Google Cast</string>
    <!-- Preference which manages date / time settings. [CHAR LIMIT=50] -->
    <string name="system_date_time">Date &amp; time</string>
    <!-- Preference which manages language settings. [CHAR LIMIT=50] -->
    <string name="system_language">Language</string>
    <!-- Preference which manages input method settings. [CHAR LIMIT=50] -->
    <string name="system_keyboard">Keyboard</string>
    <!-- Preference which manages home screen settings. [CHAR LIMIT=50] -->
    <string name="system_home">Home screen</string>
    <!-- Preference which manages search and google now settings. [CHAR LIMIT=50] -->
    <string name="system_search">Search</string>
    <!-- Preference which manages security settings. [CHAR LIMIT=50] -->
    <string name="system_security">Security &amp; restrictions</string>
    <!-- Preference which manages speech recognition settings. [CHAR LIMIT=50] -->
    <string name="system_speech">Speech</string>
    <!-- Preference which manages TV inputs. [CHAR LIMIT=50] -->
    <string name="system_inputs">Inputs</string>
    <!-- Preference which manages accessibility settings. [CHAR LIMIT=50] -->
    <string name="system_accessibility">Accessibility</string>
    <!-- Preference which manages developer options. [CHAR LIMIT=50] -->
    <string name="system_developer_options">Developer options</string>
    <!-- Label for no accessibility color or opacity [CHAR LIMIT=50] -->
    <string name="accessibility_none">None</string>

    <!-- About -->
    <skip />
    <!-- Preference which shows system update status. [CHAR LIMIT=50] -->
    <string name="about_system_update">System update</string>
    <!-- Preference which shows about screen with legal info, model, etc. [CHAR LIMIT=50] -->
    <string name="about_preference">About</string>
    <!-- Preference which shows name of device as it will appear when being accessed remotely [CHAR LIMIT=50] -->
    <string name="device_name">Device name</string>
    <!-- Button to reboot the device [CHAR LIMIT=40] -->
    <string name="restart_button_label">Restart</string>
    <!-- Preference which shows legal info. [CHAR LIMIT=50] -->
    <string name="about_legal_info">Legal information</string>
    <!-- Preference which shows warranty info. [CHAR LIMIT=50] -->
    <string name="about_warranty">Warranty</string>
    <!-- Preference which shows open source licenses [CHAR LIMIT=50]-->
    <string name="about_legal_license">Open source licenses</string>
    <!-- Preference which shows terms of service and privacy info [CHAR LIMIT=50]-->
    <string name="about_terms_of_service">Google legal</string>
    <!-- Toast message displayed if the license data is unavailable [CHAR LIMIT=100] -->
    <string name="about_license_activity_unavailable">License data is unavailable</string>
    <!-- Preference which shows model. [CHAR LIMIT=50] -->
    <string name="about_model">Model</string>
    <!-- Preference which shows version. [CHAR LIMIT=50] -->
    <string name="about_version">Version</string>
    <!-- Preference which shows serial number. [CHAR LIMIT=50] -->
    <string name="about_serial">Serial number</string>
    <!-- Preference which shows build version. [CHAR LIMIT=50] -->
    <string name="about_build">Build</string>
    <!-- Device Info screen. Countdown for user taps to enable development settings [CHAR LIMIT=NONE] -->
    <plurals name="show_dev_countdown">
        <item quantity="one">You are now <xliff:g id="step_count">%1$d</xliff:g> step away from being a developer</item>
        <item quantity="other">You are now <xliff:g id="step_count">%1$d</xliff:g> steps away from being a developer</item>
    </plurals>
    <!-- Preference which shows ads settings. [CHAR LIMIT=50] -->
    <string name="about_ads">Ads</string>
    <!-- Device Info screen. Confirmation that developer settings are enabled [CHAR LIMIT=NONE] -->
    <string name="show_dev_on">You are now a developer!</string>
    <!-- Device Info screen. Okay we get it, stop pressing, you already have it on [CHAR LIMIT=NONE] -->
    <string name="show_dev_already">No need, you are already a developer</string>

    <!-- Wifi -->
    <skip />
    <!-- Do not translate.  Concise terminology for wifi with WEP security -->
    <string name="wifi_security_short_wep">WEP</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA security -->
    <string name="wifi_security_short_wpa">WPA</string>
    <!-- Do not translate.  Concise terminology for wifi with WPA2 security -->
    <string name="wifi_security_short_wpa2">WPA2</string>
    <!-- Do not translate.  Concise terminology for wifi with both WPA/WPA2 security -->
    <string name="wifi_security_short_wpa_wpa2">WPA/WPA2</string>
    <!-- Do not translate.  Concise terminology for wifi with unknown PSK type -->
    <string name="wifi_security_short_psk_generic">@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">802.1x</string>

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

    <!-- Do not translate.  Terminology for wifi with WEP security -->
    <string name="wifi_security_wep">WEP</string>
    <!-- Do not translate.  Terminology for wifi with WPA security -->
    <string name="wifi_security_wpa">WPA PSK</string>
    <!-- Do not translate.  Terminology for wifi with WPA2 security -->
    <string name="wifi_security_wpa2">WPA2 PSK</string>
    <!-- Do not translate.  Terminology for wifi with both WPA/WPA2 security, or unknown -->
    <string name="wifi_security_wpa_wpa2">WPA/WPA2 PSK</string>
    <!-- Do not translate.  Terminology for wifi with unknown PSK type -->
    <string name="wifi_security_psk_generic">@string/wifi_security_wpa_wpa2</string>
    <!-- Do not translate.  Concise terminology for wifi with 802.1x EAP security -->
    <string name="wifi_security_eap">802.1x EAP</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">Avoided poor Internet connection</string>
    <!--
         Status for networks disabled from authentication failure (wrong password
         or certificate).
    -->
    <string name="wifi_disabled_password_failure">Authentication problem</string>
    <!-- Summary for the remembered network but currently not in range. -->
    <string name="wifi_not_in_range">Not in range</string>
    <!--
         Substring of status line when Wi-Fi Protected Setup (WPS) is available and
         string is listed first [CHAR LIMIT=20]
    -->
    <string name="wifi_wps_available_first_item">WPS available</string>
    <!--
         Substring of wifi status when Wi-Fi Protected Setup (WPS) is available and
         string is listed after a wifi_secured_* string
    -->
    <string name="wifi_wps_available_second_item">\u0020(WPS available)</string>
    <!--
         Substring of wifi status for wifi with authentication.  This version is for when the
         string is first in the list (titlecase in english)
    -->
    <string name="wifi_secured_first_item">Secured with <xliff:g id="wifi_security_short">%1$s</xliff:g></string>
    <!--
         Substring of wifi status for wifi with authentication.  This version is for when the
         string is not first in the list (lowercase in english)
    -->
    <string name="wifi_secured_second_item">, secured with <xliff:g id="wifi_security_short">%1$s</xliff:g></string>

    <!-- wifi signal strength array [CHAR LIMIT=30] -->
    <string-array name="wifi_signal_strength">
        <item>Poor</item>
        <item>Fair</item>
        <item>Good</item>
        <item>Excellent</item>
    </string-array>

    <!-- titles for connection status -->
    <!-- label mac address [CHAR LIMIT=50] -->
    <string name="title_mac_address">MAC address</string>
    <!-- label signal strength [CHAR LIMIT=50] -->
    <string name="title_signal_strength">Signal strength</string>
    <!-- label IP address [CHAR LIMIT=50] -->
    <string name="title_ip_address">IP address</string>
    <!-- label SSID [CHAR LIMIT=50] -->
    <string name="title_ssid">Enter name of Wi-Fi network</string>
    <!-- label internet connection [CHAR LIMIT=50] -->
    <string name="title_internet_connection">Internet connection</string>

    <!-- contents for connection status -->
    <!-- Connected [CHAR LIMIT=50] -->
    <string name="connected">Connected</string>
    <!-- Not connected [CHAR LIMIT=50] -->
    <string name="not_connected">Not connected</string>

    <!-- Wifi setting headers [CHAR LIMIT=50] -->
    <string name="wifi_setting_header_available_networks">Wi-Fi</string>
    <string name="wifi_setting_header_other_options">OTHER OPTIONS</string>
    <string name="wifi_setting_see_all">See all</string>
    <string name="wifi_setting_available_networks">AVAILABLE NETWORKS</string>

    <!-- Other Options under Wifi Settings headers [CHAR LIMIT=50] -->
    <string name="wifi_setting_other_options_wps">Connect via WPS</string>
    <string name="wifi_setting_other_options_add_network">Add new network</string>

    <!-- Strings for Add Network under Connectivity Setting -->
    <!-- Add network title on add network form page [CHAR LIMIT=30] -->
    <string name="add_network">Add network</string>
    <!-- Network SSID title on add network form page [CHAR LIMIT=30] -->
    <string name="network_ssid">Network SSID</string>
    <!-- Security type title on add network form page [CHAR LIMIT=30] -->
    <string name="security_type">Type of security</string>
    <!-- Password title on add network form page [CHAR LIMIT=30] -->
    <string name="password">Password</string>

    <!-- Title for connecting to a WPS network in setup mode [CHAR LIMIT=30] -->
    <string name="wps_network">Connect via WPS</string>
    <!-- Title for adding hidden network in setup mode [CHAR LIMIT=30] -->
    <string name="other_network">Other network&#8230;</string>

    <!-- Skip configuring a Wi-Fi network during device setup [CHAR LIMIT=30]-->
    <string name="skip_network">Skip</string>

    <!-- Wifi Security type indicating no security [CHAR LIMIT=30] -->
    <string name="wifi_security_type_none">None</string>
    <!-- Wifi Security type indicating WEP security [CHAR LIMIT=30] -->
    <string name="wifi_security_type_wep">WEP</string>
    <!-- Wifi Security type indicating WPA/WPA2 security [CHAR LIMIT=30] -->
    <string name="wifi_security_type_wpa">WPA/WPA2 PSK</string>
    <!-- Wifi Security type indicating EAP security [CHAR LIMIT=30] -->
    <string name="wifi_security_type_eap">802.1x EAP</string>
    <!-- Title to show when no wifi networks are available [CHAR LIMIT=80] -->
    <string name="title_wifi_no_networks_available">Scanning&#8230;</string>
    <!-- Title to show when wifi fails to save [CHAR LIMIT=80] -->
    <string name="title_wifi_could_not_save">Couldn\'t save configuration for <xliff:g id="ssid">%1$s</xliff:g></string>
    <!-- Title to show when wifi fails to connect [CHAR LIMIT=80] -->
    <string name="title_wifi_could_not_connect">Couldn\'t connect to <xliff:g id="ssid">%1$s</xliff:g></string>
    <!-- Title to show when wifi fails to connect due to timeout [CHAR LIMIT=80] -->
    <string name="title_wifi_could_not_connect_timeout">Couldn\'t find <xliff:g id="ssid">%1$s</xliff:g></string>
    <!-- Title to show when wifi fails to connect due to authentication failure [CHAR LIMIT=80] -->
    <string name="title_wifi_could_not_connect_authentication_failure">Wi-Fi password not valid</string>
    <!-- Title to show when the wifi ap rejects the connection [CHAR LIMIT=80] -->
    <string name="title_wifi_could_not_connect_ap_reject">Wi-Fi network didn\'t accept connection</string>
    <!-- Title to show when asking if advanced settings should be used for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_advanced_options">Configure <xliff:g id="ssid">%1$s</xliff:g> Proxy and IP Settings?</string>
    <!-- Title to show when asking if a proxy should be used for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_proxy_settings">Proxy settings</string>
    <!-- Title to show when asking for the proxy hostname for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_proxy_hostname">Proxy hostname:</string>
    <!-- Title to show when asking for the proxy port for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_proxy_port">Proxy port:</string>
    <!-- Title to show when asking for which domains bypass the proxy for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_proxy_bypass">Bypass proxy for:</string>
    <!-- Title to show when asking how an ip should be assigned for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_ip_settings">IP settings</string>
    <!-- Title to show when asking for the static ip address to use for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_ip_address">IP address:</string>
    <!-- Title to show when asking for the gateway's ip address for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_gateway">Gateway:</string>
    <!-- Title to show when asking for the network prefix length for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_network_prefix_length">Network prefix length:</string>
    <!-- Title to show when asking for the first DNS to use for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_dns1">DNS 1:</string>
    <!-- Title to show when asking for the second DNS to use for this wifi connection [CHAR LIMIT=80] -->
    <string name="title_wifi_dns2">DNS 2:</string>
    <!-- Title to show when the proxy settings are invalid [CHAR LIMIT=80] -->
    <string name="title_wifi_proxy_settings_invalid">Proxy settings not valid</string>
    <!-- Title to show when the ip settings are invalid [CHAR LIMIT=80] -->
    <string name="title_wifi_ip_settings_invalid">IP settings not valid</string>
    <!-- Title to show when the ip settings are invalid [CHAR LIMIT=80] -->
    <string name="title_wifi_known_network"><xliff:g id="ssid">%1$s</xliff:g> is a saved network</string>
    <!-- Label for action to try to connect to wifi again [CHAR LIMIT=50] -->
    <string name="wifi_action_try_again">Try again</string>
    <!-- Label for action to go back to the list of wifi networks [CHAR LIMIT=50] -->
    <string name="wifi_action_view_available_networks">View available networks</string>
    <!-- Message to show when wifi is connecting [CHAR LIMIT=80] -->
    <string name="wifi_connecting">Connecting to <xliff:g id="ssid">%1$s</xliff:g></string>
    <!-- Message to show when wifi is saving a new configuration [CHAR LIMIT=80] -->
    <string name="wifi_saving">Saving configuration for <xliff:g id="ssid">%1$s</xliff:g></string>
    <!-- Title for action to connect to the wifi network [CHAR LIMIT=80] -->
    <string name="wifi_connect">Connect</string>
    <!-- Title for action to forget the wifi network configuration [CHAR LIMIT=80] -->
    <string name="wifi_forget_network">Forget network</string>
    <!-- Description for action to forget the wifi network configuration [CHAR LIMIT=100] -->
    <string name="wifi_forget_network_description">This clears information used to connect to this network, including a saved password</string>
    <!-- Label for action to accept the currently connected wifi network [CHAR LIMIT=50] -->
    <string name="wifi_action_ok">OK</string>
    <!-- Label for action to try to connect to a different wifi network [CHAR LIMIT=50] -->
    <string name="wifi_action_change_network">Change</string>
    <!-- Label for action to not try to connect to a different wifi network [CHAR LIMIT=50] -->
    <string name="wifi_action_dont_change_network">Don\'t change</string>
    <!-- Label for action to use advanced settings for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_advanced_yes">OK</string>
    <!-- Label for action to not use advanced settings for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_advanced_no">No (recommended)</string>
    <!-- Label for action to not use a proxy for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_proxy_none">None</string>
    <!-- Label for action to setup a proxy for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_proxy_manual">Manual</string>
    <!-- Label for action to use dhcp to obtain an ip address for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_dhcp">DHCP</string>
    <!-- Label for action to save advanced settings [CHAR LIMIT=50] -->
    <string name="wifi_action_save">Save</string>
    <!-- Label for action to setup static ip information for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_static">Static</string>
    <!-- Title for action to show status information for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_status_info">Status info</string>
    <!-- Title for action to setup advanced options for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_advanced_options_title">Advanced options</string>
    <!-- Description for action to setup advanced options for the wifi connection [CHAR LIMIT=50] -->
    <string name="wifi_action_advanced_options_description"><xliff:g id="proxy_settings_summary">%1$s</xliff:g>, <xliff:g id="ip_settings_summary">%2$s</xliff:g></string>
    <!-- Error message if the IP address is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_ip_address">Enter a valid IP address</string>
    <!-- Error message if the gateway is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_gateway">Enter a valid gateway address</string>
    <!-- Error message if the dns is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_dns">Enter a valid DNS address</string>
    <!-- Error message if the network prefix length is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_network_prefix_length">Enter a network prefix length between 0 and 32</string>
    <!-- Hint text for the IP address -->
    <string name="wifi_ip_address_hint">Enter a valid IP address.\nExample: 192.168.1.128</string>
    <!-- Hint text for DNS -->
    <string name="wifi_dns1_hint">Enter a valid IP address or leave empty.\nExample: 8.8.8.8</string>
    <!-- Hint text for DNS -->
    <string name="wifi_dns2_hint">Enter a valid IP address or leave empty.\nExample: 8.8.4.4</string>
    <!-- Hint text for the gateway -->
    <string name="wifi_gateway_hint">Enter a valid IP address or leave empty.\nExample: 192.168.1.1</string>
    <!-- Hint text for network prefix length -->
    <string name="wifi_network_prefix_length_hint">Enter a valid network prefix length.\nExample: 24</string>
    <!-- HTTP proxy settings. The error if the hostname is not valid -->
    <string name="proxy_error_invalid_host">Hostname isn\'t valid</string>
    <!-- HTTP proxy settings. The error if the exclusion list is not valid -->
    <string name="proxy_error_invalid_exclusion_list">This exclusion list isn\’t valid. Enter a comma-separated list of excluded domains.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_port">Port field can\'t be empty</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_host_set_port">If the host field is empty, leave the port field empty</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_invalid_port">Port isn\'t valid</string>
    <!-- HTTP proxy settings. Warning message about limited application support [CHAR LIMIT=100]-->
    <string name="proxy_warning_limited_support">HTTP proxy is used by the browser but may not be used by other apps</string>
    <!-- HTTP proxy settings. The hint text field for port. -->
    <string name="proxy_port_hint">Enter a valid port.\nExample: 8080</string>
    <!-- HTTP proxy settings. The hint text for proxy exclusion list.-->
    <string name="proxy_exclusionlist_hint">Enter a comma-separated list of excluded domains or leave blank.\nExample: example.com,mycomp.test.com,localhost</string>
    <!-- HTTP proxy settings. The hint text field for the hostname. -->
    <string name="proxy_hostname_hint">Enter a valid hostname.\nExample: proxy.example.com</string>

    <!-- Title to show indicating the user is connected [CHAR LIMIT=100] -->
    <string name="wifi_summary_title_connected">Network connected</string>
    <!-- Title to show indicating the user is not connected [CHAR LIMIT=100] -->
    <string name="wifi_summary_title_not_connected">Network isn\'t connected</string>
    <!-- Title to show when wifi is already connected [CHAR LIMIT=100] -->
    <string name="wifi_summary_description_connected_to_wifi_network">Already connected to <xliff:g id="ssid">%1$s</xliff:g>. Connect to a different network?</string>
    <!-- Name to use when we don't know the name of the wifi network the device is connected to [CHAR LIMIT=20] -->
    <string name="wifi_summary_unknown_network">an unknown network</string>

    <!-- Title for action to configure advanced options for a wifi or ethernet connection [CHAR LIMIT=80] -->
    <string name="connectivity_advanced_options">Advanced options</string>
    <!-- Description for action to configure advanced options for a wifi or ethernet connection showing a summary of advanced options[CHAR LIMIT=80] -->
    <string name="connectivity_advanced_options_description"><xliff:g id="ssid">%1$s</xliff:g>, <xliff:g id="ssid">%2$s</xliff:g></string>

    <!-- Strings for Ethernet under Connectivity Setting -->
    <!-- Key for ip settings [CHAR LIMIT=30] -->
    <string name="title_ip_settings">IP settings</string>
    <!-- Title for Test Connection [CHAR LIMIT=50] -->
    <string name="title_test_connection">Test connection</string>
    <!-- DHCP in IP setting [CHAR LIMIT=50] -->
    <string name="dhcp">DHCP</string>
    <!-- Static in IP setting [CHAR LIMIT=50] -->
    <string name="title_static">Static</string>
    <!-- Gateway title in network setting [CHAR LIMIT=50] -->
    <string name="gateway">Gateway</string>
    <!-- Title for network prefix length in network setting [CHAR LIMIT=50] -->
    <string name="title_network_prefix_length">Network prefix length</string>
    <!-- Title for DNS 1 [CHAR LIMIT=50] -->
    <string name="title_dns_1">DNS 1</string>
    <!-- Title for DNS 2 [CHAR LIMIT=50] -->
    <string name="title_dns_2">DNS 2</string>
    <!-- Title for OK [CHAR LIMIT=50] -->
    <string name="title_ok">OK</string>
    <!-- Title for DNS 2 [CHAR LIMIT=50] -->
    <string name="title_cancel">Cancel</string>
    <!-- Title of renaming wifi direct device [CHAR LIMIT=50] -->
    <string name="rename_device">Rename device</string>

    <!-- Storage settings screen heading. This is displayed above items that pertain to the phone's internal storage [CHAR LIMIT=50] -->
    <string name="storage_title">Storage</string>
    <!-- Storage settings title. The amount of free space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section. [CHAR LIMIT=50] -->
    <string name="storage_available">Available</string>
    <!-- Storage settings screen heading.  The total amount of storage space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section [CHAR LIMIT=50] -->
    <string name="storage_size">Total space: <xliff:g id="total_space">%1$s</xliff:g></string>
    <!-- Storage settings summary. Displayed when the total memory usage is being calculated. Will be replaced with a number like "12.3 GB" when finished calucating. [CHAR LIMIT=30] -->
    <string name="storage_calculating_size">Calculating\u2026</string>
    <!-- Storage settings title. Displayed as a title when showing the total usage of applications installed. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="storage_apps_usage">Apps</string>
    <!-- Storage settings title. Displayed as a title when showing the total usage of /sdcard/Download on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="storage_downloads_usage">Downloads</string>
    <!-- Storage settings title. Displayed as a title when showing the total usage of all pictures, videos in /sdcard/DCIM, /sdcard/Pictures folders on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="storage_dcim_usage">Photos &amp; videos</string>
    <!-- Storage settings title. Displayed as a title when showing the total usage of audio files in /sdcard on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="storage_music_usage">Audio</string>
    <!-- Storage settings title. Displayed as a title when showing the total usage of misc files on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="storage_media_misc_usage">Misc.</string>
    <!-- Storage settings title. Displayed as a title when showing the total usage of all cached data on device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="storage_media_cache_usage">Cached data</string>

    <!-- Action to cancel WPS scanning [CHAR LIMIT=50] -->
    <string name="wifi_wps_cancel_scan">Cancel</string>
    <!-- Action to retry WPS scanning [CHAR LIMIT=50] -->
    <string name="wifi_wps_retry_scan">Retry</string>
    <!-- Message indicating we are scanning for WPS routers [CHAR LIMIT=150] -->
    <string name="wifi_wps_title">Searching for WPS router\u2026</string>
    <!-- Message describing how to turn on WPS on a router [CHAR LIMIT=150] -->
    <string name="wifi_wps_instructions">Press the Wi-Fi Protected Setup button on your router.\nIt may be called \"WPS\" or contain the symbol to the left.</string>
    <!-- Title Message in WPS dialog for PIN after start up [CHAR LIMIT=150] -->
    <string name="wifi_wps_onstart_pin">Enter PIN <xliff:g id="number">%1$s</xliff:g> on your Wi-Fi router</string>
    <!-- Description Message in WPS dialog for PIN after start up [CHAR LIMIT=150] -->
    <string name="wifi_wps_onstart_pin_description">After you enter the PIN, setup can take up to 2 minutes to finish</string>
    <!-- Text displayed when WPS setup is in progress [CHAR LIMIT=150] -->
    <string name="wifi_wps_in_progress">WPS is already in progress and can take up to 2 minutes to finish</string>
    <!-- Text displayed when WPS fails to start [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_generic">Couldn\'t find Wi-Fi router</string>
    <!-- Text displayed when WPS fails due to WEP [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_wep">Wi-Fi router security setting (WEP) isn\'t supported</string>
    <!-- Text displayed when WPS fails to TKIP [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_tkip">Wi-Fi router security setting (TKIP) isn\'t supported</string>
    <!-- Text displayed when WPS fails due to another session [CHAR LIMIT=150] -->
    <string name="wifi_wps_failed_overlap">Another WPS session is in progress. Try again in a few minutes.</string>

    <!-- Title for Date in System Settings Date Time [CHAR LIMIT=50] -->
    <string name="system_date">Date</string>
    <!-- Title for Time in System Settings Date Time [CHAR LIMIT=50] -->
    <string name="system_time">Time</string>
    <!-- Title for Set Date in System Settings Date Time [CHAR LIMIT=50] -->
    <string name="system_set_date">Set date</string>
    <!-- Title for Set Time in System Settings Date Time [CHAR LIMIT=50] -->
    <string name="system_set_time">Set time</string>
    <!-- Title for Set Time Zone in System Settings Date Time [CHAR LIMIT=50] -->
    <string name="system_set_time_zone">Set time zone</string>
    <!-- Title for Set time format in System Settings Date Time [CHAR LIMIT=50] -->
    <string name="system_set_time_format">Use 24-hour format</string>
    <!-- Title for automatic date & time [CHAR LIMIT = 80] -->
    <string name="system_auto_date_time">Automatic date &amp; time</string>
    <!-- Description for using automatic date & time in date time settings [CHAR LIMIT=100] -->
    <string name="desc_auto_date_time">Use network-provided time</string>
    <!-- Title for Location in System Settings [CHAR LIMIT=50] -->
    <string name="system_location">Location</string>
    <!-- Description for Location in System Settings [CHAR LIMIT=NONE] -->
    <string name="system_desc_location">Let apps that have asked your permission use your location information</string>
    <!-- Title for the Google location source in System Settings [CHAR LIMIT=50]-->
    <string name="system_network_location">Wi-Fi network location</string>
    <!-- Description for the Google location source in System Settings [CHAR LIMIT=150]-->
    <string name="system_desc_network_location">Let Google help apps determine location. This means sending anonymous location data to Google, even when no apps are running.</string>
    <!-- Title for confirming location consent [CHAR LIMIT=50] -->
    <string name="system_network_location_confirm">Location consent</string>
    <!-- Description for confirming location consent [CHAR LIMIT=NONE] -->
    <string name="system_desc_network_location_confirm">Allow Google\'s location service to collect anonymous location data. Some data may be stored on your device. Collection may occur even when no apps are running.</string>
    <!-- Security & location settings screen, section header for settings relating to location -->
    <string name="location_title">My location</string>
    <!-- Header title for SecurityActivity [CHAR LIMIT=50] -->
    <string name="header_category_system">System</string>
    <!-- [CHAR LIMIT=30] Location settings screen, setting preference screen box label for location mode -->
    <string name="location_mode_title">Mode</string>
    <!-- [CHAR LIMIT=30] Location settings screen, sub category for recent location requests -->
    <string name="location_category_recent_location_requests">Recent location requests</string>
    <!-- Location settings screen, displayed when there's no recent app accessing location -->
    <string name="location_no_recent_apps">No apps have requested location recently</string>
    <!-- [CHAR LIMIT=30] Location settings screen, recent location requests high battery use-->
    <string name="location_high_battery_use">High battery use</string>
    <!-- [CHAR LIMIT=30] Location settings screen, recent location requests low battery use-->
    <string name="location_low_battery_use">Low battery use</string>
    <!-- [CHAR LIMIT=130] Location mode screen, description for wifi mode -->
    <string name="location_mode_wifi_description">Use Wi\u2011Fi to estimate location </string>

    <!-- [CHAR LIMIT=60] Label for the status of location -->
    <string name="location_status">Location status</string>
    <!-- [CHAR LIMIT=60] Title for location services in locations settings -->
    <string name="location_services">Location services</string>
    <!-- [CHAR LIMIT=20] Title for status on for location services -->
    <string name="on">On</string>
    <!-- [CHAR LIMIT=20] Title for status off for location services -->
    <string name="off">Off</string>
    <!-- [CAR LIMIT=100] Location services screen title for Google location services -->
    <string name="google_location_services_title">Google location services</string>
    <!-- [CAR LIMIT=100] Location services screen title for third party location services -->
    <string name="third_party_location_services_title">3rd party location services</string>
    <!-- [CHAR LIMIT=100] Location services screen, title for Location reporting -->
    <string name="location_reporting">Location Reporting</string>
    <!-- [CHAR LIMIT=100] Location services screen, title for Location history -->
    <string name="location_history">Location History</string>
    <!-- [CHAR LIMIT=300] Location reporting screen, description -->
    <string name="location_reporting_desc">Google uses this feature in products like Google Now and Google Maps. Turning on Location Reporting lets any Google product that uses this feature store and use your device\'s most recent location data in connection with your Google Account.</string>
    <!-- [CHAR LIMIT=500] Location history screen, description -->
    <string name="location_history_desc">When Location History is turned on for this account, Google can store your device\'s location data for use by your apps.\n\nFor example, Google Maps can give you directions, and Google Now can inform you about commute traffic.\n\nYou can turn off Location History at any time, but doing so doesn\'t delete it. To view and manage your Location History, visit maps.google.com/locationhistory.</string>
    <!-- [CHAR LIMIT=100] Location history screen, title for delete location history -->
    <string name="delete_location_history_title">Delete location history</string>
    <!-- [CHAR LIMIT=300] Location history screen, description for delete location history -->
    <string name="delete_location_history_desc">This will delete all Location History has stored from this device for this Google Account. You can\'t undo this deletion. Some apps, including Google Now, will stop working.</string>
    <!-- Title for services in accessibility settings [CHAR LIMIT=50] -->
    <string name="system_services">Services</string>
    <!-- Title and description for accessibility service setting [CHAR LIMIT=50] -->
    <string name="accessibility_service_settings">Service settings</string>

    <!-- Title and description for accessibility captions setting [CHAR LIMIT=50] -->
    <string name="accessibility_captions">Captions</string>
    <!-- Title and description for accessibility captions description [CHAR LIMIT=NONE] -->
    <string name="accessibility_captions_description">Settings for closed captioning text overlay on video</string>
    <!-- Title for captions display setting [CHAR LIMIT=50] -->
    <string name="captions_display">Display</string>
    <!-- Subtext used under the captions_display string to denote that captions will be shown. [CHAR LIMIT=50] -->
    <string name="captions_display_on">On</string>
    <!-- Subtext used under the captions_display string to denote that captions will NOT be shown. [CHAR LIMIT=50] -->
    <string name="captions_display_off">Off</string>
    <!-- Description for captions display setting [CHAR LIMIT=100] -->
    <string name="display_options">Display options</string>
    <!-- Title for captions configure setting [CHAR LIMIT=50] -->
    <string name="captions_configure">Configure</string>
    <!-- Title for captions language setting [CHAR LIMIT=50] -->
    <string name="captions_lanaguage">Language</string>
    <!-- Title for captions text size setting [CHAR LIMIT=50] -->
    <string name="captions_textsize">Text size</string>
    <!-- Title for captions style setting [CHAR LIMIT=50] -->
    <string name="captions_captionstyle">Caption style</string>
    <!-- Title for custom captions settings [CHAR LIMIT=50] -->
    <string name="captions_customoptions">Custom options</string>
    <!-- Title for captions font family setting [CHAR LIMIT=50] -->
    <string name="captions_fontfamily">Font family</string>
    <!-- Title for captions text color setting [CHAR LIMIT=50] -->
    <string name="captions_textcolor">Text color</string>
    <!-- Title for captions edge type setting [CHAR LIMIT=50] -->
    <string name="captions_edgetype">Edge type</string>
    <!-- Title for captions edge color setting [CHAR LIMIT=50] -->
    <string name="captions_edgecolor">Edge color</string>
    <!-- Title for captions background color setting [CHAR LIMIT=50] -->
    <string name="captions_backgroundcolor">Background color</string>
    <!-- Title for captions bacground opacity setting [CHAR LIMIT=50] -->
    <string name="captions_backgroundopacity">Background opacity</string>
    <!-- Sample text for previewing video caption preferences. [CHAR LIMIT=NONE] -->
    <string name="captioning_preview_text">Captions will look like this</string>
    <!-- Title for captions text opacity setting [CHAR LIMIT=50] -->
    <string name="captions_textopacity">Text opacity</string>
    <!-- Title for captions window color setting [CHAR LIMIT=50] -->
    <string name="captions_windowcolor">Window color</string>
    <!-- Title for captions window opacity setting [CHAR LIMIT=50] -->
    <string name="captions_windowopacity">Window opacity</string>

    <!-- Label for no color. [CHAR LIMIT=35] -->
    <string name="color_none">None</string>
    <!-- Label for the color white. [CHAR LIMIT=35] -->
    <string name="color_white">White</string>
    <!-- Label for the color gray. [CHAR LIMIT=35] -->
    <string name="color_gray">Gray</string>
    <!-- Label for the color black. [CHAR LIMIT=35] -->
    <string name="color_black">Black</string>
    <!-- Label for the color red. [CHAR LIMIT=35] -->
    <string name="color_red">Red</string>
    <!-- Label for the color green. [CHAR LIMIT=35] -->
    <string name="color_green">Green</string>
    <!-- Label for the color blue. [CHAR LIMIT=35] -->
    <string name="color_blue">Blue</string>
    <!-- Label for the color cyan. [CHAR LIMIT=35] -->
    <string name="color_cyan">Cyan</string>
    <!-- Label for the color yellow. [CHAR LIMIT=35] -->
    <string name="color_yellow">Yellow</string>
    <!-- Label for the color magenta. [CHAR LIMIT=35] -->
    <string name="color_magenta">Magenta</string>
    <!-- Label for custom colors, formats as a HTML color. -->
    <string name="color_custom" translatable="false">#%1$02X%2$02X%3$02X</string>

    <!-- Title for accessibility service status [CHAR LIMIT=50] -->
    <string name="system_accessibility_status">State</string>
    <!-- Title for accessibility service configuration [CHAR LIMIT=50] -->
    <string name="system_accessibility_config">Configuration</string>
    <!-- Title for confirmation screen when turning ON accessibility service[CHAR LIMIT=50] -->
    <string name="system_accessibility_service_on_confirm_title">Use <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Description for confirmation screen when turning ON accessibility service[[CHAR LIMIT=NONE] -->
    <string name="system_accessibility_service_on_confirm_desc"><xliff:g id="service" example="TalkBack">%1$s</xliff:g> can collect all of the text you type, except passwords. This includes personal data such as credit card numbers.</string>
    <!-- Title for confirmation screen when turning OFF accessibility service[CHAR LIMIT=50] -->
    <string name="system_accessibility_service_off_confirm_title">Stop <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Description for confirmation screen when turning OFF accessibility service[[CHAR LIMIT=NONE] -->
    <string name="system_accessibility_service_off_confirm_desc">Selecting OK will stop <xliff:g id="service" example="TalkBack">%1$s</xliff:g>.</string>
    <!-- Title for text to speech output in accessibility settings [CHAR LIMIT=50] -->
    <string name="system_accessibility_tts_output">Text to speech</string>
    <!-- Title for Set Speak passwords in System Settings Accessibility [CHAR LIMIT=50] -->
    <string name="system_speak_passwords">Speak passwords</string>
    <!-- Title for Set Preferred engine in System Settings Accessibility [CHAR LIMIT=50] -->
    <string name="system_preferred_engine">Preferred engine</string>
    <!-- Title for Set Speech rate in System Settings Accessibility [CHAR LIMIT=50] -->
    <string name="system_speech_rate">Speech rate</string>
    <!-- Title for Set Play sample in System Settings Accessibility [CHAR LIMIT=50] -->
    <string name="system_play_sample">Play sample</string>
    <!-- Title for Set Install voice data in System Settings Accessibility [CHAR LIMIT=50] -->
    <string name="system_install_voice_data">Install voice data</string>
    <!-- Title for Set General in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_general">General</string>
    <!-- Title for Set Debugging in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_debugging">Debugging</string>
    <!-- Title for Set Input in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_input">Input</string>
    <!-- Title for Set Drawing in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_drawing">Drawing</string>
    <!-- Title for Set Monitoring in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_monitoring">Monitoring</string>
    <!-- Title for Set Apps in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_apps">Apps</string>
    <!-- Title for Set Take bug report in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_take_bug_report">Take bug report</string>
    <!-- Title for Set Backup password in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_backup_password">Backup password</string>
    <!-- Title for Set Stay awake in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_stay_awake">Stay awake</string>
    <!-- Title for Set HDCP checking in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_hdcp_checking">HDCP checking</string>
    <!-- Title for HDMI optimization in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_hdmi_optimization">HDMI optimization</string>
    <!-- Title for reboot confirmation in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_reboot_confirm">Restart now?</string>
    <!-- Description for reboot confirmation in System Settings Developer options [CHAR LIMIT=150] -->
    <string name="system_desc_reboot_confirm">To update this setting, your device needs to be restarted</string>
    <!-- Title for HDCP checking option in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_never_check">Never check</string>
    <!-- Title for HDCP checking option in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_check_for_drm_content_only">Check for DRM content only</string>
    <!-- Title for HDCP checking option in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_always_check">Always check</string>
    <!-- Title for Bluetooth HCI logging Developer option [CHAR LIMIT=50] -->
    <string name="system_bt_hci_log">Bluetooth HCI logging</string>
    <!-- Title for Set Email address in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_email_address">Email address</string>
    <!-- Title for Set USB debugging in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_usb_debugging">USB debugging</string>
    <!-- Title for Set Allow mock locations in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_allow_mock_locations">Allow mock locations</string>
    <!-- Title for Set Select debug app in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_select_debug_app">Select debug app</string>
    <!-- Title for Set Wait for debugger in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_wait_for_debugger">Wait for debugger</string>
    <!-- Title for Set Verify apps over USB in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_verify_apps_over_usb">Verify apps over USB</string>
    <!-- Description for Set verify apps over USB in system settings develop opetions [CHAR LIMIT=150] -->
    <string name="system_desc_verify_apps_over_usb">Check apps installed via ADB/ADT for harmful behavior</string>
    <!-- Title for WiFi Verbose Logging in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_wifi_verbose_logging">Wi-Fi verbose logging</string>
    <!-- Description for Wifi Verbose Logging in system settings develop opetions [CHAR LIMIT=150] -->
    <string name="system_desc_wifi_verbose_logging">Enable Wi-Fi verbose logging</string>
    <!-- Title for Set Show touches in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_touches">Show touches</string>
    <!-- Title for Set Pointer location in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_pointer_location">Pointer location</string>
    <!-- Title for Set Show layout bounds in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_layout_bounds">Show layout bounds</string>
    <!-- Title for Set Show GPU view updates in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_gpu_view_updates">Show GPU view updates</string>
    <!-- Title for Set Show hardware layer in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_hardware_layer">Show hardware layer</string>
    <!-- Title for Set Show GPU overdraw in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_gpu_overdraw">Show GPU overdraw</string>
    <!-- Title for Set Show surface updates in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_surface_updates">Show surface updates</string>
    <!-- Title for Set Window animation scale in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_window_animation_scale">Window animation scale</string>
    <!-- Title for Set Transition animation scale in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_transition_animation_scale">Transition animation scale</string>
    <!-- Title for Set Animator duration scale in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_animator_duration_scale">Animator duration scale</string>
    <!-- Title for Set Strict mode enabled in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_strict_mode_enabled">Strict mode enabled</string>
    <!-- Title for Set Show CPU usage in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_cpu_usage">Show CPU usage</string>
    <!-- Title for Set Profile GPU rendering in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_profile_gpu_rendering">Profile GPU rendering</string>
    <!-- Title for Set Enable traces in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_enable_traces">Enable traces</string>
    <!-- Title for Set Don't keep activities in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_dont_keep_activities">Don\'t keep activities</string>
    <!-- Title for Set Background process limit in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_background_process_limit">Background process limit</string>
    <!-- Title for Set Show all ANRs in System Settings Developer options [CHAR LIMIT=50] -->
    <string name="system_show_all_anrs">Show all ANRs</string>

    <!-- Description for Take bug report in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_take_bug_report">Send report to email address</string>
    <!-- Description for backup password in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_backup_password">Protect desktop full backups</string>
    <!-- Description for stay awake System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_stay_awake">Disable sleep</string>
    <!-- Description for hdcp checking System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_hdcp_checking">Use for DRM content only</string>
    <!-- Description for HDMI optimization System Settings Developer options [CHAR LIMIT=200] -->
    <string name="system_desc_hdmi_optimization">Optimize display for maximum resolution or maximum framerate. This only affects Ultra HD displays. Changing this setting will restart your device.</string>
    <!-- Description for Bluetooth HCI Logging Developer option [CHAR LIMIT=100] -->
    <string name="system_desc_bt_hci_log">Enable Bluetooth HCI snoop logging</string>
    <!-- Description for usb debugging in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_usb_debugging">Debug mode when USB connected</string>
    <!-- Description for wait for debugger in System Settings Developer options [CHAR LIMIT=120] -->
    <string name="system_desc_wait_for_debugger">Debugged application waits for debugger to attach before executing</string>
    <!-- Description for show layout bounds in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_show_layout_bounds">Show clip bounds, margins, etc.</string>
    <!-- Description for show GPU view updates in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_show_gpu_view_updates">Flash views inside windows when drawn with the GPU</string>
    <!-- Description for show hardware layer in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_show_hardware_layer">Flash hardware layers green when they update</string>
    <!-- Description for show gpu overdraw in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_show_gpu_overdraw">From best to worst: blue, green, light red, red</string>
    <!-- Description for show surface updates in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_show_surface_updates">Flash entire window surfaces when they update</string>
    <!-- Description for strict mode enabled in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_strict_mode_enabled">Flash screen when apps do long operations on main thread</string>
    <!-- Description for show cpu usage in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_show_cpu_usage">Screen overlay showing current CPU usage</string>
    <!-- Description for profile GPU rendering in System Settings Developer options [CHAR LIMIT=100] -->
    <string name="system_desc_profile_gpu_rendering">Measure rendering time in adb shell dumpsys gfxinfo</string>

    <!-- The option in the date-format picker for using the normal format
         called for by the user's locale. -->
    <string name="normal_date_format">Regional (<xliff:g id="date" example="12-31-2009">%s</xliff:g>)</string>

    <!-- General use strings -->
    <skip />
    <!-- Title for an action which turns a feature on [CHAR LIMIT=30] -->
    <string name="action_on_title">On</string>
    <!-- Title for an action which turns a feature off [CHAR LIMIT=30] -->
    <string name="action_off_title">Off</string>
    <!-- Title for a status description saying that a feature is on [CHAR LIMIT=30] -->
    <string name="action_on_description">On</string>
    <!-- Title for a status description saying that a feature is off [CHAR LIMIT=30] -->
    <string name="action_off_description">Off</string>
    <!-- Title for action which denotes the user agrees [CHAR LIMIT=50] -->
    <string name="agree">Agree</string>
    <!-- Title for action which denotes the user disagrees [CHAR LIMIT=50] -->
    <string name="disagree">Disagree</string>

    <!-- Security -->
    <skip />
    <!-- Title for action to allow installation of applications from unknown sources [CHAR LIMIT=50]-->
    <string name="security_unknown_sources_title">Unknown sources</string>
    <!-- Description for action to allow installation of applications from unknown sources [CHAR LIMIT=NONE]-->
    <string name="security_unknown_sources_desc">Allow installation of apps from sources other than the Play Store</string>
    <!-- Description for confirmation to allow installation of applications from unknown sources [CHAR LIMIT=NONE]-->
    <string name="security_unknown_sources_confirm_desc">Your device and personal data are more vulnerable to attack by apps from unknown sources. You agree that you are solely responsible for any damage to your device or loss of data that may result from using these apps.</string>
    <!-- Title for action to warn before installing applications that may cause harm [CHAR LIMIT=50]-->
    <string name="security_verify_apps_title">Verify apps</string>
    <!-- Description for action to warn before installing of applications that may cause harm [CHAR LIMIT=NONE]-->
    <string name="security_verify_apps_desc">Disallow or warn before installation of apps that may cause harm</string>

    <!-- Values for HDCP checking preference. -->
    <string-array name="hdcp_checking_values" translatable="false" >
        <item>never</item>
        <item>drm-only</item>
        <item>always</item>
    </string-array>

    <!-- Summaries for HDCP checking preference. [CHAR LIMIT=100]-->
    <string-array name="hdcp_checking_summaries" >
        <item>Never</item>
        <item>For DRM content</item>
        <item>Always</item>
    </string-array>

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

    <!-- Titles for OpenGL traces preference. [CHAR LIMIT=35] -->
    <string-array name="enable_opengl_traces_entries">
        <item>None</item>
        <item>Logcat</item>
        <item>Systrace (Graphics)</item>
        <item>Call stack on glGetError</item>
    </string-array>

    <!-- Values for OpenGL traces preference. -->
    <string-array name="enable_opengl_traces_values" translatable="false" >
        <item>0</item>
        <item>1</item>
        <item>systrace</item>
        <item>error</item>
    </string-array>

    <!-- Titles for window animation scale preference. [CHAR LIMIT=35] -->
    <string-array name="window_animation_scale_entries">
        <item>Animation off</item>
        <item>Animation scale .5x</item>
        <item>Animation scale 1x</item>
        <item>Animation scale 1.5x</item>
        <item>Animation scale 2x</item>
        <item>Animation scale 5x</item>
        <item>Animation scale 10x</item>
    </string-array>

    <!-- Values for window animation scale preference. -->
    <string-array name="window_animation_scale_values" translatable="false" >
        <item>0</item>
        <item>.5</item>
        <item>1</item>
        <item>1.5</item>
        <item>2</item>
        <item>5</item>
        <item>10</item>
    </string-array>

    <!-- Titles for transition animation scale preference. [CHAR LIMIT=35] -->
    <string-array name="transition_animation_scale_entries">
        <item>Animation off</item>
        <item>Animation scale .5x</item>
        <item>Animation scale 1x</item>
        <item>Animation scale 1.5x</item>
        <item>Animation scale 2x</item>
        <item>Animation scale 5x</item>
        <item>Animation scale 10x</item>
    </string-array>

    <!-- Values for transition animation scale preference. -->
    <string-array name="transition_animation_scale_values" translatable="false" >
        <item>0</item>
        <item>.5</item>
        <item>1</item>
        <item>1.5</item>
        <item>2</item>
        <item>5</item>
        <item>10</item>
    </string-array>

    <!-- Titles for animator duration scale preference. [CHAR LIMIT=35] -->
    <string-array name="animator_duration_scale_entries">
        <item>Animation off</item>
        <item>Animation scale .5x</item>
        <item>Animation scale 1x</item>
        <item>Animation scale 1.5x</item>
        <item>Animation scale 2x</item>
        <item>Animation scale 5x</item>
        <item>Animation scale 10x</item>
    </string-array>

    <!-- Values for animator duration scale preference. -->
    <string-array name="animator_duration_scale_values" translatable="false" >
        <item>0</item>
        <item>.5</item>
        <item>1</item>
        <item>1.5</item>
        <item>2</item>
        <item>5</item>
        <item>10</item>
    </string-array>

    <!-- Titles for frame time tracking preference. [CHAR LIMIT=35] -->
    <string-array name="track_frame_time_entries">
        <item>Off</item>
        <item>On screen as bars</item>
        <item>In adb shell dumpsys gfxinfo</item>
    </string-array>

    <!-- Values for frame time tracking preference. -->
    <string-array name="track_frame_time_values" translatable="false" >
        <item>false</item>
        <item>visual_bars</item>
        <item>true</item>
    </string-array>

    <!-- Titles for app process limit preference. [CHAR LIMIT=35] -->
    <string-array name="app_process_limit_entries">
        <item>Standard limit</item>
        <item>No background processes</item>
        <item>At most 1 process</item>
        <item>At most 2 processes</item>
        <item>At most 3 processes</item>
        <item>At most 4 processes</item>
    </string-array>

    <!-- Values for app process limit preference. -->
    <string-array name="app_process_limit_values" translatable="false" >
        <item>-1</item>
        <item>0</item>
        <item>1</item>
        <item>2</item>
        <item>3</item>
        <item>4</item>
    </string-array>
    <!--  Description for the preference screen to enable the global gesture that turns on accessibility. [CHAR LIMIT=none] -->

    <!-- 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>
    </string-array>
    <string-array name="tts_demo_string_langs" translatable="false">
        <item>eng</item>
        <item>fra</item>
        <item>deu</item>
        <item>ita</item>
        <item>spa</item>
    </string-array>

    <!-- TTS settings -->

    <!-- Default speech rate choices [CHAR LIMIT=30] -->
    <string-array name="tts_rate_entries">
        <item>Very slow</item>
        <item>Slow</item>
        <item>Normal</item>
        <item>Fast</item>
        <item>Very fast</item>
    </string-array>
    <!-- Text to speech rate values [DO NOT TRANSLATE] -->
    <string-array name="tts_rate_values">
        <item>60</item>
        <item>80</item>
        <item>100</item>
        <item>150</item>
        <item>200</item>
    </string-array>
    <!-- Default Text to Speach rate. Should match value for "Normal" in the above array. [DO NOT TRANSLATE] -->
    <string name="tts_rate_default_value">100</string>

    <!-- Title for choose account type screen [CHAR LIMIT=100]-->
    <string name="choose_account_type_title">Choose account type</string>
    <!-- Title for choose account screen [CHAR LIMIT=80]-->
    <string name="choose_account_title">Choose account</string>
    <!-- Action option which adds a new account [CHAR LIMIT=80]-->
    <string name="add_account_button_label">Add new account</string>

    <!-- Keyboard Settings -->
    <!-- Title for Current Keyboard [CHAR LIMIT=80] -->
    <string name="title_current_keyboard">Current keyboard</string>
    <!-- Title for configure current keyboard [CHAR LIMIT=80] -->
    <string name="title_configure">Configure</string>
    <!-- Description for configure current keyboard [CHAR LIMIT=100] -->
    <string name="desc_configure_keyboard">Keyboard options</string>

    <!-- String shown when computing the total size of an application's cache or data files. [CHAR LIMIT=30] -->
    <string name="computing_size">Computing\u2026</string>

    <!-- Title for selecting wifi network [CHAR LIMIT=150] -->
    <string name="title_select_wifi_network">Select your Wi-Fi network</string>

    <!-- Action option which allows the change of the name this device is known by other wifi display devices [CHAR LIMIT=40] -->
    <string name="accessories_wifi_display_rename_device">Rename</string>

    <!-- Action option which allows the enabling or disabling of wifi display [CHAR LIMIT=40] -->
    <string name="accessories_wifi_display_enable">Wi-Fi Display</string>

    <!-- Action option which allows the enabling or disabling the PIN requirement of wifi display [CHAR LIMIT=40] -->
    <string name="accessories_wifi_display_pin_required">PIN required</string>

    <!-- Header used to list a connected Remote and its serial number. %1 gets replaced with the serial number. [CHAR LIMIT=40] -->
    <string name="accessories_remote_list_title">Remote information: <xliff:g id="serialnumber">%1$s</xliff:g></string>

    <!-- Bug Report strings. NOTE: these will not be shown to external users, only internal ones. -->
    <skip />
    <!-- Message shown when a bug report is being collected [CHAR LIMIT=100] -->
    <string name="system_collecting_bug_report">Collecting bug report!\nWe\'ll ask you for more info once the report is ready.</string>
    <!-- Message shown when a bug report could not be collected [CHAR LIMIT=100] -->
    <string name="system_collecting_bug_report_error">Could not collect bug report!\nPlease try again later.</string>

    <!-- Disambiguation Activity-->
    <!-- Title of intent resolver activity when selecting an application to run. [CHAR LIMIT=50]-->
    <string name="whichApplication">Complete action using</string>
    <!-- Quetsion about always using the selected application resolution in the future. See the "Complete action using" dialog title [CHAR LIMIT=50]-->
    <string name="alwaysUseQuestion">Always use this option for this action?</string>
    <!-- Option to always use the selected application resolution in the future. See the "Complete action using" dialog title [CHAR LIMIT=50]-->
    <string name="alwaysUseOption">Always use</string>
    <!-- Option to only use the selected option this time. See the "Complete action using" dialog title [CHAR LIMIT=50]-->
    <string name="justOnceOption">Just once</string>
    <!-- Text to display when there are no activities found to display in the activity chooser. See the whichApplication title.[CHAR LIMIT=50] -->
    <string name="noApplications">No apps can perform this action.</string>
    <!-- Action to go back to the previous screen, when no apps have been found to perform the requested action. [CHAR LIMIT=50]-->
    <string name="noAppsGoBack">Back</string>

    <!-- TV input settings row -->
    <string name="inputs_inputs">Inputs</string>
    <!-- Header of HDMI CEC device control [CHAR LIMIT=50] -->
    <string name="inputs_header_cec">Consumer Electronic Control (CEC)</string>
    <!-- Title of CEC device settings [CHAR LIMIT=30] -->
    <string name="inputs_cec_settings">Device control settings</string>
    <!-- Name of predefined name for TV input (Blu-ray player) [CHAR LIMIT=30] -->
    <string name="inputs_blu_ray">Blu-ray</string>
    <!-- Name of predefined name for TV input (Cable TV) [CHAR LIMIT=30] -->
    <string name="inputs_cable">Cable</string>
    <!-- Name of predefined name for TV input (DVD player) [CHAR LIMIT=30] -->
    <string name="inputs_dvd">DVD</string>
    <!-- Name of predefined name for TV input (Gaming device) [CHAR LIMIT=30] -->
    <string name="inputs_game">Game console</string>
    <!-- Name of predefined name for TV input (Aux) [CHAR LIMIT=30] -->
    <string name="inputs_aux">Aux</string>
    <!-- Title of using customized name for a TV input [CHAR LIMIT=30] -->
    <string name="inputs_custom_name">Custom name</string>
    <!-- Title of option to hide. It will describe current state of the inputs instead of the action [CHAR LIMIT=30] -->
    <string name="inputs_hide">Hidden</string>
    <!-- Description of option to hide [CHAR LIMIT=100] -->
    <string name="inputs_hide_desc">Not shown when switching inputs</string>
    <!-- Title format of entering custom label activity [CHAR LIMIT=30] -->
    <string name="inputs_custom_title">Custom name:</string>
    <!-- Option to enable HDMI control [CHAR LIMIT=30] -->
    <string name="inputs_hdmi_control">HDMI control</string>
    <!-- Description of HDMI control option [CHAR LIMIT=50] -->
    <string name="inputs_hdmi_control_desc">Allow the TV to control HDMI devices</string>
    <!-- Option to enable device auto power off [CHAR LIMIT=30] -->
    <string name="inputs_device_auto_off">Device auto power off</string>
    <!-- Description of device auto power off option [CHAR LIMIT=50] -->
    <string name="inputs_device_auto_off_desc">Power off HDMI devices with the TV</string>
    <!-- Option to enable TV auto power on [CHAR LIMIT=30] -->
    <string name="inputs_tv_auto_on">TV auto power on</string>
    <!-- Description of TV auto power on [CHAR LIMIT=50] -->
    <string name="inputs_tv_auto_on_desc">Power on the TV with HDMI device</string>
    <!-- Header for connected TV input(s) [CHAR LIMIT=30] -->
    <plurals name="inputs_header_connected_input">
        <item quantity="one">CONNECTED INPUT</item>
        <item quantity="other">CONNECTED INPUTS</item>
    </plurals>
    <!-- Header for standby TV input(s) [CHAR LIMIT=30] -->
    <plurals name="inputs_header_standby_input">
        <item quantity="one">STANDBY INPUT</item>
        <item quantity="other">STANDBY INPUTS</item>
    </plurals>
    <!-- Header for disconnected TV input(s) [CHAR LIMIT=30] -->
    <plurals name="inputs_header_disconnected_input">
        <item quantity="one">NOT CONNECTED INPUT</item>
        <item quantity="other">NOT CONNECTED INPUTS</item>
    </plurals>
    <!-- State of a TV input for 'connected' [CHAR LIMIT=30] -->
    <string name="inputs_state_connected">Connected</string>
    <!-- State of a TV input for 'standby' [CHAR LIMIT=30] -->
    <string name="inputs_state_connected_standby">Standby</string>
    <!-- State of a TV input for 'disconnected' [CHAR LIMIT=30] -->
    <string name="inputs_state_disconnected">Disconnected</string>

    <!-- Summary for add restricted profile entry in the choice dialog [CHAR LIMIT=none] -->
    <string name="user_add_profile_item_summary">Restrict access to apps and other content in your account</string>
    <!-- User details new restricted profile name [CHAR LIMIT=30] -->
    <string name="user_new_profile_name">Restricted Profile</string>
    <!-- User app limits screen title [CHAR LIMIT=35] -->
    <string name="user_restrictions_title">App &amp; content access</string>
    <!-- Summary for app entries that are controlled by another entry [CHAR LIMIT=none] -->
    <string name="user_restrictions_controlled_by">Controlled by <xliff:g id="app">%1$s</xliff:g></string>
    <!-- Summary for apps that aren't supported in limited users [CHAR LIMIT=none] -->
    <string name="app_not_supported_in_limited">This app is not supported in restricted profiles</string>
    <!-- Summary text for apps that are allowed to access accounts from the primary user [CHAR LIMIT=none] -->
    <string name="app_sees_restricted_accounts">This app can access your accounts</string>
    <!-- Restrictions title for allowing location sharing [CHAR LIMIT=35] -->
    <string name="restriction_location_enable_title">Location</string>
    <!-- Restrictions summary for allowing location sharing [CHAR LIMIT=100] -->
    <string name="restriction_location_enable_summary" >Let apps use your location information</string>
    <!-- Action to create a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_create" >Create restricted user</string>
    <!-- Action to switch to a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_switch_to" >Enter restricted profile</string>
    <!-- Action to switch out of a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_switch_out" >Exit restricted profile</string>
    <!-- Title for action to delete a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_delete_title" >Delete restricted profile</string>
    <!-- DO NOT TRANSLATE Description for action to delete a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_delete_description" translatable="false" >NOTE: This is debug only!</string>
    <!-- Title for action to configure a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_configure_title" >Settings</string>
    <!-- Title for action to configure apps for a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_configure_apps_title" >Allowed apps</string>
    <!-- Description for action to configure apps for a restricted profile indicating number of allow apps will be ready in a moment [CHAR LIMIT=100] -->
    <plurals name="restricted_profile_configure_apps_description">
        <item quantity="one">1 app allowed</item>
        <item quantity="other">%d apps allowed</item>
    </plurals>
    <!-- An action label indicating the package will be or is allowed [CHAR LIMIT=100] -->
    <string name="restricted_profile_allowed" >Allowed</string>
    <!-- An action label indicating the package will be or is not allowed [CHAR LIMIT=100] -->
    <string name="restricted_profile_not_allowed" >Not allowed</string>
    <!-- Action to customize restrictions for a package [CHAR LIMIT=100] -->
    <string name="restricted_profile_customize_restrictions" >Customize restrictions</string>
    <!-- Description for action to configure apps for a restricted profile indicating the number of allow apps [CHAR LIMIT=100] -->
    <string name="restricted_profile_configure_apps_description_loading" >One moment\u2026</string>
    <!-- Title for action to change the PIN code to use when exiting restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_change_password_title" >Change pin</string>
    <!-- Text to indicate user should enter a new password [CHAR LIMIT=100] -->
    <string name="restricted_profile_set_password" >Set new PIN code used to exit restricted profile</string>
    <!-- Text to indicate user should enter a the password they just entered [CHAR LIMIT=100] -->
    <string name="restricted_profile_confirm_password" >Confirm PIN code used to exit restricted profile</string>
    <!-- Text to indicate user should enter the password to get out of restricted profile[CHAR LIMIT=100] -->
    <string name="restricted_profile_enter_password" >Enter PIN code to exit restricted profile</string>
    <!-- Title for dialog to remove restricted user [CHAR LIMIT=100] -->
    <string name="restricted_profile_delete_dialog_title" >Remove restricted user?</string>
    <!-- Description for action to configure an application's restriction [CHAR LIMIT=200] -->
    <string name="restriction_description" ><xliff:g id="description">%1$s</xliff:g>\n<xliff:g id="value">%2$s</xliff:g></string>

    <!-- PIN UX -->
    <eat-comment />
    <string name="font" translatable="false">sans-serif</string>
    <string name="light_font" translatable="false">sans-serif-light</string>
    <!-- Title of PIN dialog when an user is asked to enter PIN to unlock channel.
         [CHAR LIMIT=50] -->
    <string name="pin_enter_unlock_channel">Enter PIN to watch this channel</string>
    <!-- Title of PIN dialog when an user is asked to enter PIN to unlock program.
         [CHAR LIMIT=50] -->
    <string name="pin_enter_unlock_program">Enter PIN to watch this program</string>
    <!-- Title of PIN dialog when an user tries to change Parental control setting.
         [CHAR LIMIT=50] -->
    <string name="pin_enter_pin">Enter PIN</string>
    <!-- Title of PIN dialog when an user is asked to set a PIN for the first time.
         [CHAR LIMIT=50] -->
    <string name="pin_enter_new_pin">Set a new PIN</string>
    <!-- Title of PIN dialog when an user is asked to set a PIN. [CHAR LIMIT=50] -->
    <string name="pin_enter_again">Re-enter new PIN</string>
    <!-- Title of PIN dialog when an user is about to change older PIN. [CHAR LIMIT=50] -->
    <string name="pin_enter_old_pin">Enter old PIN</string>
    <!-- Message shown in the dialog when the user entered the wrong. [CHAR LIMIT=128] -->
    <string name="pin_enter_wrong">You entered the wrong PIN 5 times.\nTry again <xliff:g id="relative_time_span" example="in 60 seconds">%1$s</xliff:g>.</string>
    <!-- Name of PIN dialog button for OK. [CHAR LIMIT=8] -->
    <string name="pin_button_done">Done</string>
    <!-- Name of PIN dialog button for cancel. [CHAR LIMIT=8] -->
    <string name="pin_button_cancel">Cancel</string>
    <!-- Toast message when an user entered wrong PIN. [CHAR LIMIT=128] -->
    <string name="pin_toast_wrong">Wrong PIN, try again</string>
    <!-- Toast message when an user couldn't pass the PIN confirmation. [CHAR LIMIT=128] -->
    <string name="pin_toast_not_match">Try again, PIN doesn\'t match</string>

</resources>
