<?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 />
    <!-- Title for main screen category for accounts on device [CHAR LIMIT=50] -->
    <string name="accounts_category_title">Accounts</string>
    <!-- Preference which adds an account [CHAR LIMIT=50] -->
    <string name="add_account">Add account</string>
    <!-- Header for remove account [CHAR LIMIT=50] -->
    <string name="account_header_remove_account">Remove account</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>
    <!-- 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>
    <!-- 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>
    <!-- Formatter in AccountSyncSettings for each application we wish to synchronize, e.g. "Sync Calendar" -->
    <string name="sync_item_title"><xliff:g id="authority" example="Calendar">%s</xliff:g></string>
    <!-- Data synchronization settings screen, summary of a sync provider (for example, Gmail) when autosync is off and the user wants to do a one-time sync. -->
    <string name="sync_one_time_sync">Sync now<xliff:g id="last_sync_time">\n%1$s</xliff:g></string>
    <!-- Image description for the sync failed icon. -->
    <string name="sync_failed">Sync failed</string>
    <!-- Animation description for the sync active icon. -->
    <string name="sync_active">Sync active</string>

    <!-- 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>
    <!-- Title for always scan wifi. [CHAR LIMIT=50] -->
    <string name="wifi_setting_always_scan">Scanning always available</string>
    <!-- Context help for always scan wifi. [CHAR LIMIT=200] -->
    <string name="wifi_setting_always_scan_context">Let Google\'s location service and other apps scan for networks, even when Wi-Fi is off</string>
    <!-- Title for enable wifi. [CHAR LIMIT=50] -->
    <string name="wifi_setting_enable_wifi">Wi-Fi</string>

    <!-- Device preferences -->
    <skip />
    <!-- Preference which changes screen saver settings. [CHAR LIMIT=50] -->
    <string name="device_daydream">Screen saver</string>
    <!-- Preference which changes display settings. [CHAR LIMIT=50] -->
    <string name="device_display">Display</string>
    <!-- Title for preference screen controlling sound settings [CHAR LIMIT=50] -->
    <string name="device_sound">Sound</string>
    <!-- Title for preference which controls surround sound passthrough function [CHAR LIMIT=50] -->
    <string name="device_surround_sound">Surround sound</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 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 pairing new accessories. [CHAR LIMIT=50] -->
    <string name="accessories_add">Add accessory</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 unpairing a Bluetooth accessory[CHAR LIMIT=50] -->
    <string name="accessory_unpair">Unpair</string>
    <!-- Preference for displaying battery level percentage. % symbol if used must be escaped as %% [CHAR LIMIT=150] -->
    <string name="accessory_battery">Battery <xliff:g id="percentage">%1$d</xliff:g>%%</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>
    <!-- Title of preference item for renaming the bluetooth accessory [CHAR LIMIT=50] -->
    <string name="accessory_change_name">Change name</string>
    <!-- Title of dialog for renaming the bluetooth accessory [CHAR LIMIT=100] -->
    <string name="accessory_change_name_title">Enter a new name for this accessory</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>
    <!-- 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 google and assistant settings. [CHAR LIMIT=50] -->
    <string name="system_google">Google</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>
    <!-- Preference which manages Diagnostic and Usage reporting -->
    <string name="system_diagnostic">Usage &amp; Diagnostics</string>

    <!-- About -->
    <skip />
    <!-- Preference which shows feature tutorial tours for this device. [CHAR LIMIT=50] -->
    <string name="tutorials">Tutorials</string>
    <!-- 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 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>
    <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
    <string name="device_info_default">Unknown</string>
    <!-- About screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="selinux_status">SELinux status</string>
    <!-- These statuses are displayed when a device was built with SE Android supoprt.
    These are displayed by the settings app in the about section. -->
    <string name="selinux_status_disabled">Disabled</string>
    <string name="selinux_status_permissive">Permissive</string>
    <string name="selinux_status_enforcing">Enforcing</string>

    <!-- A menu item in "About phone" that allows the user to update the phone with settings
        from their cell phone carrier. The use of the string is similar to the string
        "system_update_settings_list_item_title" in this project. [CHAR LIMIT=50] -->
    <string name="additional_system_update_settings_list_item_title">Additional system updates</string>

    <!-- About screen, title of the item to go into the device status screen -->
    <string name="device_status">Status</string>
    <!-- About screen, summary of the item that takes you to device status screen -->
    <string name="device_status_summary">Network, serial numbers and other information</string>

    <!-- About settings screen, setting option name to show Manual [CHAR LIMIT=25] -->
    <string name="manual">Manual</string>
    <!-- About settings screen, setting option name to show regulatory information [CHAR LIMIT=25] -->
    <string name="regulatory_information">Regulatory information</string>
    <!-- Feedback on the device [CHAR LIMIT=35] -->
    <string name="device_feedback">Send feedback about this device</string>

    <!-- Full package name of OEM preferred device feedback reporter. [DO NOT TRANSLATE] -->
    <string name="oem_preferred_feedback_reporter" translatable="false" />

    <!-- About screen, fcc equipment id label  [CHAR LIMIT=40] -->
    <string name="fcc_equipment_id">Equipment ID</string>
    <!-- About screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="baseband_version">Baseband version</string>
    <!-- About screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="kernel_version">Kernel version</string>

    <!-- Status screen -->
    <!-- About phone, status item value if the actual value is not available. -->
    <string name="status_unavailable">Unavailable</string>
    <!-- About phone screen, phone status screen title -->
    <string name="device_status_title">Status</string>
    <!-- Phone info screen, section titles: -->
    <string name="battery_status_title">Battery status</string>
    <!-- Phone info screen, section titles: -->
    <string name="battery_level_title">Battery level</string>
    <!-- SIM status title  [CHAR LIMIT=40] -->
    <string name="sim_status_title">SIM status</string>
    <!-- Title for IMEI preference [CHAR LIMIT=30] -->
    <string name="imei_information_title">IMEI information</string>
    <!-- About phone, status item title.  The bluetooth adapter's hardware address-->
    <string name="status_bt_address">Bluetooth address</string>
    <!-- About phone, status item title.  How long the device has been running since its last reboot. -->
    <string name="status_up_time">Up time</string>
    <!-- About phone, status item title. WI-MAX MAC address -->
    <string name="status_wimax_mac_address">4G MAC address</string>

    <!-- Legal screen -->
    <!-- About phone settings screen, setting option name to go to dialog that shows legal info -->
    <string name="legal_information">Legal information</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see copyright-related info -->
    <string name="copyright_title">Copyright</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see licensing info -->
    <string name="license_title">License</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see terms and conditions -->
    <string name="terms_title">Terms and conditions</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see licensing info for WebView component. [CHAR LIMIT=35] -->
    <string name="webview_license_title">System WebView License</string>
    <!-- About phone settings screen, setting option name to see wallpapers attributions -->
    <string name="wallpaper_attributions">Wallpapers</string>
    <!-- About phone settings screen, setting option name to see wallpapers attributions values -->
    <string name="wallpaper_attributions_values">Satellite imagery providers:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky</string>

    <!-- Wifi -->
    <skip />

    <!-- 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_other_options">Other options</string>
    <string name="wifi_setting_see_all">See all</string>
    <string name="wifi_setting_see_fewer">See fewer</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 -->
    <!-- Security type title on add network form page [CHAR LIMIT=30] -->
    <string name="security_type">Type of security</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 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>
    <!-- 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>
    <!-- Description text for the IP address -->
    <string name="wifi_ip_address_description">Enter a valid IP address.\nExample: <xliff:g>192.168.1.128</xliff:g></string>
    <!-- Description text for DNS -->
    <string name="wifi_dns1_description">Enter a valid IP address or leave empty.\nExample: <xliff:g>8.8.8.8</xliff:g></string>
    <!-- Description text for DNS -->
    <string name="wifi_dns2_description">Enter a valid IP address or leave empty.\nExample: <xliff:g>8.8.4.4</xliff:g></string>
    <!-- Description text for the gateway -->
    <string name="wifi_gateway_description">Enter a valid IP address or leave empty.\nExample: <xliff:g>192.168.1.1</xliff:g></string>
    <!-- Description text for network prefix length -->
    <string name="wifi_network_prefix_length_description">Enter a valid network prefix length.\nExample: <xliff:g>24</xliff:g></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 description for proxy server port. -->
    <string name="proxy_port_description">Enter a valid port.\nExample: <xliff:g>8080</xliff:g></string>
    <!-- HTTP proxy settings. The description for proxy exclusion list.-->
    <string name="proxy_exclusionlist_description">Enter a comma-separated list of excluded domains or leave blank.\nExample: <xliff:g>example.com,mycomp.test.com,localhost</xliff:g></string>
    <!-- HTTP proxy settings. The description field for the hostname. -->
    <string name="proxy_hostname_description">Enter a valid hostname.\nExample: <xliff:g>proxy.example.com</xliff:g></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>

    <!-- Strings for Ethernet under Connectivity Setting -->
    <!-- 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>

    <!-- 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>
    <!-- Storage settings eject action [CHAR LIMIT=50] -->
    <string name="storage_eject">Eject</string>
    <!-- Storage settings erase and format action [CHAR LIMIT=50] -->
    <string name="storage_format">Erase &amp; format</string>
    <!-- Storage settings erase and format action [CHAR LIMIT=50] -->
    <string name="storage_format_as_private">Erase &amp; format as device storage</string>
    <!-- Storage settings erase and format action [CHAR LIMIT=50] -->
    <string name="storage_format_as_public">Erase &amp; format as removable storage</string>
    <!-- Storage settings format for device storage action [CHAR LIMIT=50] -->
    <string name="storage_format_for_private">Format as device storage</string>
    <!-- Description for a storage volume which is not currently connected to the device -->
    <string name="storage_not_connected">Not connected</string>
    <!-- Storage settings migrate primary storage action [CHAR_LIMIT=50] -->
    <string name="storage_migrate">Migrate data to this storage</string>
    <!-- Storage settings migrate primary storage action [CHAR_LIMIT=50] -->
    <string name="storage_migrate_away">Migrate data to different storage</string>
    <!-- Storage settings backup apps empty action [CHAR LIMIT=50] -->
    <string name="storage_no_apps">No apps to back up</string>

    <!-- Storage settings forget action [CHAR_LIMIT=50] -->
    <string name="storage_forget">Forget this device storage</string>
    <!-- Storage settings forget description [CHAR_LIMIT=NONE] -->
    <string name="storage_forget_wall_of_text">To use the apps or data this drive contains, replug it in. Alternatively, you can choose to forget this storage if the drive isn\'t available.\n\nIf you choose Forget, all the data the drive contains will be lost forever.\n\nYou can reinstall the apps later, but the data stored on this drive will be lost.</string>

    <!-- Header title for device storage [CHAR_LIMIT=50] -->
    <string name="storage_device_storage_section">Device storage</string>
    <!-- Header title for removable storage [CHAR_LIMIT=50] -->
    <string name="storage_removable_storage_section">Removable storage</string>
    <!-- Header title for device reset [CHAR_LIMIT=50] -->
    <string name="storage_reset_section">Reset</string>

    <!-- Toast informing that storage mount operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_mount_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is mounted</string>
    <!-- Toast informing that storage unmount operation failed. [CHAR LIMIT=64]-->
    <string name="storage_mount_failure">Couldn\'t mount <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

    <!-- Toast shown when the user connects external storage that has been formatted for Android  [CHAR_LIMIT=50] -->
    <string name="storage_mount_adopted">USB storage reconnected</string>

    <!-- Toast informing that storage unmount operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_unmount_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is safely ejected</string>
    <!-- Toast informing that storage unmount operation failed. [CHAR LIMIT=64]-->
    <string name="storage_unmount_failure">Couldn\'t safely eject <xliff:g id="name" example="SD card">%1$s</xliff:g></string>
    <!-- Toast informing that storage unmount operation failed because the volume couldn't be found. [CHAR LIMIT=64]-->
    <string name="storage_unmount_failure_cant_find">Could\'t find drive to eject</string>

    <!-- Toast informing that storage format operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_format_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is formatted</string>
    <!-- Toast informing that storage format operation failed. [CHAR LIMIT=64]-->
    <string name="storage_format_failure">Couldn\'t format <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

    <!-- Title for wizard screen for formatting storage as device [CHAR LIMIT=64] -->
    <string name="storage_wizard_format_as_private_title">Format as device storage</string>
    <!-- Description for wizard screen for formatting storage as device [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_as_private_description">This requires the USB drive to be formatted to make it secure. After securely formatting, this drive will only work with this device. Formatting erases all data currently stored on the drive. To avoid losing the data, consider backing it up.</string>

    <!-- Title for wizard screen for formatting storage as device [CHAR LIMIT=64] -->
    <string name="storage_wizard_format_as_public_title">Erase &amp; Format</string>
    <!-- Description for wizard screen for formatting storage as device [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_as_public_description">After formatting, you can use this USB drive in other devices. All data will be erased. Consider backing up first by moving apps to other device storage.</string>

    <!-- Title for wizard progress screen for formatting drive [CHAR_LIMIT=50] -->
    <string name="storage_wizard_format_progress_title">Formatting USB Drive&#8230;</string>
    <!-- Description for wizard progress screen for formatting drive [CHAR_LIMIT=NONE] -->
    <string name="storage_wizard_format_progress_description">This may take a moment. Please don\'t remove the drive.</string>

    <!-- Title for wizard selection screen for migrating data to new drive [CHAR LIMIT=50] -->
    <string name="storage_wizard_migrate_choose_title">Choose storage to migrate data to</string>
    <!-- Title for wizard confirmation screen for migrating data to new drive [CHAR_LIMIT=50] -->
    <string name="storage_wizard_migrate_confirm_title">Move data to <xliff:g id="name" example="SD card">%1$s</xliff:g></string>
    <!-- Description for wizard confirmation screen for migrating data to new drive [CHAR_LIMIT=NONE] -->
    <string name="storage_wizard_migrate_confirm_description">Move your photos, files and app data to <xliff:g id="name" example="SD card">%1$s</xliff:g>. This may take a few minutes. Some apps won\'t work correctly during the move.</string>
    <!-- Positive action for wizard confirmation screen for migrating data to new drive [CHAR_LIMIT=50] -->
    <string name="storage_wizard_migrate_confirm_action_move_now">Move now</string>
    <!-- Negative action for wizard confirmation screen for migrating data to new drive [CHAR_LIMIT=50] -->
    <string name="storage_wizard_migrate_confirm_action_move_later">Move later</string>

    <!-- Success toast for migrating data [CHAR_LIMIT=100] -->
    <string name="storage_wizard_migrate_toast_success">Migrated data to <xliff:g id="name" example="SD card">%1$s</xliff:g></string>
    <!-- Failure toast for migrating data [CHAR_LIMIT=100] -->
    <string name="storage_wizard_migrate_toast_failure">Could not migrate data to <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

    <!-- Title for wizard progress screen for migrating data to new drive [CHAR_LIMIT=50] -->
    <string name="storage_wizard_migrate_progress_title">Moving data to <xliff:g id="name" example="SD card">%1$s</xliff:g>&#8230;</string>
    <!-- Description for wizard progress screen for migrating data to new drive [CHAR_LIMIT=NONE] -->
    <string name="storage_wizard_migrate_progress_description">This may take a moment. Please don\'t remove the drive.\nSome apps won\'t work correctly during the move.</string>

    <!-- Title for warning dialog for slow drives [CHAR_LIMIT=64] -->
    <string name="storage_wizard_format_slow_title">This drive appears to be slow.</string>

    <!-- Summary for warning dialog for slow drives [CHAR_LIMIT=NONE] -->
    <string name="storage_wizard_format_slow_summary">You can continue, but apps moved to this location may stutter and data transfers may take a long time. Consider using a faster drive for better performance.</string>

    <!-- Format action for wizard screen for formatting storage [CHAR LIMIT=50] -->
    <string name="storage_wizard_format_action">Format</string>
    <!-- Back up apps action for wizard screen for formatting storage [CHAR LIMIT=50]-->
    <string name="storage_wizard_backup_apps_action">Back up apps</string>

    <!-- Back up apps title [CHAR LIMIT=50] -->
    <string name="storage_wizard_back_up_apps_title">Apps stored in <xliff:g id="name" example="SD card">%1$s</xliff:g></string>
    <!-- Back up apps title [CHAR LIMIT=50] -->
    <string name="storage_wizard_back_up_apps_and_data_title">Apps and data stored in <xliff:g id="name" example="SD card">%1$s</xliff:g></string>
    <!-- Back up apps storage available description [CHAR_LIMIT=50] -->
    <string name="storage_wizard_back_up_apps_space_available"><xliff:g id="size" example="1.23GB">%1$s</xliff:g> available</string>

    <!-- Title for wizard screen for ejecting device storage [CHAR LIMIT=64] -->
    <string name="storage_wizard_eject_private_title">Eject device storage</string>
    <!-- Description for wizard screen for ejecting device storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_eject_private_description">Apps on this device storage will stop working when it\'s ejected. This USB drive is formatted to work on this device only. It won\'t work on any others.</string>

    <!-- Title for wizard progress screen for ejecting a drive [CHAR_LIMIT=64] -->
    <string name="storage_wizard_eject_progress_title">Ejecting <xliff:g id="name" example="SD Card">%1$s</xliff:g>&#8230;</string>

    <!-- Title for wizard screen for moving apps [CHAR_LIMIT=50] -->
    <string name="storage_wizard_move_app_title">Storage used</string>

    <!-- Title for wizard progress screen for moving apps [CHAR_LIMIT=50] -->
    <string name="storage_wizard_move_app_progress_title">Moving <xliff:g id="name" example="YouTube">%1$s</xliff:g>&#8230;</string>
    <!-- Description for wizard progress screen for moving apps [CHAR_LIMIT=NONE] -->
    <string name="storage_wizard_move_app_progress_description">"Don't remove the drive during the move.\nThe <xliff:g id="appname" example="YouTube">%1$s</xliff:g> app on this device won't be available until the move is complete.</string>

    <!-- Title for wizard screen for forgetting private storage [CHAR_LIMIT=50] -->
    <string name="storage_wizard_forget_confirm_title">Forget device storage?</string>
    <!-- Description for wizard screen for forgetting private storage [CHAR_LIMIT=NONE] -->
    <string name="storage_wizard_forget_confirm_description">All your data stored in this drive will be lost forever with \'Forget\'. Would you like to proceed?</string>
    <!-- Action for wizard screen for forgetting private storage [CHAR_LIMIT=50] -->
    <string name="storage_wizard_forget_action">Forget</string>

    <!-- Title for new storage activity [CHAR_LIMIT=50] -->
    <string name="storage_new_title">USB drive connected</string>
    <!-- Browse action for new storage activity [CHAR_LIMIT=50] -->
    <string name="storage_new_action_browse">Browse</string>
    <!-- Adopt action for new storage activity [CHAR_LIMIT=50] -->
    <string name="storage_new_action_adopt">Set up as device storage</string>
    <!-- Format as removable action for new storage activity [CHAR_LIMIT=50] -->
    <string name="storage_new_action_format_public">Set up as removable storage</string>
    <!-- Eject action for new storage activity [CHAR_LIMIT=50] -->
    <string name="storage_new_action_eject">Eject</string>

    <!-- Title for missing storage activity shown when a drive is removed [CHAR_LIMIT=50] -->
    <string name="storage_missing_title"><xliff:g id="name" example="SD Card">%1$s</xliff:g> removed</string>
    <!-- Description for missing storage activity shown when a drive is removed [CHAR_LIMIT=NONE] -->
    <string name="storage_missing_description">Some apps will be unavailable or not function correctly until the drive is reconnected.</string>

    <!-- Manage applications, text for move error messages -->
    <string name="insufficient_storage">Not enough storage space.</string>
    <string name="does_not_exist">App doesn\u2019t exist.</string>
    <string name="app_forward_locked">App is copy-protected.</string>
    <string name="invalid_location">Install location isn\u2019t valid.</string>
    <string name="system_package">System updates can\u2019t be installed on external media.</string>
    <!-- Error message shown when trying to move device administrators to external disks, such as SD card [CHAR_LIMIT=none] -->
    <string name="move_error_device_admin">Device Administrator can\u2019t be installed on external media.</string>

    <!-- Learn more action title [CHAR_LIMIT=50] -->
    <string name="learn_more_action">Learn more</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 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>
    <!-- Format string for displaying the current time zone, eg "GMT-08:00, Pacific Standard Time" [CHAR LIMIT=10] -->
    <string name="desc_set_time_zone"><xliff:g id="offset" example="GMT-08:00">%1$s</xliff:g>, <xliff:g id="name" example="Pacific Standard Time">%2$s</xliff:g></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>
    <!-- Format string for displaying the current time format (12/24 hour) [CHAR LIMIT=10] -->
    <string name="desc_set_time_format"><xliff:g id="state" example="Off">%1$s</xliff:g> (<xliff:g id="sample" example="3:14 PM">%2$s</xliff:g>)</string>
    <!-- Title for automatic date & time [CHAR LIMIT = 80] -->
    <string name="system_auto_date_time">Automatic date &amp; time</string>
    <!-- Options for automatic date & time [CHAR LIMIT=100] -->
    <string-array name="auto_date_time_entries">
        <item>Use network-provided time</item>
        <item>Off</item>
    </string-array>
    <!-- Values for automatic date & time [DO NOT TRANSLATE] -->
    <string-array name="auto_date_time_entry_values" translatable="false">
        <item>network</item>
        <item>off</item>
    </string-array>
    <!-- Options for automatic date & time [CHAR LIMIT=100] -->
    <string-array name="auto_date_time_ts_entries">
        <item>Use network-provided time</item>
        <item>Use transport stream-provided time</item>
        <item>Off</item>
    </string-array>
    <!-- Values for automatic date & time [DO NOT TRANSLATE] -->
    <string-array name="auto_date_time_ts_entry_values" translatable="false">
        <item>network</item>
        <item>transport_stream</item>
        <item>off</item>
    </string-array>

    <!-- 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 confirming location consent [CHAR LIMIT=50] -->
    <string name="system_network_location_confirm">Location consent</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 for the accessibility preference to high contrast text. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_high_text_contrast_preference_title">High contrast text</string>
    <!-- Title for accessibility shortcut preference and screen [CHAR LIMIT=50] -->
    <string name="accessibility_shortcut">Accessibility shortcut</string>
    <!-- Title for accessibility shortcut toggle [CHAR LIMIT=50] -->
    <string name="accessibility_shortcut_enable">Enable accessibility shortcut</string>
    <!-- Title for accessibility shortcut service choice preference [CHAR LIMIT=50}-->
    <string name="accessibility_shortcut_service">Shortcut service</string>
    <!-- Description for the accessibility shortcut [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_description">When the shortcut is on, you can press both home and select for 3 seconds to start an accessibility feature</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_language">Language</string>
    <!-- Entry for "default" selection for captions language [CHAR LIMOIT=50] -->
    <string name="captions_language_default">Default</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 display setting [CHAR LIMIT=50] -->
    <string name="captions_backgroundshow">Show background</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 display setting [CHAR LIMIT=50] -->
    <string name="captions_windowshow">Show window</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>

    <!-- Title for caption style 0 [CHAR LIMIT=50] -->
    <string name="captions_style_0">White on black</string>
    <!-- Title for caption style 1 [CHAR LIMIT=50] -->
    <string name="captions_style_1">Black on white</string>
    <!-- Title for caption style 2 [CHAR LIMIT=50] -->
    <string name="captions_style_2">Yellow on black</string>
    <!-- Title for caption style 3 [CHAR LIMIT=50] -->
    <string name="captions_style_3">Yellow on blue</string>
    <!-- Title for customized caption style [CHAR LIMIT=50] -->
    <string name="captions_style_custom">Custom</string>

    <!-- Label for the color white. [CHAR LIMIT=35] -->
    <string name="color_white">White</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>

    <!-- Title for accessibility service status [CHAR LIMIT=50] -->
    <string name="system_accessibility_status">Enable</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 text to speech engine configuration in accessibility settings [CHAR LIMIT=50] -->
    <string name="system_accessibility_tts_engine_config">Engine configuration</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 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 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 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 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>

    <!-- 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>
    <!-- Title for confirmation dialog to allow installation of applications from unknown sources [CHAR LIMIT=50]-->
    <string name="security_unknown_sources_confirm_title">Allow unknown sources</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>

    <!-- Summary for HDCP checking preference. [CHAR LIMIT=100]-->
    <string name="system_hdcp_checking_never">Never</string>
    <!-- Summary for HDCP checking preference. [CHAR LIMIT=100]-->
    <string name="system_hdcp_checking_drm">For DRM content</string>
    <!-- Summary for HDCP checking preference. [CHAR LIMIT=100]-->
    <string name="system_hdcp_checking_always">Always</string>

    <!-- Title for HDMI optimization preference value [CHAR LIMIT=60] -->
    <string name="system_hdmi_optimization_best_resolution">Best resolution</string>
    <!-- Title for HDMI optimization preference value [CHAR LIMIT=60] -->
    <string name="system_hdmi_optimization_best_framerate">Best framerate</string>

    <!-- Title for debug overdraw preference. [CHAR LIMIT=35] -->
    <string name="system_hw_overdraw_off">Off</string>
    <!-- Title for debug overdraw preference. [CHAR LIMIT=35] -->
    <string name="system_hw_overdraw_areas">Show overdraw areas</string>
    <!-- Title for debug overdraw preference. [CHAR LIMIT=35] -->
    <string name="system_hw_overdraw_counter">Show overdraw counter</string>


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

    <!-- Title for OpenGL traces preference. [CHAR LIMIT=35] -->
    <string name="enable_opengl_traces_none">None</string>
    <!-- Title for OpenGL traces preference. Do not translate "Logcat" [CHAR LIMIT=35] -->
    <string name="enable_opengl_traces_logcat">Logcat</string>
    <!-- Title for OpenGL traces preference. Do not translate "Systrace" [CHAR LIMIT=35] -->
    <string name="enable_opengl_traces_systrace">Systrace (Graphics)</string>
    <!-- Title for OpenGL traces preference. "Call stack" is a developer term. Do not translate "glGetError" [CHAR LIMIT=35] -->
    <string name="enable_opengl_traces_error">Call stack on glGetError</string>

    <!-- Titles for window animation scale preference. [CHAR LIMIT=35] -->
    <string-array name="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="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>

    <!-- Title for frame time tracking preference. [CHAR LIMIT=35] -->
    <string name="track_frame_time_off">Off</string>
    <!-- Title for frame time tracking preference. [CHAR LIMIT=35] -->
    <string name="track_frame_time_bars">On screen as bars</string>
    <!-- Title for frame time tracking preference. Do not translate "adb shell dumpsys gfxinfo" [CHAR LIMIT=35] -->
    <string name="track_frame_time_gfxinfo">In adb shell dumpsys gfxinfo</string>

    <!-- Title for app process limit preference. [CHAR LIMIT=35] -->
    <string name="app_process_limit_standard">Standard limit</string>
    <!-- Title for app process limit preference. [CHAR LIMIT=35] -->
    <string name="app_process_limit_zero">No background processes</string>
    <!-- Title for app process limit preference. [CHAR LIMIT=35] -->
    <string name="app_process_limit_one">At most 1 process</string>
    <!-- Title for app process limit preference. [CHAR LIMIT=35] -->
    <string name="app_process_limit_two">At most 2 processes</string>
    <!-- Title for app process limit preference. [CHAR LIMIT=35] -->
    <string name="app_process_limit_three">At most 3 processes</string>
    <!-- Title for app process limit preference. [CHAR LIMIT=35] -->
    <string name="app_process_limit_four">At most 4 processes</string>

    <!--  Description for the preference screen to enable the global gesture that turns on accessibility. [CHAR LIMIT=none] -->

    <!-- TTS settings -->

    <!-- Text-to-speech speech rate choice [CHAR LIMIT=30] -->
    <string name="tts_rate_very_slow">Very slow</string>
    <!-- Text-to-speech speech rate choice [CHAR LIMIT=30] -->
    <string name="tts_rate_slow">Slow</string>
    <!-- Text-to-speech speech rate choice [CHAR LIMIT=30] -->
    <string name="tts_rate_normal">Normal</string>
    <!-- Text-to-speech speech rate choice [CHAR LIMIT=30] -->
    <string name="tts_rate_fast">Fast</string>
    <!-- Text-to-speech speech rate choice [CHAR LIMIT=30] -->
    <string name="tts_rate_very_fast">Very fast</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>

    <!-- 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>
    <!-- Description for action of setting a custom name for a TV input [CHAR LIMIT=200] -->
    <string name="inputs_custom_name_description_fmt">Enter a name for the <xliff:g id="input" example="HDMI">%1$s</xliff:g> input.</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>
    <!-- Title of option to show this input while switching.[CHAR LIMIT=50] -->
    <string name="inputs_show">Show this input</string>
    <!-- Header for input name options [CHAR LIMIT=50] -->
    <string name="input_header_names">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>

    <!-- 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>
    <!-- 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 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>
    <!-- Title for action to create a restricted profile [CHAR LIMIT=100] -->
    <string name="restricted_profile_create_title">Create restricted profile</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>
    <!-- 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>
    <!-- Summary for a case when app entries that are controlled by another entry and app can access user accounts [CHAR LIMIT=none] -->
    <string name="app_sees_restricted_accounts_and_controlled_by">This app can access your accounts. Controlled by <xliff:g id="app">%1$s</xliff:g></string>

    <!-- 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_seconds">You entered the wrong PIN 5 times.\nTry again in <xliff:g id="relative_time_span" example="60">%1$d</xliff:g> seconds.</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>

    <!-- Message displayed to prompt the user to input the network password, ^1 will be replaced with the name of the network and should be a possive form related to password [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_input_password">Enter password for <xliff:g id="ssid">%1$s</xliff:g></string>
    <!-- Message displayed when the selected Wi-Fi network has been connected to [CHAR LIMIT=40] -->
    <string name="wifi_setup_connection_success">Connected successfully</string>
    <!-- Message displayed when the Wi-Fi network's configuration has been saved [CHAR LIMIT=40] -->
    <string name="wifi_setup_save_success">Saved successfully</string>

    <!-- Application management application version label [CHAR LIMIT=NONE] -->
    <string name="device_apps_app_management_version">Version <xliff:g id="app_version">%1$s</xliff:g></string>
    <!-- Application management description for opening the application [CHAR LIMIT=NONE] -->
    <string name="device_apps_app_management_open">Open</string>
    <!-- Application management choice for force stopping the application [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_force_stop">Force stop</string>
    <!-- Application management description for force stopping the application [CHAR LIMIT=NONE] -->
    <string name="device_apps_app_management_force_stop_desc">If you force stop an app, it may misbehave.</string>
    <!-- Application management choice for uninstalling the application [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_uninstall">Uninstall</string>
    <!-- Application management choice for uninstalling updates for the application [CHAR_LIMIT=40] -->
    <string name="device_apps_app_management_uninstall_updates">Uninstall updates</string>
    <!-- Application management description for uninstalling updates for the application [CHAR_LIMIT=NONE] -->
    <string name="device_apps_app_management_uninstall_updates_desc">All updates to this Android system app will be uninstalled.</string>
    <!-- Application management choice for disabling the application [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_disable">Disable</string>
    <!-- Application management description for disabling the application [CHAR LIMIT=NONE] -->
    <string name="device_apps_app_management_disable_desc">Do you want to disable this app?</string>
    <!-- Application management choice for enabling the application [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_enable">Enable</string>
    <!-- Application management description for enabling the application [CHAR LIMIT=NONE] -->
    <string name="device_apps_app_management_enable_desc">Do you want to enable this app?</string>
    <!-- Application management choice for displaying the application's size [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_storage_used">Storage used</string>
    <!-- Application management description for displaying the applicantion's size [CHAR_LIMIT=NONE] -->
    <string name="device_apps_app_management_storage_used_desc"><xliff:g id="size" example="30.2MB">%1$s</xliff:g> used in <xliff:g id="volume" example="internal storage">%2$s</xliff:g></string>
    <!-- Application management choice for clearing the application's data [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_clear_data">Clear data</string>
    <!-- Application management description for clearing the application's data [CHAR LIMIT=NONE] -->
    <string name="device_apps_app_management_clear_data_desc">All this app’s data will be deleted permanently.\nThis includes all files, settings, accounts, databases, etc.</string>
    <!-- Application management choice for clearing the application's default actions [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_clear_default">Clear defaults</string>
    <!-- Application management description for defaults are set for the application [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_clear_default_set">Set to launch this app for some actions</string>
    <!-- Application management description for defaults aren't set for the application [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_clear_default_none">No defaults set</string>
    <!-- Application management choice for clearing the application's cache [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_clear_cache">Clear cache</string>
    <!-- Application management choice for changing the application's notifications option [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_notifications">Notifications</string>
    <!-- Application management choice for displaying the application's permissions [CHAR LIMIT=40] -->
    <string name="device_apps_app_management_permissions">Permissions</string>
    <!-- Application management toast message when an app cannot be launched [CHAR LIMIT=100]-->
    <string name="device_apps_app_management_not_available">Application unavailable</string>
    <!-- General settings choice for agreeing to the displayed action [CHAR LIMIT=40] -->
    <string name="settings_ok">OK</string>
    <!-- General settings choice for disagreeing with the displayed action [CHAR LIMIT=40] -->
    <string name="settings_cancel">Cancel</string>
    <!-- General settings choice for on [CHAR LIMIT=40] -->
    <string name="settings_on">On</string>
    <!-- General settings choice for off [CHAR LIMIT=40] -->
    <string name="settings_off">Off</string>
    <!-- Screen saver choice for not having a screen saver [CHAR LIMIT=40] -->
    <string name="device_daydreams_none">Turn screen off</string>
    <!-- Screen saver choice for selecting a different screen saver [CHAR LIMIT=40] -->
    <string name="device_daydreams_select">Screen saver</string>
    <!-- Screen saver choice for testing the selected screen saver [CHAR LIMIT=40] -->
    <string name="device_daydreams_test">Start now</string>
    <!-- Screen saver choice for configuring the time before the device goes to sleep [CHAR LIMIT=40] -->
    <string name="device_daydreams_sleep">When to start</string>
    <!-- Screen saver description for configuring the time before the device goes to sleep [CHAR LIMIT=NONE] -->
    <string name="device_daydreams_sleep_description">Screen saver begins after this period of inactivity. If no screen saver is selected, the display turns off.</string>
    <!-- Screen saver summary for displaying the time before the device goes to sleep -->
    <string name="device_daydreams_sleep_summary">After <xliff:g id="sleep_description" example="3 minutes">%1$s</xliff:g> of inactivity</string>
    <!-- Screen saver choice for configuring the time before the device's screen goes off after dreaming [CHAR LIMIT=40] -->
    <string name="device_daydreams_screen_off">Put device to sleep</string>
    <!-- Screen saver description for configuring the time before the device's screen goes off after dreaming [CHAR LIMIT=NONE] -->
    <string name="device_daydreams_screen_off_description">Screen turns off after this period of inactivity.</string>
    <!-- Default summary text of the "Configure backup account" setting [CHAR LIMIT=80] -->
    <string name="backup_configure_account_default_summary">No account is currently storing backed up data</string>
    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_title"></string>
    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_message">Stop backing up your Wi-Fi passwords, bookmarks, other settings, and app data, and erase all copies on Google servers?</string>
    <!-- Privacy choice for configuring backing up data [CHAR LIMIT=40] -->
    <string name="privacy_backup_data">Back up my data</string>
    <!-- Privacy choice for choosing which account to backup [CHAR LIMIT=40] -->
    <string name="privacy_backup_account">Backup account</string>
    <!-- Privacy choice for configuring automatic restore [CHAR LIMIT=40] -->
    <string name="privacy_automatic_restore">Automatic restore</string>
    <!-- Factory reset choice for initiating a factory reset [CHAR LIMIT=40] -->
    <string name="factory_reset_device">Reset device</string>
    <!-- Factory reset description about what happens when you perform a factory reset [CHAR LIMIT=NONE] -->
    <string name="factory_reset_description">This will erase all data from your device\'s internal storage, including: your Google account, system and app data and settings, and downloaded apps</string>
    <!-- Factory reset screen, message on screen after user selects Reset phone button -->
    <string name="confirm_factory_reset_description">Erase all your personal information and downloaded apps? You can\'t reverse this action!</string>
    <!-- Factory reset screen, button on screen after user selects Reset phone button -->
    <string name="confirm_factory_reset_device">Erase everything</string>


    <!-- Title for screen where user selects a name for their device [CHAR LIMIT=NONE] -->
    <string name="select_device_name_title">Choose a name for your <xliff:g id="devicemodel" example="Nexus Player">%1$s</xliff:g></string>
    <!-- Description for screen where user selects a name for their device [CHAR LIMIT=NONE] -->
    <string name="select_device_name_description">Give your <xliff:g id="devicemodel" example="Nexus Player">%1$s</xliff:g> a name to help identify it when casting or connecting to it from other devices.</string>
    <!-- Rooms where a user's device might be placed [CHAR LIMIT=40] -->
    <string-array name="rooms">
        <!-- [CHAR LIMIT=40] -->
        <item>Android TV</item>
        <!-- [CHAR LIMIT=40] -->
        <item>Living Room TV</item>
        <!-- [CHAR LIMIT=40] -->
        <item>Family Room TV</item>
        <!-- [CHAR LIMIT=40] -->
        <item>Bedroom TV</item>
    </string-array>
    <!-- String displayed for option where user will type in a room name rather than selecting from the list of defaults [CHAR LIMIT=40] -->
    <string name="custom_room">Enter custom name&#8230;</string>
    <!-- Title of settings summary/status screen [CHAR LIMIT=100] -->
    <string name="device_rename_title">Rename this <xliff:g id="devicemodel" example="Nexus Player">%1$s</xliff:g></string>
    <!-- Description on summary/status screen that tells you what the name of your device is [CHAR LIMIT=NONE] -->
    <string name="device_rename_description">This <xliff:g id="devicemodel" example="Nexus Player">%1$s</xliff:g> is currently named \"<xliff:g id="devicename" example="Living Room Player">%2$s</xliff:g>\"</string>
    <!-- The 'yes' or 'edit' equivalent in a yes/no choice circumstance [CHAR LIMIT=30] -->
    <string name="change_setting">Change</string>
    <!-- The 'no' or  'keep the same' equivalent in a yes/no choice circumstance [CHAR LIMIT=30]-->
    <string name="keep_settings">Don\'t change</string>

    <!-- Group header for app permissions [CHAR LIMIT=20] -->
    <string name="apps_permissions">Permissions</string>
    <!-- Item title for app permissions [CHAR LIMIT=20] -->
    <string name="device_apps_permissions">App permissions</string>
    <!-- Summary of number of apps currently granted a single permission [CHAR LIMIT=45] -->
    <string name="app_permissions_group_summary"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> apps allowed</string>

    <!-- Strings for dialog title when asking to the user whether to allow an app to enable discovery mode -->
    <string name="bluetooth_permission_request">"Bluetooth permission request"</string>

    <!-- About phone screen, status item label  [CHAR LIMIT=60] -->
    <string name="security_patch">Android security patch level</string>

    <!-- App picker screen title -->
    <string name="choose_application">Choose application</string>

    <!-- Summary Title for saying that the preference is experimental and will evolve over time due to User feedback. [CHAR LIMIT=NONE] -->
    <string name="experimental_preference">(Experimental)</string>

    <!-- Title of button to confirm rebooting into safe mode. [CHAR LIMIT=50] -->
    <string name="reboot_safemode_action">Reboot to safe mode</string>

    <!-- Shutdown Confirmation Dialog.  Message in the confirmation dialog
         when the user asks to reboot into safe mode. [CHAR LIMIT=50] -->
    <string name="reboot_safemode_confirm">Do you want to reboot into safe mode?</string>
    <!-- Shutdown Confirmation Dialog. Detailed message in the confirmation dialog when the user asks to reboot into safe mode [CHAR LIMIT=NONE] -->
    <string name="reboot_safemode_desc">This will disable all third party applications you have installed. They will be restored when you reboot again.</string>

    <!-- Toast shown when the user triggers the capture of a bugreport [CHAR LIMIT=50] -->
    <string name="capturing_bugreport">Capturing bug report</string>

    <!-- Title for the 'available virtual keyboards' preference sub-screen. [CHAR LIMIT=50] -->
    <string name="available_virtual_keyboard_category">Available virtual keyboards</string>
    <!-- Title for the preference entry for managing keyboards [CHAR LIMIT=50] -->
    <string name="manage_keyboards">Manage keyboards</string>

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

    <!-- Title of usage access screen [CHAR LIMIT=30] -->
    <string name="usage_access">Usage access</string>
    <!-- Description of the usage access setting [CHAR LIMIT=NONE] -->
    <string name="usage_access_description">Usage access allows an app to track what other apps you\u2019re using and how often, as well as your carrier, language settings, and other details.</string>

</resources>
