<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <!-- Strings for Dialog yes button -->
    <string name="yes">"Yes"</string>
    <!-- Strings for Dialog no button -->
    <string name="no">"No"</string>
    <!-- Strings for Dialog create button -->
    <string name="create">Create</string>
    <!-- Strings for Dialog allow button -->
    <string name="allow">Allow</string>
    <!-- Strings for Dialog deny button -->
    <string name="deny">Deny</string>

    <!-- Strings for Dialog close button [CHAR LIMIT=20] -->
    <string name="dlg_close">Close</string>
    <!-- Strings for Dialog switch button [CHAR LIMIT=20] -->
    <string name="dlg_switch">Switch</string>

    <!-- Device Info --> <skip />
    <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
    <string name="device_info_default">Unknown</string>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Countdown for user taps to enable development settings -->
    <plurals name="show_dev_countdown">
        <item quantity="one">You are now <xliff:g id="step_count">%1$d</xliff:g> step away from being a developer.</item>
        <item quantity="other">You are now <xliff:g id="step_count">%1$d</xliff:g> steps away from being a developer.</item>
    </plurals>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Confirmation that developer settings are enabled -->
    <string name="show_dev_on">You are now a developer!</string>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Okay we get it, stop pressing, you already have it on -->
    <string name="show_dev_already">No need, you are already a developer.</string>

    <!-- [CHAR LIMIT=NONE] Toast message when user attemps to launch developer otions before enabling it. -->
    <string name="dev_settings_disabled_warning">Please enable developer options first.</string>

    <!-- Category headings in left-pane header menu --> <skip />
    <!-- Settings main menu category heading. Wireless and networks (Wi-Fi, Bluetooth, data usage...). [CHAR LIMIT=40] -->
    <string name="header_category_wireless_networks">Wireless &amp; networks</string>
    <!-- Settings main menu category heading. Wireless and networks (Wi-Fi, Bluetooth, data usage...). [CHAR LIMIT=40] -->
    <string name="header_category_connections">Connections</string>
    <!-- Settings main menu category heading. Device (Sound, display, battery, applications...). [CHAR LIMIT=40] -->
    <string name="header_category_device">Device</string>
    <!-- Settings main menu category heading. Personal (Accounts, security, language, backup...). [CHAR LIMIT=40] -->
    <string name="header_category_personal">Personal</string>
    <!-- Settings main menu category heading. Personal (Accounts, security, language, backup...). [CHAR LIMIT=40] -->
    <string name="header_category_access">Access</string>
    <!-- Settings main menu category heading. System (Updates, data, accessibility, about phone). [CHAR LIMIT=40] -->
    <string name="header_category_system">System</string>

    <!-- Data Connection Enable. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="radio_info_data_connection_enable">Enable Data Connection</string>
    <!-- Data Connection Disable. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="radio_info_data_connection_disable">Disable Data Connection</string>

    <!-- VoLTE provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="volte_provisioned_switch_string">VoLTE Provisioned</string>

    <!-- Video calling provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="vt_provisioned_switch_string">Video Calling Provisioned</string>

    <!-- Wifi Calling provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="wfc_provisioned_switch_string">Wifi Calling Provisioned</string>

    <!-- EAB provisioning flag on. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="eab_provisioned_switch_string">EAB/Presence Provisioned</string>

    <!-- Title for controlling on/off for Mobile phone's radio power. Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="radio_info_radio_power">Mobile Radio Power</string>

    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewADN">View SIM Address Book</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewFDN">View Fixed Dialing Numbers</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewSDN">View Service Dialing Numbers</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_getIMS">IMS Service Status</string>

    <!-- Phone Info screen. IMS Registration Title.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ims_reg_status_title">IMS Status</string>

    <!-- Phone Info screen. IMS Status - Registered.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ims_reg_status_registered">Registered</string>
    <!-- Phone Info screen. Ims Status - Unregistered.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ims_reg_status_not_registered">Not Registered</string>

    <!-- Phone Info screen. Ims Feature Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ims_feature_status_available">Available</string>
    <!-- Phone Info screen. Ims Feature status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ims_feature_status_unavailable">Unavailable</string>

    <!-- Phone Info screen. IMS Registration.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ims_reg_status">IMS Registration: <xliff:g id="status" example="registered">%1$s</xliff:g>\u000AVoice over LTE: <xliff:g id="availability" example="available">%2$s</xliff:g>\u000AVoice over WiFi: <xliff:g id="availability" example="available">%3$s</xliff:g>\u000AVideo Calling: <xliff:g id="availability" example="available">%4$s</xliff:g>\u000AUT Interface: <xliff:g id="availability" example="available">%5$s</xliff:g></string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_in">In Service</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_out">Out of Service</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_emergency">Emergency Calls Only</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_service_off">Radio Off</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_roaming_in">Roaming</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_roaming_not">Not Roaming</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_phone_idle">Idle</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_phone_ringing">Ringing</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_phone_offhook">Call in Progress</string>

    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_disconnected">Disconnected</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_connecting">Connecting</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_connected">Connected</string>
    <!-- Phone Info screen. Status label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_data_suspended">Suspended</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_unknown">Unknown</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_packets">pkts</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_bytes">bytes</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_dbm">dBm</string>
    <!-- Phone Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_display_asu">asu</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_lac">LAC</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_cid">CID</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed. Unmounts the SD card from the phone, meaning it will become available for an attached computer  [CHAR LIMIT=25] -->
    <string name="sdcard_unmount" product="nosdcard">Unmount USB storage</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed. Unmounts the SD card from the phone, meaning it will become available for an attached computer  -->
    <string name="sdcard_unmount" product="default">Unmount SD card</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed. Formats the SD card in the phone, meaning it will be erased and reformatted [CHAR LIMIT=25] -->
    <string name="sdcard_format" product="nosdcard">Erase USB storage</string>
    <!-- Used for diagnostic info screens, precise translation isn't needed. Formats the SD card in the phone, meaning it will be erased and reformatted -->
    <string name="sdcard_format" product="default">Erase SD card</string>

    <!-- Content description for preview pager. [CHAR LIMIT=NONE] -->
    <string name="preview_pager_content_description">Preview</string>
    <!-- Content description for dot pager indicator for preview pager. [CHAR LIMIT=NONE] -->
    <string name="preview_page_indicator_content_description">Preview, page <xliff:g id="current_page" example="3">%1$d</xliff:g> of <xliff:g id="num_pages" example="9">%2$d</xliff:g></string>

    <!-- Summary of font size setting screen. [CHAR LIMIT=NONE] -->
    <string name="font_size_summary">Make the text on screen smaller or larger.</string>

    <!-- Description for the button that makes interface elements smaller. [CHAR_LIMIT=NONE] -->
    <string name="font_size_make_smaller_desc">Make smaller</string>
    <!-- Description for the button that makes interface elements larger. [CHAR_LIMIT=NONE] -->
    <string name="font_size_make_larger_desc">Make larger</string>

    <!-- Sample text for font size preview. -->
    <string name="font_size_preview_text">Servez à ce monsieur une bière et des kiwis.</string>
    <string name="font_size_preview_text_headline">Sample text</string>
    <string name="font_size_preview_text_title"
            translation_description="Title text in sample text used to illustrate how the currently selected font size will appear to the user. NOTE: Translate manually. No not adopt any copyrighted material for translation.">
        The Wonderful Wizard of Oz
    </string>
    <string name="font_size_preview_text_subtitle"
            translation_description="Subtitle text in sample text used to illustrate how the currently selected font size will appear to the user. NOTE: Translate manually. No not adopt any copyrighted material for translation.">
        Chapter 11: The Wonderful Emerald City of Oz</string>
    <string name="font_size_preview_text_body"
            translation_description="Text in sample text used to illustrate how the currently selected font size will appear to the user. NOTE: Translate manually. No not adopt any copyrighted material for translation.">
        Even with eyes protected by the green spectacles Dorothy and her friends were at first dazzled by the brilliancy of the wonderful City.
        The streets were lined with beautiful houses all built of green marble and studded everywhere with sparkling emeralds.
        They walked over a pavement of the same green marble, and where the blocks were joined together were rows of emeralds, set closely, and glittering in the brightness of the sun.
        The window panes were of green glass; even the sky above the City had a green tint, and the rays of the sun were green.
        \n\nThere were many people, men, women and children, walking about, and these were all dressed in green clothes and had greenish skins.
        They looked at Dorothy and her strangely assorted company with wondering eyes, and the children all ran away and hid behind their mothers when they saw the Lion; but no one spoke to them.
        Many shops stood in the street, and Dorothy saw that everything in them was green.
        Green candy and green pop-corn were offered for sale, as well as green shoes, green hats and green clothes of all sorts.
        At one place a man was selling green lemonade, and when the children bought it Dorothy could see that they paid for it with green pennies.
        \n\nThere seemed to be no horses nor animals of any kind; the men carried things around in little green carts, which they pushed before them.
        Everyone seeemed happy and contented and prosperous.
    </string>
    <!-- Button. Chosen when they want to save the chosen text size. -->
    <string name="font_size_save">OK</string>

    <!-- Title for a notification shown. [CHAR LIMIT=25] -->
    <string name="sdcard_setting" product="nosdcard">USB storage</string>
    <!-- Title for a notification shown. -->
    <string name="sdcard_setting" product="default">SD card</string>

    <!-- Used as setting title (for checkbox) on second screen after selecting Bluetooth settings -->
    <string name="bluetooth">Bluetooth</string>
    <!-- Bluetooth settings screen, summary after selecting Discoverable check box [CHAR LIMIT=50] -->
    <string name="bluetooth_is_discoverable">Visible to all nearby Bluetooth devices (<xliff:g id="discoverable_time_period">%1$s</xliff:g>)</string>
    <!-- Bluetooth settings screen, summary when Discoverable duration is set to "forever" [CHAR LIMIT=50] -->
    <string name="bluetooth_is_discoverable_always">Visible to all nearby Bluetooth devices</string>
    <!-- Bluetooth settings screen, summary text when not discoverable and no paired devices [CHAR LIMIT=50] -->
    <string name="bluetooth_not_visible_to_other_devices">Not visible to other Bluetooth devices</string>
    <!-- Bluetooth settings screen, summary text when not discoverable with paired devices [CHAR LIMIT=50] -->
    <string name="bluetooth_only_visible_to_paired_devices">Only visible to paired devices</string>
    <!-- Bluetooth settings screen, option name to pick discoverability timeout duration (a list dialog comes up) -->
    <string name="bluetooth_visibility_timeout">Visibility timeout</string>
    <!-- Bluetooth settings screen, check box label whether or not to allow
        bluetooth voice dialing when lock screen is up-->
    <string name="bluetooth_lock_voice_dialing">Lock voice dialing</string>
    <!-- Bluetooth settings screen, lock voice dialing checkbox summary text -->
    <string name="bluetooth_lock_voice_dialing_summary">
      Prevent use of the bluetooth dialer when the screen is locked
    </string>
    <!-- Bluetooth settings screen, heading above the list of nearby bluetooth devices -->
    <string name="bluetooth_devices">Bluetooth devices</string>
    <!-- Bluetooth settings screen, title for the current bluetooth name setting -->
    <string name="bluetooth_device_name">Device name</string>
    <!-- Bluetooth settings screen, image description for device details button. This opens the screen to rename, unpair, etc. a single device. -->
    <string name="bluetooth_device_details">Device settings</string>
    <!-- Bluetooth settings screen, image description for profile of a device details button. -->
    <string name="bluetooth_profile_details">Profile settings</string>
    <!-- Bluetooth settings screen, summary text when there isn't a name set (for the name setting) -->
    <string name="bluetooth_name_not_set">No name set, using account name</string>
    <!-- Bluetooth settings screen, menu item to scan for nearby bluetooth devices -->
    <string name="bluetooth_scan_for_devices">Scan for devices</string>
    <!-- Bluetooth settings screen, menu item to change this device's Bluetooth name. [CHAR LIMIT=30] -->
    <string name="bluetooth_rename_device">Rename this device</string>
    <!-- Bluetooth settings screen, confirmation button for rename device dialog. [CHAR LIMIT=20] -->
    <string name="bluetooth_rename_button">Rename</string>
    <!-- Bluetooth settings.  Dialog title to confirm disconnecting from all profiles of a device. [CHAR LIMIT=30] -->
    <string name="bluetooth_disconnect_title">Disconnect device?</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles" product="default">Your phone will disconnect from "<xliff:g id="device_name">%1$s</xliff:g>."</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles" product="tablet">Your tablet will disconnect from "<xliff:g id="device_name">%1$s</xliff:g>."</string>
    <!-- Bluetooth settings.  Message for disconnecting from all profiles of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disconnect_all_profiles" product="device">Your device will disconnect from "<xliff:g id="device_name">%1$s</xliff:g>."</string>
    <!-- dialog ok button for disconnect dialog [CHAR LIMIT=20] -->
    <string name="bluetooth_disconnect_dialog_ok">Disconnect</string>
    <!-- Bluetooth Settings. text displayed when user has restriction DISALLOW_CONFIG_BLUETOOTH [CHAR LIMIT=NONE]-->
    <string name="bluetooth_empty_list_user_restricted">You don\u2019t have permission to change Bluetooth settings.</string>
    <!-- Title for bluetooth pairing item [CHAR LIMIT=60] -->
    <string name="bluetooth_pairing_pref_title">Pair new device</string>

    <!-- Bluetooth Visibility message.  This message informs the user that their device is now visible to other bluetooth devices.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_is_visible_message"><xliff:g id="device_name">%1$s</xliff:g> is visible to nearby devices while Bluetooth settings is open.</string>
    <!-- Bluetooth mac address message.  This message shows the bluetooth mac address for this device.  [CHAR LIMIT=120] -->
    <string name="bluetooth_footer_mac_message" product="default">Phone\'s Bluetooth address: <xliff:g id="bluetooth_mac_address">%1$s</xliff:g></string>
    <!-- Bluetooth mac address message.  This message shows the bluetooth mac address for this device.  [CHAR LIMIT=120] -->
    <string name="bluetooth_footer_mac_message" product="tablet">Tablet\'s Bluetooth address: <xliff:g id="bluetooth_mac_address">%1$s</xliff:g></string>
    <!-- Bluetooth mac address message.  This message shows the bluetooth mac address for this device.  [CHAR LIMIT=120] -->
    <string name="bluetooth_footer_mac_message" product="device">Device\'s Bluetooth address: <xliff:g id="bluetooth_mac_address">%1$s</xliff:g></string>

    <!-- Bluetooth Visibility disconnect question.  Asks the user if they wish to disconnect a paired bluetooth device.  [CHAR LIMIT=50] -->
    <string name="bluetooth_is_disconnect_question">Disconnect <xliff:g id="device_name">%1$s</xliff:g>?</string>
    <!-- Bluetooth broadcasting settings, option to enable/disable broadcasting -->
    <string name="bluetooth_broadcasting">Broadcasting</string>
    <!-- Bluetooth settings.  Dialog title to disable a single profile of a device. [CHAR LIMIT=40] -->
    <string name="bluetooth_disable_profile_title">Disable profile?</string>
    <!-- Bluetooth settings.  Message for disabling a profile of a bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_disable_profile_message">This will disable:&lt;br>&lt;b><xliff:g id="profile_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>From:&lt;br>&lt;b><xliff:g id="device_name">%2$s</xliff:g>&lt;/b></string>

    <!-- Bluetooth settings.  Message when the device state is unknown -->
    <string name="bluetooth_unknown" />
    <!--Bluetooth settings screen, summary text for Bluetooth device with no name -->
    <string name="bluetooth_device">Unnamed Bluetooth device</string>
    <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices -->
    <string name="progress_scanning">Searching</string>
    <!--Bluetooth settings screen, text that appears when scanning for devices is finished and no nearby bluetooth device was found [CHAR LIMIT=40]-->
    <string name="bluetooth_no_devices_found">No nearby Bluetooth devices were found.</string>
    <!-- Notification ticker text (shown in the status bar) when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_ticker">Bluetooth pairing request</string>
    <!-- Notification title when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_title">Pairing request</string>
    <!-- Notification message when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_message">Tap to pair with <xliff:g id="device_name">%1$s</xliff:g>.</string>
    <!-- Item in bluetooth settings screen, used to show the list of received files [CHAR LIMIT=30] -->
    <string name="bluetooth_show_received_files">Received files</string>

    <!-- Strings for BluetoothDevicePicker [CHAR LIMIT=40]-->
    <string name="device_picker">Choose Bluetooth device</string>

    <!-- This string asks the user whether or not to allow an app to enable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_enablement"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth</string>
    <!-- This string asks the user whether or not to allow an app to disable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_disablement"><xliff:g id="app_name">%1$s</xliff:g> wants to turn off Bluetooth</string>

    <!-- This string asks the user whether or not to allow an app to enable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_enablement_no_name">An app wants to turn on Bluetooth</string>
    <!-- This string asks the user whether or not to allow an app to disable bluetooth. [CHAR LIMIT=100] -->
    <string name="bluetooth_ask_disablement_no_name">An app wants to turn off Bluetooth</string>

    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to make your tablet visible to other Bluetooth devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>
    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to make your phone visible to other Bluetooth devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>

    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery_no_name" product="tablet">An app wants to make your tablet visible to other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</string>
    <!-- Strings for asking to the user whether to allow an app to enable discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_discovery_no_name" product="default">An app wants to make your phone visible to other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</string>

    <!-- Strings for asking to the user whether to allow an app to enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to make your tablet visible to other Bluetooth devices. You can change this later in Bluetooth settings.</string>
    <!-- Strings for asking to the user whether to allow an app to enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to make your phone visible to other Bluetooth devices. You can change this later in Bluetooth settings.</string>

    <!-- Strings for asking to the user whether to allow an app to enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet">An app wants to make your tablet visible to other Bluetooth devices. You can change this later in Bluetooth settings.</string>
    <!-- Strings for asking to the user whether to allow an app to enable lasting discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default">An app wants to make your phone visible to other Bluetooth devices. You can change this later in Bluetooth settings.</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your tablet visible to other devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your phone visible to other devices for <xliff:g id="timeout">%2$d</xliff:g> seconds.</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet">An app wants to turn on Bluetooth and make your tablet visible to other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default">An app wants to turn on Bluetooth and make your phone visible to other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds.</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your tablet visible to other devices. You can change this later in Bluetooth settings.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default"><xliff:g id="app_name">%1$s</xliff:g> wants to turn on Bluetooth and make your phone visible to other devices. You can change this later in Bluetooth settings.</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet">An app wants to turn on Bluetooth and make your tablet visible to other devices. You can change this later in Bluetooth settings.</string>
    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default">An app wants to turn on Bluetooth and make your phone visible to other devices. You can change this later in Bluetooth settings.</string>

    <!-- Strings for msg to display to user while bluetooth is turning on [CHAR LIMIT=60] -->
    <string name="bluetooth_turning_on">"Turning Bluetooth on\u2026"</string>

    <!-- Strings for msg to display to user while bluetooth is turning off [CHAR LIMIT=60] -->
    <string name="bluetooth_turning_off">"Turning Bluetooth off\u2026"</string>

    <!-- Strings for device profile auto connect setting -->
    <string name="bluetooth_auto_connect">Auto-connect</string>

    <!-- Activity label of BluetoothPermissionActivity [CHAR LIMIT=none]-->
    <string name="bluetooth_connection_permission_request">"Bluetooth connection request"</string>

    <!-- Notification message when a remote Bluetooth device wants to connect to a Bluetooth profile [CHAR LIMIT=none]-->
    <string name="bluetooth_connection_notif_message">"Tap to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022."</string>

    <!-- Bluetooth connection permission Alert Activity text [CHAR LIMIT=none]-->
    <string name="bluetooth_connection_dialog_text">"Do you want to connect to \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022?"</string>

    <!-- Activity label of BluetoothPbPermissionActivity, also used as Strings in the permission dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_phonebook_request">"Phone book access request"</string>

    <!-- Bluetooth phone book permission Alert Activity text [CHAR LIMIT=none] -->
    <string name="bluetooth_pb_acceptance_dialog_text">
        <xliff:g id="device_name">%1$s</xliff:g> wants to access your contacts and call history. Give access to <xliff:g id="device_name">%2$s</xliff:g>?
    </string>

    <!-- Bluetooth phone book permission Alert Activity checkbox text [CHAR LIMIT=none] -->
    <string name="bluetooth_remember_choice">Don\u2019t ask again</string>
    <!--FIXME SHOULD BE REMOVED AND ALL LANG VERSIONS FIXED TO ABOVE NAME -->
    <string name="bluetooth_pb_remember_choice">Don\u2019t ask again</string>

    <!-- Activity label of BluetoothMessagePermissionActivity, also used as Strings in the permission dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_map_request">"Message access request"</string>

    <!-- Bluetooth message permission Alert Activity text [CHAR LIMIT=none] -->
    <string name="bluetooth_map_acceptance_dialog_text">%1$s wants to access your messages. Give access to %2$s?</string>

    <!-- Activity label of BluetoothMessagePermissionActivity for SIM access profile. Also used as Strings in the permission dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_sap_request">"SIM access request"</string>

    <!-- Bluetooth SIM access permission Alert Activity text [CHAR LIMIT=none] -->
    <string name="bluetooth_sap_acceptance_dialog_text"><xliff:g id="device_name">%1$s</xliff:g> wants to access your SIM card. Granting access to the SIM card will disable data connectivity on your device for the duration of the connection. Give access to <xliff:g id="device_name">%2$s?</xliff:g></string>

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

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

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

    <!-- Title for Bluetooth device group with media capability group [CHAR LIMIT=none]-->
    <string name="connected_device_available_media_title">Available media devices</string>
    <!-- Title for Bluetooth device group with media capability group [CHAR LIMIT=none]-->
    <string name="connected_device_available_call_title">Available call devices</string>
    <!-- Title for connected device group [CHAR LIMIT=none]-->
    <string name="connected_device_connected_title">Currently connected</string>
    <!-- Title for connected device group [CHAR LIMIT=none]-->
    <string name="connected_device_saved_title">Saved devices</string>
    <!-- Title for preference to add a device [CHAR LIMIT=none] [BACKUP_MESSAGE_ID=7803521577708810621] -->
    <string name="connected_device_add_device_title">Add device</string>
    <!-- Summary for preference to add a device [CHAR LIMIT=none]-->
    <string name="connected_device_add_device_summary">Bluetooth will turn on to pair</string>
    <!-- Title for other connection preferences [CHAR LIMIT=none]-->
    <string name="connected_device_connections_title">Connection preferences</string>
    <!-- Title for Bluetooth preference to open paired but no connection list [CHAR LIMIT=none]-->
    <string name="connected_device_previously_connected_title">Previously connected devices</string>

    <!-- Date & time settings screen title -->
    <string name="date_and_time">Date &amp; time</string>
    <!-- The title of the activity to pick a time zone. -->
    <string name="choose_timezone">Choose time zone</string>

    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_data_label"><xliff:g id="data">Data:</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_sendbroadcast_text">Send <xliff:g id="broadcast">broadcast</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_action_label"><xliff:g id="action">Action</xliff:g>:</string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_startactivity_text">Start <xliff:g id="activity">activity</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_resource_label"><xliff:g id="resource">Resource</xliff:g>: </string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_account_label">Account: </string>

    <!-- HTTP proxy settings title -->
    <string name="proxy_settings_title">Proxy</string>
    <!-- HTTP proxy settings. Button to clear the proxy box. -->
    <string name="proxy_clear_text">Clear</string>
    <!-- HTTP proxy settings. The port number label. -->
    <string name="proxy_port_label">Proxy port</string>
    <!-- HTTP proxy settings. The exclusion list label. -->
    <string name="proxy_exclusionlist_label">Bypass proxy for</string>
    <!-- HTTP proxy settings. The button to restore the defaults. -->
    <string name="proxy_defaultView_text">Restore defaults</string>
    <!-- HTTP proxy settings. The button to save. -->
    <string name="proxy_action_text">Done</string>
    <!-- HTTP proxy settings. The text field for the hostname -->
    <string name="proxy_hostname_label">Proxy hostname</string>
    <!-- HTTP proxy settings. Title if there is an error-->
    <string name="proxy_error">Attention</string>
    <!-- HTTP proxy settings. Button to get rid of error box-->
    <string name="proxy_error_dismiss">OK</string>
    <!-- HTTP proxy settings. The error if the hostname is not valid -->
    <string name="proxy_error_invalid_host">The hostname you typed isn\u2019t valid.</string>
    <!-- HTTP proxy settings. The error if the exclusion list is not valid -->
    <string name="proxy_error_invalid_exclusion_list">The exclusion list you typed isn\u2019t properly formatted. Type a comma-separated list of excluded domains.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_port">You need to complete the port field.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_host_set_port">The port field must be empty if the host field is empty.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_invalid_port">The port you typed isn\u2019t valid.</string>
    <!-- HTTP proxy settings. Warning message about limited application support [CHAR LIMIT=100]-->
    <string name="proxy_warning_limited_support">The HTTP proxy is used by the browser but may not be used by the other apps.</string>

    <!-- HTTP proxy settings. Title for Proxy-Auto Config URL.  [CHAR LIMIT=25] -->
    <string name="proxy_url_title">"PAC URL: "</string>

    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_dl_kbps">DL Bandwidth (kbps):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ul_kbps">UL Bandwidth (kbps):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_location_label">Cell Location Info (deprecated):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_neighboring_location_label">Neighbor Cell Info (deprecated):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_phy_chan_config">LTE Physical Channel Configuration:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_cell_info_refresh_rate">Cell Info Refresh Rate:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_cellinfo_label">All Cell Measurement Info:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_dcrtinfo_label">Data Connection Real-Time Info:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gprs_service_label">Data Service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_roaming_label">Roaming:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_imei_label">IMEI:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, DO NOT TRANSLATE. -->
    <string name="radio_info_imsi_label">IMSI:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_redirect_label">Call Redirect:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_resets_label">Number of PPP Reset Since Boot:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_current_network_label">Current Network:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_received_label">Data Received:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gsm_service_label">Voice Service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_strength_label">Signal Strength:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_status_label">Voice Call Status:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_sent_label">Data Sent:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_message_waiting_label">Message Waiting:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_phone_number_label">Phone Number:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_band_mode_label">Select Radio Band</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_voice_network_type_label">Voice Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_network_type_label">Data Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_set_perferred_label">Set Preferred Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_hostname_v4">Ping Hostname(www.google.com) IPv4:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_hostname_v6">Ping Hostname(www.google.com) IPv6:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_http_client_test">HTTP Client Test:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="ping_test_label">Run Ping Test</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_label">SMSC:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_update_label">Update</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_refresh_label">Refresh</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_toggle_dns_check_label">Toggle DNS Check</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="oem_radio_info_label">OEM-specific Info/Settings</string>

    <!-- Band Mode Selection -->
    <!-- Band mode screen.  Title of activity. -->
    <string name="band_mode_title">Set Radio Band Mode</string>
    <!-- Band mode screen.  Loading message. -->
    <string name="band_mode_loading">Loading Band List\u2026</string>
    <!-- Band mode screen. Button caption to set the bandmode. -->
    <string name="band_mode_set">Set</string>
    <!-- Band mode screen. Status message when unsuccessful. -->
    <string name="band_mode_failed">Unsuccessful</string>
    <!-- Band mode screen. Statusm essage when successful. -->
    <string name="band_mode_succeeded">Successful</string>

    <!-- Instructions after the user changes the mass storage settings -->
    <string name="sdcard_changes_instructions">Changes take effect when USB cable is reconnected.</string>
    <!-- Enable USB mass storage mode checkbox title -->
    <string name="sdcard_settings_screen_mass_storage_text">Enable USB mass storage</string>
    <!-- The label for total bytes on SD card -->
    <string name="sdcard_settings_total_bytes_label">Total bytes:</string>
    <!-- Message when there is no SD card present [CHAR LIMIT=30] -->
    <string name="sdcard_settings_not_present_status" product="nosdcard">USB storage not mounted.</string>
    <!-- Message when there is no SD card present -->
    <string name="sdcard_settings_not_present_status" product="default">No SD card.</string>
    <!-- Th label for the available (free) sapce on the SD card -->
    <string name="sdcard_settings_available_bytes_label">Available bytes:</string>
    <!-- Message when the SD card is being used by the computer as mass storage [CHAR LIMIT=30] -->
    <string name="sdcard_settings_mass_storage_status" product="nosdcard">USB storage is being used as a mass storage device.</string>
    <!-- Message when the SD card is being used by the computer as mass storage -->
    <string name="sdcard_settings_mass_storage_status" product="default">SD card is being used as a mass storage device.</string>
    <!-- Message when it is safe to remove the SD card [CHAR LIMIT=30] -->
    <string name="sdcard_settings_unmounted_status" product="nosdcard">It\u2019s now safe to remove the USB storage.</string>
    <!-- Message when it is safe to remove the SD card -->
    <string name="sdcard_settings_unmounted_status" product="default">It\u2019s now safe to remove the SD card.</string>
    <!-- Error message when the SD card was removed without properly unmounting [CHAR LIMIT=30] -->
    <string name="sdcard_settings_bad_removal_status" product="nosdcard">USB storage was removed while still in use!</string>
    <!-- Error message when the SD card was removed without properly unmounting -->
    <string name="sdcard_settings_bad_removal_status" product="default">SD card was removed while still in use!</string>
    <!-- Label for used bytes on the SD card -->
    <string name="sdcard_settings_used_bytes_label">Used bytes:</string>
    <!-- Message when it is scanning the SD card for new files [CHAR LIMIT=30]  -->
    <string name="sdcard_settings_scanning_status" product="nosdcard">Scanning USB storage for media\u2026</string>
    <!-- Message when it is scanning the SD card for new files -->
    <string name="sdcard_settings_scanning_status" product="default">Scanning SD card for media\u2026</string>
    <!-- Message when the SD card is mounted as read only [CHAR LIMIT=30] -->
    <string name="sdcard_settings_read_only_status" product="nosdcard">USB storage mounted read-only.</string>
    <!-- Message when the SD card is mounted as read only -->
    <string name="sdcard_settings_read_only_status" product="default">SD card mounted read-only.</string>
    <!-- Used in setup wizard Wi-Fi screen.  The button label for going to the next screen without submitting. [CHAR LIMIT=20] -->
    <string name="skip_label">Skip</string>
    <!-- Used in setup wizard Wi-Fi screen. The button label for going to the next screen and submitting. [CHAR LIMIT=20] -->
    <string name="next_label">Next</string>

    <!-- LocalePicker -->
    <!-- Title for the locale picker activity -->
    <string name="language_picker_title">Languages</string>

    <!-- Title for the language selection screen [CHAR LIMIT=25] -->
    <string name="pref_title_lang_selection">Language preferences</string>

    <!-- Menu item in the locale menu. Will remove the selected locales. [CHAR LIMIT=30] -->
    <string name="locale_remove_menu">Remove</string>

    <!-- "Button" that opens a language picker. The selected language gets added to the language list. [CHAR LIMIT=30] -->
    <string name="add_a_language">Add a language</string>

    <!-- The title of the confirmation dialog shown when the user selects one / several languages and tries to remove them [CHAR LIMIT=60] -->
    <plurals name="dlg_remove_locales_title">
        <item quantity="one">Remove selected language?</item>
        <item quantity="other">Remove selected languages?</item>
    </plurals>

    <!-- The text of the confirmation dialog shown when the user selects several languages and tries to remove them [CHAR LIMIT=NONE] -->
    <string name="dlg_remove_locales_message">Text will be displayed in another language.</string>

    <!-- The title of the error dialog shown when the user selects all the languages and tries to remove them [CHAR LIMIT=60] -->
    <string name="dlg_remove_locales_error_title">Can’t remove all languages</string>
    <!-- The text of the error dialog shown when the user selects all the languages and tries to remove them [CHAR LIMIT=NONE] -->
    <string name="dlg_remove_locales_error_message">Keep at least one preferred language</string>

    <!-- This text shows in the language picker when the system is not translated into that languages [CHAR LIMIT=80] -->
    <string name="locale_not_translated">May not be available in some apps</string>

    <!-- Label for an accessibility action that moves a language up in the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_up">Move up</string>
    <!-- Label for an accessibility action that moves a language down in the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_down">Move down</string>
    <!-- Label for an accessibility action that moves a language to the top of the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_top">Move to top</string>
    <!-- Label for an accessibility action that moves a language to the bottom of the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_move_bottom">Move to bottom</string>
    <!-- Label for an accessibility action that removes the currently selected language from the the ordered language list [CHAR LIMIT=20] -->
    <string name="action_drag_label_remove">Remove language</string>

    <!-- The title of the dialog to pick an activity.  This is shown when there are multiple activities that can do a particular action.  For example, suppose you click on the "Share" menu item in the Browser.  Since you can share the webpage URL via many communication methods, this dialog would come up with choices like "Email", "IM", etc.  This is a generic message, and the previous example is a single possible scenario (so please don't assume it's for the browser or anything :) ). -->
    <string name="activity_picker_label">Choose activity</string>
    <!-- Do not translate. -->
    <string name="debug_intent_sender_label">Debug intent sender</string>
    <!-- The title of the activity to see random device info. -->
    <string name="device_info_label">Device info</string>
    <!-- The title of the activity to adjust display settings -->
    <string name="display_label">Screen</string>
    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label" product="tablet">Tablet info</string>
    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label" product="default">Phone info</string>
    <!-- The title of the activity to adjust SD card settings [CHAR LIMIT=25] -->
    <string name="sd_card_settings_label" product="nosdcard">USB storage</string>
    <!-- The title of the activity to adjust SD card settings-->
    <string name="sd_card_settings_label" product="default">SD card</string>
    <!-- The title of the activity to adjust proxy settings -->
    <string name="proxy_settings_label">Proxy settings</string>

    <!-- ======================================================================================= -->
    <!-- NEW STUFF -->
    <!-- ======================================================================================= -->

    <!-- Button label for generic cancel action [CHAR LIMIT=20] -->
    <string name="cancel">Cancel</string>
    <!-- Button label for generic OK action [CHAR LIMIT=20] -->
    <string name="okay">OK</string>
    <!-- Button label for generic forget action [CHAR LIMIT=20] -->
    <string name="forget">Forget</string>
    <!-- Button label for generic save action [CHAR LIMIT=20] -->
    <string name="save">Save</string>
    <!-- Button label for generic done action [CHAR LIMIT=20] -->
    <string name="done">Done</string>
    <!-- Button label for generic apply action [CHAR LIMIT=20] -->
    <string name="apply">Apply</string>

    <!-- Title of the Settings activity shown within the application itself. -->
    <string name="settings_label">Settings</string>
    <!-- Title of the Settings activity shown in the Launcher. [CHAR LIMIT=20] -->
    <string name="settings_label_launcher">Settings</string>
    <!-- Label for option to select a settings panel as a shortcut -->
    <string name="settings_shortcut">Settings shortcut</string>
    <!-- Shown in create shortcut activity when there is no shortcut that can be created. [CHAR_LIMIT=None] -->
    <string name="activity_list_empty">No matching activities found.</string>
    <!-- Wireless controls settings screen, setting check box label -->
    <string name="airplane_mode">Airplane mode</string>
    <!-- Main Settings screen settings title for things like airplane mode, tethering, NFC, VPN.  This will take you to another screen with those settings.  [CHAR LIMIT=30] -->
    <string name="radio_controls_title">More</string>
    <!-- Wireless Settings screen title for things like Wi-Fi, bluetooth, airplane mode. -->
    <string name="wireless_networks_settings_title">Wireless &amp; networks</string>
    <!-- Main Settings screen settings summary text for the "Wireless controls" setting -->
    <string name="radio_controls_summary">Manage Wi\u2011Fi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</string>

    <!-- check box cellular data title [CHAR LIMIT=30] -->
    <string name="cellular_data_title">Mobile data</string>
    <!-- check box Calls title [CHAR LIMIT=30] -->
    <string name="calls_title">Calls</string>
    <!-- check box SMS Messges title [CHAR LIMIT=30] -->
    <string name="sms_messages_title">SMS messages</string>
    <!-- check box cellular data summary [CHAR LIMIT=85] -->
    <string name="cellular_data_summary">Allow data usage over mobile network</string>
    <!-- check box to allow data usage when roaming [CHAR LIMIT=41] -->
    <string name="allow_data_usage_title">Allow data usage when roaming</string>
    <!-- mobile network settings screen, setting check box title -->
    <string name="roaming">Data roaming</string>
    <!-- mobile network settings screen, setting option summary text when check box is selected -->
    <string name="roaming_enable">Connect to data services when roaming</string>
    <!-- mobile network settings screen, setting option summary text when check box is clear -->
    <string name="roaming_disable">Connect to data services when roaming</string>
    <!-- mobile network settings screen, dialog message when you are roaming and clear the "Data roaming" check box -->
    <string name="roaming_reenable_message">You have lost data connectivity because you left your home network with data roaming turned off.</string>
    <!-- mobile network settings screen, button on dialog box that appears when you are roaming and clear the "Data roaming" check box -->
    <string name="roaming_turn_it_on_button">Turn it on</string>
    <!-- mobile network settings screen, message in dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_warning">You may incur significant charges.</string>
    <!-- mobile network settings screen, message in dialog box that appears when you select the "Data roaming" check box. This is for multiuser tablets [CHAR LIMIT=none] -->
    <string name="roaming_warning_multiuser" product="tablet">When you allow data roaming, you may incur significant roaming charges!\n\nThis setting affects all users on this tablet.</string>
    <!-- mobile network settings screen, message in dialog box that appears when you select the "Data roaming" check box. This is for multiuser phones [CHAR LIMIT=none] -->
    <string name="roaming_warning_multiuser" product="default">When you allow data roaming, you may incur significant roaming charges!\n\nThis setting affects all users on this phone.</string>
    <!-- mobile network settings screen, title of dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_reenable_title">Allow data roaming?</string>
    <!-- mobile network settings screen, setting option name -->
    <string name="networks">Operator selection</string>
    <!-- mobile network settings screen, setting option summary text -->
    <string name="sum_carrier_select">Choose a network operator</string>

    <!-- Date and time settings --><skip />
    <!-- Main Settings screen setting option name to go into the date and time settings-->
    <string name="date_and_time_settings_title">Date &amp; time</string>
    <!-- Title for Date & Time settings screen in SetupWizard [CHAR LIMIT=40] -->
    <string name="date_and_time_settings_title_setup_wizard">Set date and time</string>
    <!-- Main Settings screen setting option summary text for the item to go into the date and time settings. -->
    <string name="date_and_time_settings_summary">Set date, time, time zone, &amp; formats</string>
    <!-- Date & time setting screen setting check box title if the date and time should be determined automatically [CHAR LIMIT=30] -->
    <string name="date_time_auto">Automatic date &amp; time</string>
    <!-- Date & time setting screen setting option summary text when Automatic check box is selected
        (that is, when date and time should be determined automatically) [CHAR LIMIT=100] -->
    <string name="date_time_auto_summaryOn">Use network-provided time</string>
    <!-- Date & time setting screen setting option summary text when Automatic check box is clear
        [CHAR LIMIT=100] -->
    <string name="date_time_auto_summaryOff">Use network-provided time</string>
    <!-- Date & time setting screen setting check box title if the time zone should be determined automatically [CHAR LIMIT=30] -->
    <string name="zone_auto">Automatic time zone</string>
    <!-- Date & time setting screen setting option summary text when Automatic time zone check box is selected (that is, when date and time should be determined automatically)
        [CHAR LIMIT=100]  -->
    <string name="zone_auto_summaryOn">Use network-provided time zone</string>
    <!-- Date & time setting screen setting option summary text when Automatic time zone check box is clear
        [CHAR LIMIT=100] -->
    <string name="zone_auto_summaryOff">Use network-provided time zone</string>
    <!-- Date & time setting screen setting check box title if the 24 hour setting should be determined automatically [CHAR LIMIT=30] -->
    <string name="date_time_24hour_auto">Automatic 24\u2011hour format</string>
    <!-- Date & time setting screen setting option summary text for the automatic 24 hour setting checkbox [CHAR LIMIT=100] -->
    <string name="date_time_24hour_auto_summary">Use locale default</string>
    <!-- Date & time setting screen setting check box title [CHAR LIMIT=30] -->
    <string name="date_time_24hour_title">24\u2011hour format</string>
    <!-- Date & time setting screen setting check box title -->
    <string name="date_time_24hour">Use 24-hour format</string>
    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
    <string name="date_time_set_time_title">Time</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_time">Set time</string>
    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
    <string name="date_time_set_timezone_title">Time zone</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_timezone">Select time zone</string>
    <!-- Date & time setting screen setting option title [CHAR LIMIT=30] -->
    <string name="date_time_set_date_title">Date</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_date">Set date</string>
    <!-- Text hint to search region in time zone setting screen -->
    <string name="date_time_search_region">Search region</string>
    <!-- Setting option title to select region in time zone setting screen [CHAR LIMIT=30] -->
    <string name="date_time_select_region">Region</string>
    <!-- Setting option title to select time zone in time zone setting screen [CHAR LIMIT=30]-->
    <string name="date_time_select_zone">Time Zone</string>
    <!-- Setting option title to select time zone in a region -->
    <string name="date_time_set_timezone_in_region">Time zones in <xliff:g id="region" example="United States">%1$s</xliff:g></string>
    <!-- Setting option title in time zone setting screen [CHAR LIMIT=30] -->
    <string name="date_time_select_fixed_offset_time_zones">Select UTC offset</string>
    <!-- Menu item on Select time zone screen -->
    <string name="zone_list_menu_sort_alphabetically">Sort alphabetically</string>
    <!-- Menu item on Select time zone screen -->
    <string name="zone_list_menu_sort_by_timezone">Sort by time zone</string>
    <!-- Label describing when a given time zone changes to DST or standard time -->
    <string name="zone_change_to_from_dst"><xliff:g id="time_type" example="Pacific Summer Time">%1$s</xliff:g> starts on <xliff:g id="transition_date" example="Mar 11 2018">%2$s</xliff:g>.</string>
    <!-- Label describing a exemplar location and time zone offset[CHAR LIMIT=NONE] -->
    <string name="zone_info_exemplar_location_and_offset"><xliff:g id="exemplar_location" example="Los Angeles">%1$s</xliff:g> (<xliff:g id="offset" example="GMT-08:00">%2$s</xliff:g>)</string>
    <!-- Label describing a time zone offset and name[CHAR LIMIT=NONE] -->
    <string name="zone_info_offset_and_name"><xliff:g id="time_type" example="Pacific Time">%2$s</xliff:g> (<xliff:g id="offset" example="GMT-08:00">%1$s</xliff:g>)</string>
    <!-- Label describing a time zone and changes to DST or standard time [CHAR LIMIT=NONE] -->
    <string name="zone_info_footer">Uses <xliff:g id="offset_and_name" example="Pacific Time (GMT-08:00)">%1$s</xliff:g>. <xliff:g id="dst_time_type" example="Pacific Daylight Time">%2$s</xliff:g> starts on <xliff:g id="transition_date" example="Mar 11 2018">%3$s</xliff:g>.</string>
    <!-- Label describing a time zone without DST [CHAR LIMIT=NONE] -->
    <string name="zone_info_footer_no_dst">Uses <xliff:g id="offset_and_name" example="GMT-08:00 Pacific Time">%1$s</xliff:g>. No daylight savings time.</string>
    <!-- Describes the time type "daylight savings time" (used in zone_change_to_from_dst, when no zone specific name is available) -->
    <string name="zone_time_type_dst">Daylight savings time</string>
    <!-- Describes the time type "standard time" (used in zone_change_to_from_dst, when no zone specific name is available) -->
    <string name="zone_time_type_standard">Standard time</string>
    <!-- The menu item to switch to selecting a time zone by region (default) [CHAR LIMIT=30] -->
    <string name="zone_menu_by_region">Select by region</string>
    <!-- The menu item to switch to selecting a time zone with a fixed offset (such as UTC or GMT+0200) [CHAR LIMIT=30] -->
    <string name="zone_menu_by_offset">Select by UTC offset</string>

    <!-- Title string shown above DatePicker, letting a user select system date
         [CHAR LIMIT=20] -->
    <string name="date_picker_title">Date</string>
    <!-- Title string shown above TimePicker, letting a user select system time
         [CHAR LIMIT=20] -->
    <string name="time_picker_title">Time</string>

    <!-- Security Settings --><skip />

    <!-- Security settings screen, setting option name to change screen timeout -->
    <string name="lock_after_timeout">Automatically lock</string>
    <!-- Security settings screen, setting option summary to change screen timeout -->
    <string name="lock_after_timeout_summary"><xliff:g id="timeout_string">%1$s</xliff:g> after sleep</string>
    <!-- Security settings screen, setting option summary to change screen timeout, with additional explanation-->
    <string name="lock_immediately_summary_with_exception">Immediately after sleep, except when kept unlocked by <xliff:g id="trust_agent_name">%1$s</xliff:g></string>
    <!-- Security settings screen, setting option summary to change screen timeout, with additional explanation-->
    <string name="lock_after_timeout_summary_with_exception"><xliff:g id="timeout_string">%1$s</xliff:g> after sleep, except when kept unlocked by <xliff:g id="trust_agent_name">%2$s</xliff:g></string>
    <!-- Text shown next to checkbox for showing owner info on LockScreen [CHAR LIMIT=50]-->
    <string name="show_owner_info_on_lockscreen_label">Show owner info on lock screen</string>
    <!-- Text shown for title of owner info setting [CHAR LIMIT=20]-->
    <string name="owner_info_settings_title">Lock screen message</string>
    <!-- Text shown for title of settings checkbox to enable widgets [CHAR LIMIT=20]-->
    <string name="security_enable_widgets_title">Enable widgets</string>
    <!-- Summary for settings checkbox to disable widgets when the setting has been disabled by an installed device admin [CHAR LIMIT=50] -->
    <string name="security_enable_widgets_disabled_summary">Disabled by admin</string>
    <!-- Text shown for the title of the lockdown option -->
    <string name="lockdown_settings_title">Show lockdown option</string>
    <!-- Text shown for the description of the lockdown option -->
    <string name="lockdown_settings_summary">Display power button option that turns off Smart Lock, fingerprint unlocking, and notifications on the lock screen</string>
    <!-- Text shown for summary of owner info setting (if none set) [CHAR LIMIT=40]-->
    <string name="owner_info_settings_summary">None</string>
    <!-- Description of how many characters are used in owner info [CHAR LIMIT=40]-->
    <string name="owner_info_settings_status"><xliff:g id="count" example="90">%1$d</xliff:g> / <xliff:g id="count" example="100">%2$d</xliff:g></string>
    <!-- Hint text shown in owner info edit text [CHAR LIMIT=50] -->
    <string name="owner_info_settings_edit_text_hint">E.g., Joe\u2019s Android.</string>
    <!-- Text shown for title of user info setting [CHAR LIMIT=20]-->
    <string name="user_info_settings_title">User info</string>
    <!-- Text shown next to checkbox for showing profile info on LockScreen [CHAR LIMIT=50]-->
    <string name="show_profile_info_on_lockscreen_label">Show profile info on lock screen</string>
    <!-- Text shown for title of profile info setting [CHAR LIMIT=20]-->
    <string name="profile_info_settings_title">Profile info</string>
    <!-- Main Settings screen setting option title for the item to take you to the Accounts screen [CHAR LIMIT=22] -->
    <string name="Accounts_settings_title">Accounts</string>
    <!-- Main Settings screen setting option title for the item to take you to the location screen -->
    <string name="location_settings_title">Location</string>
    <!-- Used in the location settings to control turning on/off the feature entirely -->
    <string name="location_settings_master_switch_title">Use location</string>

    <!-- Main Settings screen setting option title for the item to take you to the accounts screen [CHAR LIMIT=22] -->
    <string name="account_settings_title">Accounts</string>
    <!-- Main Settings screen setting option title for the item to take you to the security screen -->
    <string name="security_settings_title">Security &amp; location</string>
    <!-- Security Settings screen setting option title for the item to take you to the encryption and credential screen -->
    <string name="encryption_and_credential_settings_title">Encryption &amp; credentials</string>
    <!-- Security Settings screen Encryption and crendential summary -->
    <string name="encryption_and_credential_settings_summary" product="default">Phone encrypted</string>
    <string name="decryption_settings_summary" product="default">Phone not encrypted</string>
    <!-- Security Settings screen Encryption and crendential summary -->
    <string name="encryption_and_credential_settings_summary" product="tablet">Device encrypted</string>
    <string name="decryption_settings_summary" product="tablet">Device not encrypted</string>
    <!-- Security Settings screen setting option title for the item to take you to the lock screen preference screen [CHAR LIMIT=60] -->
    <string name="lockscreen_settings_title">Lock screen preferences</string>

    <!-- Main Settings screen setting option summary text for the item tot ake you to the security and location screen -->
    <string name="security_settings_summary">Set My Location, screen unlock, SIM card lock, credential storage lock</string>
    <!-- Main Settings screen setting option summary text for the item to take you to the CDMA security and location screen -->
    <string name="cdma_security_settings_summary">Set My Location, screen unlock, credential storage lock</string>
    <!-- In the security screen, the header title for settings related to  Passwords-->
    <string name="security_passwords_title">Privacy</string>
    <!-- Summary for settings preference disabled by administrator [CHAR LIMIT=50] -->
    <string name="disabled_by_administrator_summary">Disabled by admin</string>
    <!-- In the security screen, the header title for security statuses -->
    <string name="security_status_title">Security status</string>
    <!-- Summary for Security settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="security_dashboard_summary">Screen lock, fingerprint</string>
    <!-- Summary for Security settings when fingerprint is not supported [CHAR LIMIT=NONE]-->
    <string name="security_dashboard_summary_no_fingerprint">Screen lock</string>
    <!-- Fingerprint enrollment and settings --><skip />
    <!-- Title shown for menu item that launches fingerprint settings or enrollment [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_preference_title">Fingerprint</string>
    <!-- Fingerprint managment category title - configuration options for managing enrolled fingerprints [CHAR LIMIT=22] -->
    <string name="fingerprint_manage_category_title">Manage fingerprints</string>
    <!-- Fingerprint category title - configuration options for managing fingerprint enrollment [CHAR LIMIT=22] -->
    <string name="fingerprint_usage_category_title">Use fingerprint for</string>
    <!-- Preference to add another fingerprint -->
    <string name="fingerprint_add_title">Add fingerprint</string>
    <!-- switch for allowing fingerprint to be used for keyguard -->
    <string name="fingerprint_enable_keyguard_toggle_title">screen lock</string>
    <!-- Message showing the current number of fingerprints set up. Shown for a menu item that launches fingerprint settings or enrollment. -->
    <plurals name="security_settings_fingerprint_preference_summary">
        <item quantity="one"><xliff:g id="count">%1$d</xliff:g> fingerprint set up</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> fingerprints set up</item>
    </plurals>
    <!-- message shown in summary field when no fingerprints are registered -->
    <string name="security_settings_fingerprint_preference_summary_none"></string>
    <!-- Introduction title shown in fingerprint enrollment to introduce the fingerprint feature[CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_introduction_title">Unlock with fingerprint</string>
    <!-- Introduction title shown in fingerprint enrollment to introduce the fingerprint feature, when fingerprint unlock is disabed by device admin [CHAR LIMIT=40] -->
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled">Use your fingerprint</string>
    <!-- Introduction detail message shown in fingerprint enrollment dialog [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message">Just touch the fingerprint sensor to unlock your phone, authorize purchases, or sign in to apps. Be careful whose fingerprints you add. Even one added print can do any of these things.\n\nNote: Your fingerprint may be less secure than a strong pattern or PIN.</string>
    <!-- Introduction detail message shown in fingerprint enrollment dialog, when fingerprint unlock is disabled by device admin [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled">Use your fingerprint to unlock your phone or approve purchases.\n\nNote: You can\u2019t use your fingerprint to unlock this device. For more information, contact your organization\u2019s admin.</string>
    <!-- Introduction detail message shown in fingerprint enrollment screen in setup wizard. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_message_setup">Use your fingerprint to unlock your phone or approve purchases.\n\nNote: Your fingerprint may be less secure than a strong pattern or PIN.</string>
    <!-- Button text to cancel enrollment from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_cancel">Cancel</string>
    <!-- Button text to continue to the next screen from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_continue">Continue</string>
    <!-- Button text to cancel enrollment from the introduction (this string variant is used while in setup wizard) [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup">Skip</string>
    <!-- Button text to continue to the next screen from the introduction (this string variant is used while in setup wizard) [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup">Next</string>
    <!-- Title of dialog shown when the user tries to skip setting up fingerprint after adding lock screen during initial setup. [CHAR LIMIT=30] -->
    <string name="setup_fingerprint_enroll_skip_title">Skip fingerprint?</string>
    <!-- Body text of dialog shown when the user tries to skip setting up fingerprint after adding lock screen during initial setup [CHAR LIMIT=NONE] -->
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text">Fingerprint setup only takes a minute or two. If you skip this, you can add your fingerprint later in settings.</string>
    <!-- Title of dialog shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so [CHAR LIMIT=30]-->
    <string name="lock_screen_intro_skip_title">Skip screen lock?</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so, including loss of factory reset protection. (tablet) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet">Device protection features won\u2019t be turned on. You won\u2019t be able to prevent others from using this tablet if it\u2019s lost, stolen or reset.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so, including loss of factory reset protection. (device) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device">Device protection features won\u2019t be turned on. You won\u2019t be able to prevent others from using this device if it\u2019s lost, stolen or reset.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so, including loss of factory reset protection. (phone) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default">Device protection features won\u2019t be turned on. You won\u2019t be able to prevent others from using this phone if it\u2019s lost, stolen or reset.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so. (tablet) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text" product="tablet">Device protection features won\u2019t be turned on. You won\u2019t be able to prevent others from using this tablet if it\u2019s lost or stolen.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so. (device) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text" product="device">Device protection features won\u2019t be turned on. You won\u2019t be able to prevent others from using this device if it\u2019s lost or stolen.</string>
    <!-- Dialog text shown when the user tries to skip setting up a screen lock, warning them of potential consequences of not doing so. (phone) [CHAR LIMIT=NONE] -->
    <string name="lock_screen_intro_skip_dialog_text" product="default">Device protection features won\u2019t be turned on. You won\u2019t be able to prevent others from using this phone if it\u2019s lost or stolen.</string>
    <!-- Button for skipping a step after having been warned of a potential concern [CHAR LIMIT=30] -->
    <string name="skip_anyway_button_label">Skip anyway</string>
    <!-- Button for going to the previous screen or step [CHAR LIMIT=20] -->
    <string name="go_back_button_label">Go back</string>
    <!-- Introduction title shown in fingerprint enrollment dialog to locate the sensor [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_find_sensor_title">Touch the sensor</string>
    <!-- Message shown in fingerprint enrollment dialog to locate the sensor -->
    <string name="security_settings_fingerprint_enroll_find_sensor_message">It\u2019s on the back of your phone. Use your index finger.</string>
    <!-- Content description of graphic that shows where the fingerprint of the device is [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description">Illustration with device and fingerprint sensor location</string>
    <!-- Label text shown in fingerprint dialog for renaming a fingerprint template [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_name_label">Name</string>
    <!-- Button text shown in fingerprint dialog that allows the user to rename a fingerprint template [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_ok">OK</string>
    <!-- Button text shown in fingerprint dialog that allows the user to delete the fingerprint template [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_delete">Delete</string>
    <!-- Title shown in fingerprint enrollment dialog to begin enrollment [CHAR LIMIT=29]-->
    <string name="security_settings_fingerprint_enroll_start_title">Touch the sensor</string>
    <!-- Message shown in fingerprint enrollment dialog to begin enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_start_message">Put your finger on the sensor and lift after you feel a vibration</string>
    <!-- Title shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=40] -->
    <string name="security_settings_fingerprint_enroll_repeat_title">Lift, then touch again</string>
    <!-- Message shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_repeat_message">Keep lifting your finger to add the different parts of your fingerprint</string>
    <!-- Title shown in fingerprint enrollment dialog once enrollment is completed [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_finish_title">Fingerprint added</string>
    <!-- Message shown in fingerprint enrollment dialog once enrollment is completed -->
    <string name="security_settings_fingerprint_enroll_finish_message">When you see this icon, use your fingerprint for identification or to approve purchases</string>
    <!-- Button text to skip enrollment of fingerprint [CHAR LIMIT=40] -->
    <string name="security_settings_fingerprint_enroll_enrolling_skip">Do it later</string>
    <!-- Title of the dialog shown when the user tries to skip fingerprint setup, asking them to confirm the action [CHAR LIMIT=40] -->
    <string name="setup_fingerprint_enroll_enrolling_skip_title">Skip fingerprint setup?</string>
    <!-- Content of the dialog shown when the user tries to skip fingerprint setup, asking them to confirm the action [CHAR LIMIT=NONE] -->
    <string name="setup_fingerprint_enroll_enrolling_skip_message">You\u2019ve chosen to use your fingerprint as one way to unlock your phone. If you skip now, you\u2019ll need to set this up later. Setup takes only a minute or so.</string>

    <!-- Button text to setup screen lock in onboard dialog [CHAR LIMIT=34] -->
    <string name="security_settings_fingerprint_enroll_setup_screen_lock">Set up screen lock</string>
    <!-- Button text to exit fingerprint wizard after everything is done [CHAR LIMIT=15] -->
    <string name="security_settings_fingerprint_enroll_done">Done</string>
    <!-- Dialog title for dialog which shows when user touches the icon on the screen, instead of the sensor at the back [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_touch_dialog_title">Whoops, that\u2019s not the sensor</string>
    <!-- Dialog message for dialog which shows when user touches the icon on the screen, instead of the sensor at the back [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_touch_dialog_message">Touch the sensor on the back of your phone. Use your index finger.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled. [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_error_dialog_title">Enrollment was not completed</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled due to being idle too long. -->
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message">Fingerprint enrollment time limit reached. Try again.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled due to an internal error or fingerprint can't be read. -->
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message">Fingerprint enrollment didn\'t work. Try again or use a different finger.</string>
    <!-- Button text shown at the end of enrollment that allows the user to add another fingerprint -->
    <string name="fingerprint_enroll_button_add">Add another</string>
    <!-- Button text shown at the end of enrollment that allows the user to move to the next step -->
    <string name="fingerprint_enroll_button_next">Next</string>
    <!-- Text shown in fingerprint settings explaining what the fingerprint can be used for. [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_disclaimer">In addition to unlocking your phone, you can also use your fingerprint to authorize purchases and app access. <annotation id="url">Learn more</annotation></string>
    <!-- Text shown in fingerprint settings explaining what the fingerprint can be used for in the case unlocking is disabled [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled">
        The screen lock option is disabled. To learn more, contact your organization\'s admin.
        <annotation id="admin_details">More details</annotation>\n\nYou can still use your
        fingerprint to authorize purchases and app access.
        <annotation id="url">Learn more</annotation></string>
    <!-- Text shown in fingerprint enroll when we didn't observe progress for a few seconds. [CHAR LIMIT=100] -->
    <string name="security_settings_fingerprint_enroll_lift_touch_again">Lift finger, then touch sensor again</string>

    <!-- Text shown when "Add fingerprint" button is disabled -->
    <string name="fingerprint_add_max">You can add up to <xliff:g id="count" example="5">%d</xliff:g> fingerprints</string>
    <!-- Text shown when users has enrolled a maximum number of fingerprints [CHAR LIMIT=NONE] -->
    <string name="fingerprint_intro_error_max">You\u2019ve added the maximum number of fingerprints</string>
    <!-- Text shown when an unknown error caused the device to be unable to add fingerprints [CHAR LIMIT=NONE] -->
    <string name="fingerprint_intro_error_unknown">Can\u2019t add more fingerprints</string>

    <!-- Title shown in a dialog which asks the user to confirm when the last fingerprint gets deleted by him. [CHAR LIMIT=50]-->
    <string name="fingerprint_last_delete_title">Remove all fingerprints?</string>

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

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

    <!-- Message shown in a dialog which asks the user to confirm when the last fingerprint gets deleted by him. [CHAR LIMIT=NONE]-->
    <string name="fingerprint_last_delete_message">You won\'t be able to use your fingerprints to
        unlock your phone, authorize purchases, or sign in to apps with them</string>
    <string name="fingerprint_last_delete_message_profile_challenge">You won\'t be able to use your
        fingerprints to unlock your work profile, authorize purchases, or sign in to work
        apps</string>

    <!-- Button to confirm the last removing the last fingerprint. [CHAR LIMIT=20]-->
    <string name="fingerprint_last_delete_confirm">Yes, remove</string>

    <!-- Content description for the fingerprint icon when the user is prompted to enter his credentials. Not shown on the screen. [CHAR LIMIT=NONE] -->
    <string name="confirm_fingerprint_icon_content_description">Use your fingerprint to continue.</string>

    <!-- Title of the preferences category for preference items to control encryption -->
    <string name="crypt_keeper_settings_title">Encryption</string>

    <!-- Title of the preferences item to control encryption -->
    <string name="crypt_keeper_encrypt_title" product="tablet">Encrypt tablet</string>
    <!-- Title of the preferences item to control encryption -->
    <string name="crypt_keeper_encrypt_title" product="default">Encrypt phone</string>

    <!-- Summary of the preferences item to control encryption, when encryption is active -->
    <string name="crypt_keeper_encrypted_summary">Encrypted</string>

    <!-- Informational text in the first confirmation screen before starting device encryption -->
    <string name="crypt_keeper_desc" product="tablet">
    You can encrypt your accounts, settings, downloaded apps and their data,
    media, and other files. After you encrypt your tablet, assuming you\u2019ve set up a screen lock
    (that is, a pattern or numeric PIN or password), you\u2019ll need to unlock the screen to decrypt
    the tablet every time you power it on. The only other way to decrypt is to perform a factory
    data reset, erasing all your data.\n\nEncryption takes an hour or more. You must start with
    a charged battery and keep your tablet plugged in throughout the process. If you interrupt it,
    you\u2019ll lose some or all of your data</string>
    <!-- Informational text in the first confirmation screen before starting device encryption -->
    <string name="crypt_keeper_desc" product="default">
    You can encrypt your accounts, settings, downloaded apps and their data,
    media, and other files. After you encrypt your phone, assuming you\u2019ve set up a screen lock
    (that is, a pattern or numeric PIN or password), you\u2019ll need to unlock the screen to decrypt
    the phone every time you power it on. The only other way to decrypt is to perform a factory
    data reset, erasing all your data.\n\nEncryption takes an hour or more. You must start with
    a charged battery and keep your phone plugged in throughout the process. If you interrupt it,
    you\u2019ll lose some or all of your data.</string>

    <!-- Button text to start encryption process -->
    <string name="crypt_keeper_button_text" product="tablet">Encrypt tablet</string>
    <!-- Button text to start encryption process -->
    <string name="crypt_keeper_button_text" product="default">Encrypt phone</string>

    <!-- Warning string that will be displayed when encryption cannot be started -->
    <string name="crypt_keeper_low_charge_text">Charge your battery and try again.</string>
    <!-- Warning string that will be displayed when encryption cannot be started -->
    <string name="crypt_keeper_unplugged_text">Plug in your charger and try again.</string>

    <!-- Dialog title, shown when encryption cannot proceed because a PIN/Password is needed -->
    <string name="crypt_keeper_dialog_need_password_title">No lock screen PIN or password</string>
    <!-- Dialog message, shown when encryption cannot proceed because a PIN/Password is needed -->
    <string name="crypt_keeper_dialog_need_password_message">You need to set a lock screen PIN or
    password before you can start encryption.</string>

    <!-- Title of the final confirmation screen before starting device encryption -->
    <string name="crypt_keeper_confirm_title">Encrypt?</string>
    <!-- Warning text in the final confirmation screen before starting device encryption -->
    <string name="crypt_keeper_final_desc" product="tablet">
    The encryption operation is irreversible and if you interrupt it, you\u2019ll lose data.
    Encryption takes an hour or more, during which the tablet will restart several times.
    </string>
    <!-- Warning text in the final confirmation screen before starting device encryption -->
    <string name="crypt_keeper_final_desc" product="default">
    The encryption operation is irreversible and if you interrupt it, you\u2019ll lose data.
    Encryption takes an hour or more, during which the phone will restart several times.
    </string>

    <!-- Title of the progress screen while encrypting the device -->
    <string name="crypt_keeper_setup_title">Encrypting</string>

    <!-- Informational text on the progress screen while encrypting the device -->
    <string name="crypt_keeper_setup_description" product="tablet">Wait while your tablet
    is being encrypted. <xliff:g id="percent" example="50">^1</xliff:g>% complete.</string>
    <!-- Informational text on the progress screen while encrypting the device -->
    <string name="crypt_keeper_setup_description" product="default">Wait while your phone
    is being encrypted. <xliff:g id="percent" example="50">^1</xliff:g>% complete.</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet">Wait while your tablet
    is being encrypted. Time remaining: <xliff:g id="duration" example="1:23">^1</xliff:g></string>
    <string name="crypt_keeper_setup_time_remaining" product="default">Wait while your phone
    is being encrypted. Time remaining: <xliff:g id="duration" example="1:23">^1</xliff:g></string>

    <string name="crypt_keeper_force_power_cycle" product="tablet">To unlock your tablet, turn it off and then on.</string>
    <string name="crypt_keeper_force_power_cycle" product="default">To unlock your phone, turn it off and then on.</string>


    <!-- Warn user their device will be wiped if they make x more failed attempts -->
    <string name="crypt_keeper_warn_wipe">Warning: Your device will be wiped after
    <xliff:g id="count" example="7">^1</xliff:g> more failed attempts to be unlocked!
    </string>

    <!-- Informational text on the password entry screen prompting the user for their password -->
    <string name="crypt_keeper_enter_password">Type your password</string>

    <!-- Title of the encryption screen when encrypting the device failed -->
    <string name="crypt_keeper_failed_title">Encryption unsuccessful</string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_failed_summary" product="tablet">
      Encryption was interrupted and can\u2019t complete. As a result, the data on
      your tablet is no longer accessible.
      \n\n
      To resume using your tablet, you need to perform a factory reset.
      When you set up your tablet after the reset, you\u2019ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_failed_summary" product="default">
      Encryption was interrupted and can\u2019t complete. As a result, the data on
      your phone is no longer accessible.
      \n\nTo resume using your phone, you need to perform a factory reset.
      When you set up your phone after the reset, you\u2019ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Title of the encryption screen when decrypting the device failed -->
    <string name="crypt_keeper_data_corrupt_title">Decryption unsuccessful</string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_data_corrupt_summary" product="tablet">
      The password you entered is correct, but unfortunately your data is
      corrupt.
      \n\nTo resume using your tablet, you need to perform a factory reset.
      When you set up your tablet after the reset, you\u2019ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Informational text when encryption fails -->
    <string name="crypt_keeper_data_corrupt_summary" product="default">
      The password you entered is correct, but unfortunately your data is
      corrupt.
      \n\nTo resume using your phone, you need to perform a factory reset.
      When you set up your phone after the reset, you\u2019ll have an opportunity
      to restore any data that was backed up to your Google Account.
    </string>

    <!-- Image button description to switch input method -->
    <string name="crypt_keeper_switch_input_method">Switch input method</string>

    <!-- Unlock Picker Settings --><skip />

    <!-- Security Picker --><skip />

    <!-- Title for suggested actions for screen lock [CHAR LIMIT=46] -->
    <string name="suggested_lock_settings_title">Secure your phone</string>

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

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

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

    <!--  Title for security picker to choose the unlock method: None/Pattern/PIN/Password [CHAR LIMIT=22] -->
    <string name="lock_settings_picker_title">Choose screen lock</string>

    <!--  Title for security picker to choose the profile unlock method: None/Pattern/PIN/Password [CHAR LIMIT=22] -->
    <string name="lock_settings_picker_title_profile">Choose work lock</string>

    <!--  Title for security picker in setup wizard to choose the unlock method: None/Pattern/PIN/Password (tablet) [CHAR LIMIT=22] -->
    <string name="setup_lock_settings_picker_title" product="tablet">Protect your tablet</string>
    <!--  Title for security picker in setup wizard to choose the unlock method: None/Pattern/PIN/Password (device) [CHAR LIMIT=22] -->
    <string name="setup_lock_settings_picker_title" product="device">Protect your device</string>
    <!--  Title for security picker in setup wizard to choose the unlock method: None/Pattern/PIN/Password (phone) [CHAR LIMIT=22] -->
    <string name="setup_lock_settings_picker_title" product="default">Protect your phone</string>

    <!-- Message shown when setting up screen lock, prompting user to choose the their backup screen lock method [CHAR LIMIT=NONE] -->
    <string name="lock_settings_picker_fingerprint_added_security_message">For added security, set a backup screen lock</string>

    <!-- Description text for screen in setup wizard asking user to set up screen lock, explaining to the user how setting up a screen lock protect them from losing data. (tablet) [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_message" product="tablet">Prevent others from using this tablet without your permission by activating device protection features. Choose the screen lock you want to use.</string>
    <!-- Description text for screen in setup wizard asking user to set up screen lock, explaining to the user how setting up a screen lock protect them from losing data. (device) [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_message" product="device">Prevent others from using this device without your permission by activating device protection features. Choose the screen lock you want to use.</string>
    <!-- Description text for screen in setup wizard asking user to set up screen lock, explaining to the user how setting up a screen lock protect them from losing data. (phone) [CHAR LIMIT=NONE] -->
    <string name="setup_lock_settings_picker_message" product="default">Prevent others from using this phone without your permission by activating device protection features. Choose the screen lock you want to use.</string>

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

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

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

    <!--  Main Security lock settings --><skip />
    <!--  Title for PreferenceScreen to launch picker for security method when there is none [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_launch_picker_title">Screen lock</string>

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

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

    <!--  Profile Security lock settings --><skip />
    <!--  Title for PreferenceScreen to launch picker for security method for the managed profile when there is none [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_launch_picker_title_profile">Work profile lock</string>

    <!--  Title for PreferenceScreen to change security method: None/Pattern/PIN/Password [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_launch_picker_change_title">Change lock screen</string>

    <!--  Summary for PreferenceScreen to change security method: None/Pattern/PIN/Password [CHAR LIMIT=45]  -->
    <string name="unlock_set_unlock_launch_picker_change_summary">Change or disable pattern, PIN, or password security</string>

    <!--  Summary for PreferenceScreen to change security method: None/Pattern/PIN/Password [CHAR LIMIT=45]  -->
    <string name="unlock_set_unlock_launch_picker_enable_summary">Choose a method to lock the screen</string>

    <!-- Title for preference that disables unlock security [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_off_title">None</string>
    <!-- Summary for preference that disables unlock security [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_off_summary"></string>

    <!-- Title for preference that disables unlock security [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_none_title">Swipe</string>
    <!-- Summary for preference that disables unlock security [CHAR LIMIT=45]-->
    <string name="unlock_set_unlock_none_summary">No security</string>

    <!-- Title for preference that guides the user through creating an unlock pattern [CHAR LIMIT=22]-->
    <string name="unlock_set_unlock_pattern_title">Pattern</string>
    <!-- Summary for preference that guides the user through creating an unlock pattern [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_pattern_summary">Medium security</string>

    <!-- Title for preference that guides the user through creating an unlock PIN (Personal Identification Number) [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_pin_title">PIN</string>
    <!-- Summary for preference that guides the user through creating an unlock PIN (Personal Identification Number) [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_pin_summary">Medium to high security</string>

    <!-- Title for preference that guides the user through creating an unlock password [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_password_title">Password</string>
    <!-- Title for preference that guides the user through creating an unlock password [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_password_summary">High security</string>

    <!-- Title for preference that allows the user to setup their lock screen preference later [CHAR LIMIT=22] -->
    <string name="unlock_set_do_later_title">Not now</string>

    <!-- Summary specifying that this is the current screen lock setting [CHAR LIMIT=45] -->
    <string name="current_screen_lock">Current screen lock</string>

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

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

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

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

    <!-- Message shown in screen lock picker while setting up the new screen lock with fingerprint option. [CHAR LIMIT=NONE]-->
    <string name="fingerprint_unlock_title">You can unlock your phone using your fingerprint. For security, this option requires a backup screen lock.</string>

    <!-- Summary for preference that has been disabled by because of the DevicePolicyAdmin, or because device encryption is enabled, or because there are credentials in the credential storage [CHAR LIMIT=50] -->
    <string name="unlock_set_unlock_disabled_summary">Disabled by admin, encryption policy, or
        credential storage</string>

    <!-- Summary for "Configure lockscreen" when lock screen is off [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_off">None</string>
    <!-- Summary for "Configure lockscreen" when security is disabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_none">Swipe</string>
    <!-- Summary for "Configure lockscreen" when security pattern is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_pattern">Pattern</string>
    <!-- Summary for "Configure lockscreen" when security PIN is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_pin">PIN</string>
    <!-- Summary for "Configure lockscreen" when security password is enabled [CHAR LIMIT=45] -->
    <string name="unlock_set_unlock_mode_password">Password</string>

    <!-- Footer text in when choosing screen lock type during setup wizard, telling the user that
         they can add fingerprint after they complete setup wizard. The text "Settings > Security"
         should match settings_label and security_settings_title [CHAR LIMIT=NONE] -->
    <string name="unlock_setup_wizard_fingerprint_details">Once you\u2019ve set up a screen lock, you can also set up your fingerprint in Settings &gt; Security.</string>

    <!-- Title for option to turn of password/pin/pattern unlock. [CHAR LIMIT=22] -->
    <string name="unlock_disable_lock_title">Turn off screen lock</string>

    <!-- Title of the dialog shown when the user removes the device lock [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_title">Remove device protection?</string>
    <!-- Title of the dialog shown when the user removes the profile lock [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_title_profile">Remove profile protection?</string>

    <!-- Content of the dialog shown when the user removes the device lock pattern [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern">"Device protection features will not work without your pattern."</string>
    <!-- Content of the dialog shown when the user removes the device lock pattern and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint">"Device protection features will not work without your pattern.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won\'t be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin">"Device protection features will not work without your PIN."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_fingerprint">"Device protection features will not work without your PIN.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won\'t be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the device lock password [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password">"Device protection features will not work without your password."</string>
    <!-- Content of the dialog shown when the user removes the device lock password and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_fingerprint">"Device protection features will not work without your password.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won\'t be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the device lock of unknown type [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown">"Device protection features will not work without your screen lock."</string>
    <!-- Content of the dialog shown when the user removes the device lock of unknown type and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint">"Device protection features will not work without your screen lock.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this device and you won\'t be able to unlock your phone, authorize purchases, or sign in to apps with them."</string>

    <!-- Content of the dialog shown when the user removes the profile lock pattern [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_profile">"Profile protection features will not work without your pattern."</string>
    <!-- Content of the dialog shown when the user removes the profile lock pattern and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile">"Profile protection features will not work without your pattern.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this profile and you won\'t be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the profile lock PIN [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_profile">"Profile protection features will not work without your PIN."</string>
    <!-- Content of the dialog shown when the user removes the profile lock PIN and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile">"Profile protection features will not work without your PIN.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this profile and you won\'t be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the profile lock password [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_profile">"Profile protection features will not work without your password."</string>
    <!-- Content of the dialog shown when the user removes the profile lock password and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile">"Profile protection features will not work without your password.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this profile and you won\'t be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>
    <!-- Content of the dialog shown when the user removes the profile lock of unknown type [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_profile">"Profile protection features will not work without your screen lock."</string>
    <!-- Content of the dialog shown when the user removes the profile lock of unknown type and the user has fingerprints enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile">"Profile protection features will not work without your screen lock.<xliff:g id="empty_line">\n\n</xliff:g>Your saved fingerprints will also be removed from this profile and you won\'t be able to unlock your profile, authorize purchases, or sign in to apps with them."</string>

    <!-- Affirmative action of the dialog shown when the user removes the device lock [CHAR LIMIT=25] -->
    <string name="unlock_disable_frp_warning_ok">Yes, remove</string>

    <!-- Title shown on security settings to allow the user to change their lockscreen pattern [CHAR LIMIT=22] -->
    <string name="unlock_change_lock_pattern_title">Change unlock pattern</string>
    <!-- Title shown on security settings to allow the user to change their lockscreen PIN [CHAR LIMIT=22] -->
    <string name="unlock_change_lock_pin_title">Change unlock PIN</string>
    <!-- Title shown on security settings to allow the user to change their lockscreen password [CHAR LIMIT=22]-->
    <string name="unlock_change_lock_password_title">Change unlock password</string>

    <!-- Message shown on the lock screen when the user incorrectly enters their lock and it counts towards the max attempts before their data on the device is wiped. [CHAR LIMIT=NONE] -->
    <string name="lock_failed_attempts_before_wipe">Try again. Attempt <xliff:g id="current_attempts">%1$d</xliff:g> of <xliff:g id="total_attempts">%2$d</xliff:g>.</string>

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

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

    <!-- Hint shown in dialog screen when password is too short -->
    <string name="lockpassword_password_too_short">Must be at least <xliff:g id="count" example="3">%d</xliff:g> characters</string>
    <!-- Hint shown in dialog screen when PIN is too short -->
    <string name="lockpassword_pin_too_short">PIN must be at least <xliff:g id="count" example="3">%d</xliff:g> digits</string>

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

    <!-- Error shown in popup when password is too long -->
    <string name="lockpassword_password_too_long">Must be fewer than
        <xliff:g id="number" example="17">%d</xliff:g> characters</string>
    <!-- Error shown in popup when PIN is too long -->
    <string name="lockpassword_pin_too_long">Must be fewer than
        <xliff:g id="number" example="17">%d</xliff:g> digits</string>

    <!-- Error shown when in PIN mode and user enters a non-digit -->
    <string name="lockpassword_pin_contains_non_digits">Must contain only digits 0-9</string>

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

    <!-- Error shown when a user is choosing a PIN for their work phone, but what they suggest is blocked by their company's IT administrator. The user should try another PIN that's less common and more complicated. -->
    <string name="lockpassword_pin_blacklisted_by_admin">Common PINs are blocked by your IT admin. Try a different PIN.</string>

    <!-- Error shown when in PASSWORD mode and user enters an invalid character -->
    <string name="lockpassword_illegal_character">This can\'t include an invalid character</string>

    <!-- Error shown when in PASSWORD mode and password is all digits -->
    <string name="lockpassword_password_requires_alpha">Must contain at least one letter</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain any digits -->
    <string name="lockpassword_password_requires_digit">Must contain at least one digit</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain any symbols -->
    <string name="lockpassword_password_requires_symbol">Must contain at least one symbol</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of letters -->
    <plurals name="lockpassword_password_requires_letters">
        <item quantity="one">Must contain at least 1 letter</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> letters</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of lowercase letters -->
    <plurals name="lockpassword_password_requires_lowercase">
        <item quantity="one">Must contain at least 1 lowercase letter</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> lowercase letters</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of uppercase letters -->
    <plurals name="lockpassword_password_requires_uppercase">
        <item quantity="one">Must contain at least 1 uppercase letter</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> uppercase letters</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of numerical digits -->
    <plurals name="lockpassword_password_requires_numeric">
        <item quantity="one">Must contain at least 1 numerical digit</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> numerical digits</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of special symbols -->
    <plurals name="lockpassword_password_requires_symbols">
        <item quantity="one">Must contain at least 1 special symbol</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> special symbols</item>
    </plurals>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of non-letter characters -->
    <plurals name="lockpassword_password_requires_nonletter">
        <item quantity="one">Must contain at least 1 non-letter character</item>
        <item quantity="other">Must contain at least <xliff:g id="count" example="3">%d</xliff:g> non-letter characters</item>
    </plurals>

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

    <!-- Error shown when a user is choosing a PASSWORD for their work phone, but what they suggest is blocked by their company's IT administrator. The user should try another PASSWORD that's less common and more complicated. -->
    <string name="lockpassword_password_blacklisted_by_admin">Common passwords are blocked by your IT admin. Try a different password.</string>

    <!-- [CHAR_LIMIT=NONE] Error shown when the user tries to set an ascending or descending sequence of digits -->
    <string name="lockpassword_pin_no_sequential_digits">Ascending, descending, or repeated sequence
        of digits isn\'t allowed</string>

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

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

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

    <!-- Label for LockPatternTutorial Cancel button -->
    <string name="lockpattern_tutorial_cancel_label">Cancel</string>

    <!-- Label for LockPatternTutorial Continue button -->
    <string name="lockpattern_tutorial_continue_label">Next</string>

    <!-- Toast shown when lock pattern or password successfully setup. [CHAR LIMIT=64] -->
    <string name="lock_setup" msgid="5507462851158901718">Setup is complete.</string>

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

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

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

    <!-- Title of preference to manage trust agents -->
    <string name="manage_trust_agents">Trust agents</string>

    <!-- Summary shown when trust agent settings is disabled because the user hasn't set up primary security -->
    <string name="disabled_because_no_backup_security">To use, first set a screen lock</string>

    <!-- Summary of preference to manage device policies when there is no trust agents-->
    <string name="manage_trust_agents_summary">None</string>

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

    <!-- Bluetooth settings -->
    <!-- Bluetooth settings check box title on Main Settings screen -->
    <string name="bluetooth_quick_toggle_title">Bluetooth</string>
    <!-- Bluetooth settings check box summary for turning on bluetooth -->
    <string name="bluetooth_quick_toggle_summary">Turn on Bluetooth</string>
    <!--Used as title on second screen after selecting Bluetooth settings -->
    <string name="bluetooth_settings">Bluetooth</string>
    <!--Wireless controls screen, settings title for the item to take you to the bluetooth settings screen -->
    <string name="bluetooth_settings_title">Bluetooth</string>
    <!--Wireless controls screen, settings summary for the item tot ake you to the bluetooth settings screen -->
    <string name="bluetooth_settings_summary">Manage connections, set device name &amp; discoverability</string>

    <!-- ======================================================================================= -->
    <!-- Note: The opening brackets of HTML style tags are escaped (e.g. "<b>" is "&lt;b>") in   -->
    <!--   the following resources to enable formatting followed by HTML styling, as described   -->
    <!--   here:  http://developer.android.com/guide/topics/resources/string-resource.html       -->
    <!-- ======================================================================================= -->

    <!-- Title for the dialog to enter PIN. [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_request">Pair with <xliff:g id="device_name">%1$s</xliff:g>?</string>

    <!-- Message when bluetooth is informing the user of the pairing key. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_key_msg">Bluetooth pairing code</string>

    <!-- Message when bluetooth dialog for passkey entry is showing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_passkey_msg">Type the pairing code then press Return or Enter</string>

    <!-- Checkbox label for alphanumeric PIN entry (default is numeric PIN). [CHAR LIMIT=50] -->
    <string name="bluetooth_enable_alphanumeric_pin">PIN contains letters or symbols</string>

    <!-- Bluetooth PIN hint text (below the text entry box). [CHAR LIMIT=30] -->
    <string name="bluetooth_pin_values_hint">Usually 0000 or 1234</string>

    <!-- Bluetooth PIN hint text (below the text entry box). [CHAR LIMIT=30] -->
    <string name="bluetooth_pin_values_hint_16_digits">Must be 16 digits</string>

    <!-- Pairing dialog text to remind user to enter the PIN on the other device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_pin_other_device">You may also need to type this PIN on the other device.</string>
    <!-- Pairing dialog text to remind user to enter the passkey on the other device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_enter_passkey_other_device">You may also need to type this passkey on the other device.</string>

    <!-- Message for confirmation of passkey to complete pairing. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_confirm_passkey_msg">To pair with:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Make sure it is showing this passkey:&lt;br>&lt;b><xliff:g id="passkey">%2$s</xliff:g>&lt;/b></string>

    <!-- Message when bluetooth incoming pairing request for (2.1 devices) dialog is showing -->
    <string name="bluetooth_incoming_pairing_msg">From:&lt;br>&lt;b><xliff:g id="device_name">%1$s</xliff:g>&lt;/b>&lt;br>&lt;br>Pair with this device?</string>

    <!-- Message when bluetooth dialog when passkey or pin needs to be displayed. -->
    <string name="bluetooth_display_passkey_pin_msg">To pair with:<xliff:g id="bold1">&lt;br>&lt;b></xliff:g><xliff:g id="device_name">%1$s</xliff:g><xliff:g id="end_bold1">&lt;/b>&lt;br>&lt;br></xliff:g>Type on it:<xliff:g id="bold2">&lt;br>&lt;b></xliff:g><xliff:g id="passkey">%2$s</xliff:g><xliff:g id="end_bold2">&lt;/b></xliff:g>, then press Return or Enter.</string>

    <!-- Checkbox message in pairing dialogs.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_shares_phonebook">Allow access to your contacts and call history</string>

    <!-- Title for BT error dialogs. -->
    <string name="bluetooth_error_title"></string>

    <!-- Message for the error dialog when BT connecting operation fails generically. -->
    <string name="bluetooth_connecting_error_message">Couldn\u2019t connect to <xliff:g id="device_name">%1$s</xliff:g>.</string>

    <!-- Bluetooth settings: The title of the preference (list item) that initiates a scan for devices -->
    <string name="bluetooth_preference_scan_title">Scan for devices</string>
    <!-- Bluetooth settings: The title of the action button that initiates a search for nearby devices [CHAR LIMIT=20] -->
    <string name="bluetooth_search_for_devices">Refresh</string>
    <!-- Bluetooth settings: The title of the action button while a search for nearby devices is in progress [CHAR LIMIT=20] -->
    <string name="bluetooth_searching_for_devices">Searching\u2026</string>
    <!-- Bluetooth settings: The sub heading for device settings. [CHAR LIMIT=30] -->
    <string name="bluetooth_preference_device_settings">Device settings</string>
    <!-- Bluetooth settings: Paired dialog title [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_title">Paired device</string>
    <!-- Bluetooth settings: Name label [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_name_label">Name</string>
    <!-- Bluetooth settings: Checkbox label for enable/disable internet connection.  [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_internet_option">Internet connection</string>
    <!-- Bluetooth settings: Checkbox label for enable/disable keyboard connection.  [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_keyboard_option">Keyboard</string>
    <!-- Bluetooth settings: Checkbox label for enable/disable contacts connection.  [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_dialog_contacts_option">Contacts and call history</string>
    <!-- Bluetooth settings: pairing dialog title.  [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_dialog_title">Pair with this device?</string>
    <!-- Bluetooth settings: share phone book title.  [CHAR LIMIT=40] -->
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title">Share phone book?</string>
    <!-- Bluetooth settings: Message informing user that a bluetooth wants to access contant and call history.  [CHAR LIMIT=100] -->
    <string name="bluetooth_pairing_dialog_contants_request"><xliff:g id="device_name">%1$s</xliff:g> wants to access your contacts and call history.</string>
    <!-- Bluetooth settings: paring permission message.  [CHAR LIMIT=100] -->
    <string name="bluetooth_pairing_dialog_paring_request"><xliff:g id="device_name">%1$s</xliff:g> wants to pair with Bluetooth. When connected, it will have access to your contacts and call history.</string>
    <!-- Bluetooth settings: The sub heading for devices which have already been paired with this device. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_paired_devices">Paired devices</string>
    <!-- Bluetooth settings: The sub heading for available devices during and after scanning. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_found_media_devices">Available devices</string>
    <!-- Bluetooth settings: The message displayed if no Bluetooth devices were found. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_no_found_devices">No devices available</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will connect to all profiles on the device. -->
    <string name="bluetooth_device_context_connect">Connect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect from all profiles on the device. -->
    <string name="bluetooth_device_context_disconnect">Disconnect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will first pair, and then connect to all profiles on the device. -->
    <string name="bluetooth_device_context_pair_connect">Pair &amp; connect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will remove pairing with the device. -->
    <string name="bluetooth_device_context_unpair">Unpair</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect and remove pairing with the device. -->
    <string name="bluetooth_device_context_disconnect_unpair">Disconnect &amp; unpair</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will take the user to another screen where they can choose exactly which profiles to connect to. -->
    <string name="bluetooth_device_context_connect_advanced">Options\u2026</string>
    <!-- Bluetooth settings.  Menu option to Bluetooth advanced settings [CHAR LIMIT=20]-->
    <string name="bluetooth_menu_advanced">Advanced</string>
    <!-- Bluetooth settings. Title of the advanced bluetooth settings screen [CHAR LIMIT=30]-->
    <string name="bluetooth_advanced_titlebar">Advanced Bluetooth</string>
    <!-- Bluetooth settings. Text displayed when Bluetooth is off and device list is empty [CHAR LIMIT=50]-->
    <string name="bluetooth_empty_list_bluetooth_off">When Bluetooth is turned on, your device can communicate with other nearby Bluetooth devices.</string>
    <!-- Bluetooth settings. Text displayed when Bluetooth is off and bluetooth scanning is turned on [CHAR LIMIT=NONE] -->
    <string name="bluetooth_scanning_on_info_message">When Bluetooth is turned on, your device can communicate with other nearby Bluetooth devices.\n\nTo improve device experience, apps and services can still scan for nearby devices at any time, even when Bluetooth is off. This can be used, for example, to improve location-based features and services. you can change this in <annotation id="link">scanning settings</annotation>.</string>
    <!-- Message to describe "BLE scan always available feature" when Bluetooth is off. The
      place-holders "LINK_BEGIN" and "LINK_END" must NOT be translated. They mark a link to bring
      the user to "scanning settings" screen. -->
    <string name="ble_scan_notify_text">To improve location accuracy, system apps and services can
      still detect Bluetooth devices. You can change this in
      <xliff:g id="link_begin">LINK_BEGIN</xliff:g>scanning
      settings<xliff:g id="link_end">LINK_END</xliff:g>.</string>
    <!-- Bluetooth connecting error message [CHAR LIMIT=NONE] -->
    <string name="bluetooth_connect_failed">Couldn\'t connect. Try again.</string>

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

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

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

    <!-- Bluetooth settings.  The title of the screen to pick which profiles to connect to on the device.  For example, headphones may have both A2DP and headset, this allows the user to choose which one he wants to connect to. -->
    <string name="bluetooth_connect_specific_profiles_title">Connect to\u2026</string>

    <!-- Bluetooth settings.  Message for disconnecting from the A2DP profile. [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_a2dp_profile"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from media audio.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the headset profile. [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_headset_profile"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from handsfree audio.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the HID profile. [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_hid_profile"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from input device.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the PAN profile (user role). [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_pan_user_profile">Internet access via <xliff:g id="device_name">%1$s</xliff:g> will be disconnected.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the PAN profile (NAP role). [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from sharing this tablet\u2019s internet connection.</string>
    <!-- Bluetooth settings.  Message for disconnecting from the PAN profile (NAP role). [CHAR LIMIT=80] -->
    <string name="bluetooth_disconnect_pan_nap_profile" product="default"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected from sharing this phone\u2019s internet connection.</string>

    <!-- Bluetooth settings.  Connection options screen.  The title of the screen. [CHAR LIMIT=40] -->
    <string name="bluetooth_device_advanced_title">Paired Bluetooth device</string>
    <!-- Bluetooth settings.  Connection options screen.  The title of the checkbox that controls whether the device is in "online" mode or "offline" mode.  This essentially is the checkbox that controls whether any checks / unchecks on a profile should be applied immediately, or next time the device is connected. -->
    <string name="bluetooth_device_advanced_online_mode_title">Connect</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary of the online mode checkbox.  This describes what the setting does in the context of the screen. -->
    <string name="bluetooth_device_advanced_online_mode_summary">Connect to Bluetooth device</string>
    <!-- Bluetooth settings.  Connection options screen.  The title of the header that is above all of the profiles.
         When a user decides what Bluetooth capabilities to use with the device.  -->
    <string name="bluetooth_device_advanced_profile_header_title">Use for</string>
    <!-- Bluetooth settings. Connection options screen. Title for option to rename the device. [CHAR LIMIT=30] -->
    <string name="bluetooth_device_advanced_rename_device">Rename</string>
    <!-- Bluetooth settings. Connection options screen. Title for checkbox to enable incoming file transfers [CHAR LIMIT=30] -->
    <string name="bluetooth_device_advanced_enable_opp_title">Allow incoming file transfers</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the checkbox preference when PAN is connected (user role). [CHAR LIMIT=25]-->
    <string name="bluetooth_pan_user_profile_summary_connected">Connected to device for internet access</string>
    <!-- Bluetooth settings. Connection options screen. The summary for the checkbox preference when PAN is connected (NAP role). [CHAR LIMIT=25]-->
    <string name="bluetooth_pan_nap_profile_summary_connected">Sharing local internet connection with device</string>

    <!-- Bluetooth settings.  Dock Setting Title -->
    <string name="bluetooth_dock_settings">Dock Settings</string>
    <!-- Bluetooth settings.  Dock Setting Dialog Title -->
    <string name="bluetooth_dock_settings_title">Use dock for audio</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Checkbox selection 1: Use dock as speaker phone -->
    <string name="bluetooth_dock_settings_headset">As speaker phone</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Checkbox selection 2: Use dock for media audio -->
    <string name="bluetooth_dock_settings_a2dp">For music and media</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Remember setting and don't ask user again -->
    <string name="bluetooth_dock_settings_remember">Remember settings</string>

    <!-- Bluetooth developer settings: Maximum number of connected audio devices -->
    <string name="bluetooth_max_connected_audio_devices_string">Maximum connected Bluetooth audio devices</string>
    <!-- Bluetooth developer settings: Maximum number of connected audio devices -->
    <string name="bluetooth_max_connected_audio_devices_dialog_title">Select maximum number of connected Bluetooth audio devices</string>

    <!-- Wifi Display settings. The title of the screen. [CHAR LIMIT=40] -->
    <string name="wifi_display_settings_title">Cast</string>
    <!-- Wifi Display settings. The title of a menu item to enable wireless display [CHAR LIMIT=40] -->
    <string name="wifi_display_enable_menu_item">Enable wireless display</string>
    <!-- Wifi Display settings. Text that appears when scanning for devices is finished and no nearby device was found [CHAR LIMIT=40]-->
    <string name="wifi_display_no_devices_found">No nearby devices were found.</string>
    <!-- Wifi Display settings. The status summary for connecting devices. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_connecting">Connecting</string>
    <!-- Wifi Display settings. The status summary for connected devices. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_connected">Connected</string>
    <!-- Wifi Display settings. The status summary for devices that's already in use. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_in_use">In use</string>
    <!-- Wifi Display settings. The status summary for devices that's not available. [CHAR LIMIT=40] -->
    <string name="wifi_display_status_not_available">Unavailable</string>
    <!-- Wifi Display settings. Image description for device details button. This opens the screen to rename, unpair, etc. a single device. -->
    <string name="wifi_display_details">Display settings</string>

    <!-- Wifi Display settings. Options dialog.  The title of the dialog. [CHAR LIMIT=40] -->
    <string name="wifi_display_options_title">Wireless display options</string>
    <!-- Wifi Display settings. Options dialog.  The forget button text. [CHAR LIMIT=20] -->
    <string name="wifi_display_options_forget">Forget</string>
    <!-- Wifi Display settings. Options dialog.  The done button text. [CHAR LIMIT=20] -->
    <string name="wifi_display_options_done">Done</string>
    <!-- Wifi Display settings. Options dialog.  The name label used when prompting the user to rename the display. [CHAR LIMIT=20] -->
    <string name="wifi_display_options_name">Name</string>

    <!-- Wifi Display settings. The sub heading for wireless display certification options. [CHAR LIMIT=40] -->
    <string name="wifi_display_certification_heading" translatable="false">Certification</string>
    <!-- Wifi Display settings. The section title for wireless display session info. [CHAR LIMIT=40] -->
    <string name="wifi_display_session_info" translatable="false">Session info</string>
    <!-- Wifi Display settings. The checkbox title for enabling listen mode during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_listen_mode" translatable="false">Enable listen mode</string>
    <!-- Wifi Display settings. The checkbox title for enabling autonomous GO during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_autonomous_go" translatable="false">Enable autonomous GO</string>
    <!-- Wifi Display settings. The button text for sending pause trigger during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_pause" translatable="false">Pause</string>
    <!-- Wifi Display settings. The button text for sending play (resume) trigger during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_resume" translatable="false">Resume</string>
    <!-- Wifi Display settings. The dropdown menu title for choosing WPS configuration during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_wps_config" translatable="false">WPS configuration</string>
    <!-- Wifi Display settings. The dropdown menu title for choosing listen channel during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_listen_channel" translatable="false">Listen channel</string>
    <!-- Wifi Display settings. The dropdown menu title for choosing operating channel during certification process. [CHAR LIMIT=40] -->
    <string name="wifi_display_operating_channel" translatable="false">Operating channel</string>
    <!-- Wifi 2.4GHz is used as an universal itendifier for 2.4GHz band -->
    <string name="wifi_band_24ghz">2.4 GHz</string>
    <!-- Wifi Internal 5GHz as an universal itendifier for 5GHz band -->
    <string name="wifi_band_5ghz">5 GHz</string>
    <!-- Wifi Sign in text for button [CHAR LIMIT = 40]-->
    <string name="wifi_sign_in_button_text">Sign in</string>
    <!-- Wifi Sign in CTA for wifi settings when captive portal auth is required [CHAR LIMIT = 50] -->
    <string name="wifi_tap_to_sign_in">Tap here to sign in to network</string>
    <!-- Link speed on Wifi Status screen -->
    <string name="link_speed">%1$d Mbps</string>

    <!-- This string asks the user whether or not to allow an app to enable WiFi. [CHAR LIMIT=NONE] -->
    <string name="wifi_ask_enable"><xliff:g id="requester" example="FancyApp">%s</xliff:g> wants to turn on Wi-Fi</string>
    <!-- This string asks the user whether or not to allow an app to disable WiFi. [CHAR LIMIT=NONE] -->
    <string name="wifi_ask_disable"><xliff:g id="requester" example="FancyApp">%s</xliff:g> wants to turn off Wi-Fi</string>

    <!-- NFC settings -->
    <!-- Used in the 1st-level settings screen to turn on NFC -->
    <string name="nfc_quick_toggle_title">NFC</string>
    <!-- Description of NFC in the 1st level settings screen, for a tablet. [CHAR LIMIT=NONE] -->
    <string name="nfc_quick_toggle_summary" product="tablet">Allow data exchange when the tablet touches another device</string>
    <!-- Description of NFC in the 1st level settings screen, for a phone. [CHAR LIMIT=NONE] -->
    <string name="nfc_quick_toggle_summary" product="default">Allow data exchange when the phone touches another device</string>
    <!-- Dialog title for NFC disclaimer [CHAR_LIMIT=40]-->
    <string name="nfc_disclaimer_title">Turn on NFC</string>
    <!-- Dialog content for NFC disclaimer: telling user NFC can exchange data when device is nearby other devices (for example: payment terminals, badge reader etc). [CHAR_LIMIT=NONE]-->
    <string name="nfc_disclaimer_content">NFC exchanges data between this device and other nearby devices or targets, such as payment terminals, access readers, and interactive ads or tags.</string>

    <!-- Used to enter the Android Beam sharing preferences screen. This phrase is a trademark. [CHAR LIMIT=32] -->
    <string name="android_beam_settings_title">Android Beam</string>
    <!-- Used to describe the on state of the Android Beam feature [CHAR LIMIT=NONE] -->
    <string name="android_beam_on_summary">Ready to transmit app content via NFC</string>
    <!-- Used to describe the off state of the Android Beam feature [CHAR LIMIT=NONE] -->
    <string name="android_beam_off_summary">Off</string>
    <!-- Used to describe the enabled state of the Android Beam feature when NFC, which it relies on, is turned off [CHAR LIMIT=NONE] -->
    <string name="android_beam_disabled_summary">Unavailable because NFC is turned off</string>
    <!-- Used in the Android Beam sharing preferences screen. This phrase is a trademark. [CHAR LIMIT=32] -->
    <string name="android_beam_label">Android Beam</string>
    <!-- Explanation of the Android Beam feature in the Android Beam settings panel. The use of "beam" here is as a verb and not considered trademarked. [CHAR LIMIT=NONE] -->
    <string name="android_beam_explained">When this feature is turned on, you can beam app content to another NFC-capable device by holding the devices close together. For example, you can beam web pages, YouTube videos, contacts, and more.\n\nJust bring the devices together (typically back to back) and then tap your screen. The app determines what gets beamed.</string>

    <!-- Wi-Fi Settings --> <skip />
    <!-- Used in the 1st-level settings screen to turn on Wi-Fi -->
    <string name="wifi_quick_toggle_title">Wi\u2011Fi</string>
    <!-- Used in the 1st-level settings screen as the turn-on summary -->
    <string name="wifi_quick_toggle_summary">Turn on Wi\u2011Fi</string>
    <!-- Used in the 1st-level settings screen to go to the 2nd-level settings screen  [CHAR LIMIT=20]-->
    <string name="wifi_settings">Wi\u2011Fi</string>

    <!-- Used in the Wi-Fi settings screen to control turning on/off Wi-Fi entirely [CHAR LIMIT=30]-->
    <string name="wifi_settings_master_switch_title">Use Wi\u2011Fi</string>
    <!-- Title of the Wi-fi settings screen -->
    <string name="wifi_settings_category">Wi\u2011Fi settings</string>
    <!-- Title of the Wi-fi settings entry in the left top level menu -->
    <string name="wifi_settings_title">Wi\u2011Fi</string>
    <!-- Summary text of the Wi-fi settings screen -->
    <string name="wifi_settings_summary">Set up &amp; manage wireless access points</string>
    <!-- Used by Account creation for turning on Wi-Fi  [CHAR LIMIT=60] -->
    <string name="wifi_select_network">Select Wi\u2011Fi</string>
    <!-- Summary text when turning Wi-Fi or bluetooth on -->
    <string name="wifi_starting">Turning Wi\u2011Fi on\u2026</string>
    <!-- Summary text when turning Wi-Fi or bluetooth off -->
    <string name="wifi_stopping">Turning off Wi\u2011Fi\u2026</string>
    <!-- Summary text when Wi-Fi or bluetooth has error -->
    <string name="wifi_error">Error</string>
    <!-- Summary text when wifi SoftAP started failed due to no legal usable channel allowed in this region by regulatory -->
    <string name="wifi_sap_no_channel_error">5 GHz band not available in this country</string>
    <!-- Toast message when Wi-Fi or bluetooth is disallowed in airplane mode -->
    <string name="wifi_in_airplane_mode">In Airplane mode</string>
    <!-- Checkbox title for option to notify user when open networks are nearby -->
    <string name="wifi_notify_open_networks">Open network notification</string>
    <!-- Checkbox summary for option to notify user when open networks are nearby-->
    <string name="wifi_notify_open_networks_summary">Notify when a high\u2011quality public network is available</string>
    <!-- Checkbox title for option to enable Wi-Fi when saved networks are nearby -->
    <string name="wifi_wakeup">Turn on Wi\u2011Fi automatically</string>
    <!-- Checkbox summary for option to enable Wi-Fi when high quality saved networks are nearby-->
    <string name="wifi_wakeup_summary">Wi\u2011Fi will turn back on near high\u2011quality saved networks, like your home network</string>
    <!-- Checkbox summary for auto-wifi when user needs to enable location scanning to toggle it -->
    <string name="wifi_wakeup_summary_no_location">Unavailable because location is turned off. Turn on <annotation id="link">location</annotation>.</string>
    <!-- Checkbox summary for Wi-Fi wakeup option to explain that Wi-Fi wakeup is disabled because Wi-Fi scanning is turned off -->
    <string name="wifi_wakeup_summary_scanning_disabled">Unavailable because Wi\u2011Fi scanning is turned off</string>
    <!-- Checkbox summary for Wi-Fi wakeup option to explain that a network rating provider needs to be selected to use the feature. -->
    <string name="wifi_wakeup_summary_scoring_disabled">To use, select a network rating provider</string>
    <!-- Checkbox title for option to toggle poor network detection -->
    <string name="wifi_poor_network_detection">Avoid poor connections</string>
    <!-- Checkbox summary for option to toggle poor network detection -->
    <string name="wifi_poor_network_detection_summary">Don\u2019t use a Wi\u2011Fi network unless it has a good internet connection</string>
    <!-- Checkbox summary for option to toggle poor network detection [CHAR LIMIT=60] -->
    <string name="wifi_avoid_poor_network_detection_summary">Only use networks that have a good internet connection</string>
    <!-- Checkbox title for option to connect to open Wi-Fi automatically [CHAR LIMIT=40] -->
    <string name="use_open_wifi_automatically_title">Connect to open networks</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically  [CHAR LIMIT=100] -->
    <string name="use_open_wifi_automatically_summary">Automatically connect to high\u2011quality public networks</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically, to explain that a network rating provider needs to be selected to use the feature. -->
    <string name="use_open_wifi_automatically_summary_scoring_disabled">To use, select a network rating provider</string>
    <!-- Checkbox summary for option to connect to open Wi-Fi automatically, to explain that a compatible network rating provider needs to be selected to use the feature. -->
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled">To use, select a compatible network rating provider</string>
    <!-- Preference title for option to install certificates -->
    <string name="wifi_install_credentials">Install certificates</string>
    <!-- Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off and Wi-Fi
      scanning is on. The place-holders "LINK_BEGIN" and "LINK_END" must NOT be translated. They
      mark a link to bring the user to "scanning settings" screen. -->
    <string name="wifi_scan_notify_text">To improve location accuracy, apps and services can still scan for Wi\u2011Fi networks at any time, even when Wi\u2011Fi is off. This can be used, for example, to improve location-based features and services. You can change this in <xliff:g id="link_begin">LINK_BEGIN</xliff:g>scanning settings<xliff:g id="link_end">LINK_END</xliff:g>.</string>
    <!-- Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off and Wi-Fi
      scanning is also off. The place-holders "LINK_BEGIN" and "LINK_END" must NOT be translated.
      They mark a link to bring the user to "scanning settings" screen. -->
    <string name="wifi_scan_notify_text_scanning_off">To improve location accuracy,
        turn on Wi-Fi scanning in
        <xliff:g id="link_begin">LINK_BEGIN</xliff:g>scanning
        settings<xliff:g id="link_end">LINK_END</xliff:g>.</string>
    <!-- Wifi scan always mode checkbox text -->
    <string name="wifi_scan_notify_remember_choice">Don\u2019t show again</string>
    <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? -->
    <string name="wifi_setting_sleep_policy_title">Keep Wi\u2011Fi on during sleep</string>
    <!-- Setting title for setting the wifi sleep policy. Do we keep Wi-Fi active when the screen turns off? [CHAR LIMIT=30] -->
    <string name="wifi_setting_on_during_sleep_title">Wi\u2011Fi on during sleep</string>
    <!-- Generic error message when the sleep policy could not be set. -->
    <string name="wifi_setting_sleep_policy_error">There was a problem changing the setting</string>
    <!-- Checkbox title for option to toggle suspend power optimizations [CHAR LIMIT=30] -->
    <string name="wifi_suspend_efficiency_title">Improve efficiency</string>
    <!-- Checkbox title for option to toggle suspend power optimizations -->
    <string name="wifi_suspend_optimizations">Wi\u2011Fi optimization</string>
    <!-- Checkbox summary for option to toggle suspend power optimizations -->
    <string name="wifi_suspend_optimizations_summary">Minimize battery usage when Wi\u2011Fi is on</string>
    <!-- Checkbox summary for option to toggle suspend power optimizations [CHAR LIMIT=30] -->
    <string name="wifi_limit_optimizations_summary">Limit battery used by Wi\u2011Fi</string>
    <!-- Checkbox title. Should we switch to using cellular data if Wi-Fi is still connected but the Wi-Fi network we're connected to no longer has Internet access (e.g., due to an outage)? -->
    <string name="wifi_switch_away_when_unvalidated">Switch to mobile data if Wi\u2011Fi loses internet access.</string>
    <!-- Preference title for option to automatically switch away from bad wifi networks [CHAR LIMIT=60]-->
    <string name="wifi_cellular_data_fallback_title">Switch to mobile data automatically</string>
    <!-- Preference summary to automatically switch away from bad wifi networks [CHAR LIMIT=None]-->
    <string name="wifi_cellular_data_fallback_summary">Use mobile data when Wi\u2011Fi has no internet access. Data usage charges may apply.</string>
    <!-- Action bar text message to manually add a wifi network [CHAR LIMIT=20]-->
    <string name="wifi_add_network">Add network</string>
    <!-- Action bar title to open additional Wi-Fi settings-->
    <string name="wifi_configure_settings_preference_title">Wi\u2011Fi preferences</string>
    <!-- Summary for Wi-Fi Preferences that explains that Wi-Fi will be enabled when high quality saved networks are nearby-->
    <string name="wifi_configure_settings_preference_summary_wakeup_on">Wi\u2011Fi turns back on automatically</string>
    <!-- Summary for Wi-Fi Preferences that explains that Wi-Fi will not automatically be enabled when high quality saved networks are nearby-->
    <string name="wifi_configure_settings_preference_summary_wakeup_off">Wi\u2011Fi doesn\u0027t turn back on automatically</string>
    <!-- Header for the list of wifi networks-->
    <string name="wifi_access_points">Wi\u2011Fi networks</string>
    <!-- Content description for menu button in Wifi setup. Not shown on the screen. [CHAR LIMIT=NONE] -->
    <string name="wifi_menu_more_options">More options</string>
    <!-- Menu option to launch Wi-Fi Direct settings [CHAR LIMIT=20]-->
    <string name="wifi_menu_p2p">Wi\u2011Fi Direct</string>
    <!-- Menu option to scan Wi-Fi networks -->
    <string name="wifi_menu_scan">Scan</string>
    <!-- Menu option to Wi-Fi advanced settings -->
    <string name="wifi_menu_advanced">Advanced</string>
    <!-- Menu option to Wi-Fi configure settings -->
    <string name="wifi_menu_configure">Configure</string>
    <!-- Menu option to connect to a Wi-Fi network -->
    <string name="wifi_menu_connect">Connect to network</string>
    <!-- Menu option to remember a temporary Wi-Fi network -->
    <string name="wifi_menu_remember">Remember network</string>
    <!-- Menu option to delete a Wi-Fi network -->
    <string name="wifi_menu_forget">Forget network</string>
    <!-- Menu option to modify a Wi-Fi network configuration -->
    <string name="wifi_menu_modify">Modify network</string>
    <!-- Menu option to write a Wi-Fi configuration token to an NFC tag [CHAR_LIMIT=30]-->
    <string name="wifi_menu_write_to_nfc">Write to NFC tag</string>
    <!-- Wi-Fi settings. text displayed when Wi-Fi is off and network list is empty [CHAR LIMIT=50]-->
    <string name="wifi_empty_list_wifi_off">To see available networks, turn Wi\u2011Fi on.</string>
    <!-- Wi-Fi settings. text displayed when Wi-Fi is on and network list is empty [CHAR LIMIT=50]-->
    <string name="wifi_empty_list_wifi_on">Searching for Wi\u2011Fi networks\u2026</string>
    <!-- Wifi Settings. text displayed when user has restriction DISALLOW_CONFIG_WIFI [CHAR LIMIT=NONE]-->
    <string name="wifi_empty_list_user_restricted">You don\u2019t have permission to change the Wi\u2011Fi network.</string>
    <!-- Wi-Fi settings. content description for more button [CHAR LIMIT=50]-->
    <string name="wifi_more">More</string>
    <!-- Wi-Fi settings. wps menu title [CHAR LIMIT=25]-->
    <string name="wifi_setup_wps">Automatic setup (WPS)</string>
    <!-- Wi-Fi settings dialog. Title of dialog displayed asking user to enable Wi-Fi Scanning [CHAR LIMIT=60]-->
    <string name="wifi_settings_scanning_required_title">Turn on Wi\u2011Fi scanning?</string>
    <!-- Wi-Fi settings dialog. Summary text describing why we need Wi-Fi scanning on. [CHAR LIMIT=NONE]-->
    <string name="wifi_settings_scanning_required_summary">To turn on Wi\u2011Fi automatically, you first need to turn on Wi\u2011Fi scanning.</string>
    <!-- Wi-Fi settings dialog. Informational text describing what Wi-Fi scanning does. [CHAR LIMIT=NONE]-->
    <string name="wifi_settings_scanning_required_info">Wi\u2011Fi scanning allows apps and services to scan for Wi\u2011Fi networks at any time, even when Wi\u2011Fi is off. This can be used, for example, to improve location\u2011based features and services.</string>
    <!-- Wi-Fi settings dialog. Text for the button that takes users to a help article about Wi-Fi scanning. [CHAR LIMIT = 20]-->
    <string name="wifi_settings_scanning_required_turn_on">Turn on</string>
    <!-- Wi-Fi settings dialog. Text to show in toast for when user turns on wifi scanning. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_scanning_required_enabled">Wi\u2011Fi scanning turned on</string>

    <!-- Dialog for Access Points --> <skip />
    <!-- Label to show/hide advanced options [CHAR LIMIT=40] -->
    <string name="wifi_show_advanced">Advanced options</string>
    <!-- Message for talkback to say when Advanced Options expanded [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description_expanded">Drop down list Advanced Options. Double-tap to collapse.</string>
    <!-- Message for talkback to say when Advanced Options is collapsed [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description_collapsed">Drop down list Advanced Options. Double-tap to expand.</string>
    <!-- Label for the SSID of the network -->
    <string name="wifi_ssid">Network name</string>
    <!-- Hint for a text field to enter the SSID of a hidden wifi network. [CHAR LIMIT=35] -->
    <string name="wifi_ssid_hint">Enter the SSID</string>
    <!-- Label for the security of the connection -->
    <string name="wifi_security">Security</string>
    <!-- Label for the hidden network status of this network -->
    <string name="wifi_hidden_network">Hidden network</string>
    <!-- Label for the warning shown to users if they try to connect to a network as "hidden" -->
    <string name="wifi_hidden_network_warning">If your router is not broadcasting a network ID but you would like to connect to it in the future, you can set the network as hidden.\n\nThis may create a security risk because your phone will regularly broadcast its signal to find the network.\n\nSetting the network as hidden will not change your router settings.</string>
    <!-- Label for the signal strength of the connection -->
    <string name="wifi_signal">Signal strength</string>
    <!-- Label for the status of the connection -->
    <string name="wifi_status">Status</string>
    <!-- Label for the link speed of the connection -->
    <string name="wifi_speed">Link speed</string>
    <!-- Label for the frequency band of the connection -->
    <string name="wifi_frequency">Frequency</string>
    <!-- Label for the IP address of the connection -->
    <string name="wifi_ip_address">IP address</string>
    <!-- Label for Passpoint network -->
    <string name="passpoint_label">Saved via</string>
    <!-- Content for Passpoint network -->
    <string name="passpoint_content"><xliff:g id="name">%1$s</xliff:g> credentials</string>
    <!-- Label for the EAP method of the network -->
    <string name="wifi_eap_method">EAP method</string>
    <!-- Label for the phase2 -->
    <string name="please_select_phase2">Phase 2 authentication</string>
    <!-- Label for the EAP CA certificate of the network -->
    <string name="wifi_eap_ca_cert">CA certificate</string>
    <!-- Label for the domain name that the EAP CA certificate(s) can be used to validate. -->
    <string name="wifi_eap_domain">Domain</string>
    <!-- Label for the EAP user certificate of the network -->
    <string name="wifi_eap_user_cert">User certificate</string>
    <!-- Label for the EAP identity of the network -->
    <string name="wifi_eap_identity">Identity</string>
    <!-- Label for the EAP anonymous identity of the network -->
    <string name="wifi_eap_anonymous">Anonymous identity</string>
    <!-- Label for the password of the secured network -->
    <string name="wifi_password">Password</string>
    <!-- Label for the check box to show password -->
    <string name="wifi_show_password">Show password</string>
    <!-- Label for the RadioGroup to choose wifi ap band -->
    <string name="wifi_ap_band_config">Select AP Band</string>
    <!-- Label for the radio button to choose wifi ap channel automatically-->
    <string name="wifi_ap_choose_auto">Auto</string>
    <!-- Label for the radio button to choose wifi ap 2.4 GHz band -->
    <string name="wifi_ap_choose_2G">2.4 GHz Band</string>
    <!-- Label for the radio button to only choose wifi ap 5GHz band -->
    <string name="wifi_ap_choose_5G">5.0 GHz Band</string>
    <!-- Label for the radio button to prefer 5GHz wifi ap band  [CHAR LIMIT=80]-->
    <string name="wifi_ap_prefer_5G">5.0 GHz Band preferred</string>
    <!-- Label for adding to the list of selected bands when 2.4 GHz is selected -->
    <string name="wifi_ap_2G">2.4 GHz</string>
    <!-- Label for adding to the list of selected bands when 5.0 GHz is selected -->
    <string name="wifi_ap_5G">5.0 GHz</string>
    <!-- Label that is shown as a dialog summary informing users they must pick at LEAST one band for their hotspot [CHAR LIMIT=NONE]-->
    <string name="wifi_ap_band_select_one">Choose at least one band for Wi\u2011Fi hotspot:</string>
    <!-- Label for the spinner to show ip settings [CHAR LIMIT=25] -->
    <string name="wifi_ip_settings">IP settings</string>
    <!-- Label for the check box to share a network with other users on the same device -->
    <string name="wifi_shared">Share with other device users</string>
    <!-- Hint for unchanged fields -->
    <string name="wifi_unchanged">(unchanged)</string>
    <!-- Hint for unspecified fields -->
    <string name="wifi_unspecified">Please select</string>
    <!-- Hint for multiple certificates being added to the configuration -->
    <string name="wifi_multiple_cert_added">(Multiple certificates added)</string>
    <!-- Menu option for using trusted system CA certificates to validate EAP servers -->
    <string name="wifi_use_system_certs">Use system certificates</string>
    <!-- Menu option for not providing an EAP user certificate -->
    <string name="wifi_do_not_provide_eap_user_cert">Do not provide</string>
    <!-- Menu option for not validating the EAP server -->
    <string name="wifi_do_not_validate_eap_server">Do not validate</string>
    <!-- Warning message displayed if user choses not to validate the EAP server -->
    <string name="wifi_do_not_validate_eap_server_warning">No certificate specified. Your connection will not be private.</string>
    <!-- Warning message displayed if network name (ssid) is too long -->
    <string name="wifi_ssid_too_long">Network name is too long.</string>
    <!-- Warning message displayed if user does not specify a domain for the CA certificate.
         Only displayed if the user also chooses to use system certificates. -->
    <string name="wifi_no_domain_warning">Must specify a domain.</string>
    <!-- Substring of status line when Wi-Fi Protected Setup (WPS) is available and
         string is listed first [CHAR LIMIT=20]-->
    <string name="wifi_wps_available_first_item">WPS available</string>
    <!-- Substring of wifi status when Wi-Fi Protected Setup (WPS) is available and
         string is listed after a wifi_secured_* string-->
    <string name="wifi_wps_available_second_item">\u0020(WPS available)</string>
    <!-- Message in WriteWifiConfigToNfcDialog when prompted to enter network password [CHAR_LIMIT=40] -->
    <string name="wifi_wps_nfc_enter_password">Enter your network password</string>

    <!-- Message in dialog when the user tries to connect to a carrier network[CHAR_LIMIT=40] -->
    <string name="wifi_carrier_connect">Carrier Wi\u2011Fi network</string>
    <!-- Message in dialog when the user tries to connect to a carrier network[CHAR_LIMIT=60] -->
    <string name="wifi_carrier_content">Connect via <xliff:g id="name">%1$s</xliff:g></string>

    <string name="wifi_scan_always_turnon_message">To improve location accuracy and for other purposes, <xliff:g id="app_name">%1$s</xliff:g> wants to turn on network scanning, even when Wi-Fi is off.\n\nAllow this for all apps that want to scan?</string>
    <!-- Message informing the user how to turn off  [CHAR LIMIT=200] -->
    <string name="wifi_scan_always_turnoff_message">To turn this off, go to Advanced in the overflow menu.</string>
    <string name="wifi_scan_always_confirm_allow">Allow</string>
    <string name="wifi_scan_always_confirm_deny">Deny</string>

    <!-- Dialog label to sign in to a Hotspot. [CHAR LIMIT=50]-->
    <string name="wifi_hotspot_title">Sign in to connect?</string>
    <!-- Dialog message to sign in to a Hotspot. [CHAR LIMIT=50]-->
    <string name="wifi_hotspot_message"><xliff:g id="app_name">%1$s</xliff:g> requires you to sign in online before you connect to the network.</string>
    <!-- Wifi settings button to connect in to a Hotspot. [CHAR LIMIT=50]-->
    <string name="wifi_hotspot_connect">CONNECT</string>

    <!-- Dialog text to tell the user that the selected network does not have Internet access. -->
    <string name="no_internet_access_text">This network has no internet access. Stay connected?</string>
    <string name="no_internet_access_remember">Don\u2019t ask again for this network</string>

    <!-- Dialog text to tell the user that the selected network has lost Internet access, and asking the user whether they want to avoid this network. -->
    <string name="lost_internet_access_title">Wi\u2011Fi is not connected to the internet</string>
    <string name="lost_internet_access_text">You can switch to the mobile network whenever Wi\u2011Fi has a bad connection. Data usage charges may apply.</string>
    <!-- Button text to let user switch to mobile data -->
    <string name="lost_internet_access_switch">Switch to mobile</string>
    <string name="lost_internet_access_cancel">Stay on Wi\u2011Fi</string>
    <string name="lost_internet_access_persist">Never show again</string>

    <!-- Button label to connect to a Wi-Fi network -->
    <string name="wifi_connect">Connect</string>
    <!-- Failured notification for connect -->
    <string name="wifi_failed_connect_message">Failed to connect to network</string>
    <!-- Button label to delete a Wi-Fi network -->
    <string name="wifi_forget">Forget</string>
    <!-- Button label to modify a Wi-Fi network -->
    <string name="wifi_modify">Modify</string>
    <!-- Failured notification for forget -->
    <string name="wifi_failed_forget_message">Failed to forget network</string>
    <!-- Button label to save a Wi-Fi network configuration -->
    <string name="wifi_save">Save</string>
    <!-- Failured notification for save -->
    <string name="wifi_failed_save_message">Failed to save network</string>
    <!-- Button label to dismiss the dialog -->
    <string name="wifi_cancel">Cancel</string>
    <!-- Dialog title for forget confirmation dialog -->
    <string name="wifi_forget_dialog_title">Forget network?</string>
    <!-- Dialog message for forget confirmation dialog -->
    <string name="wifi_forget_dialog_message">All passwords for this network will be deleted</string>

    <!-- Wi-Fi Advanced Settings --> <skip />
    <!-- Wi-Fi settings screen, Saved networks, settings section.  This is a header shown above Saved networks wifi settings. [CHAR LIMIT=30] -->
    <string name="wifi_saved_access_points_titlebar">Saved networks</string>
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates the number of networks a user has saved. -->
    <plurals name="wifi_saved_access_points_summary">
        <item quantity="one">1 network</item>
        <item quantity="other">%d networks</item>
    </plurals>
    <!-- Wi-Fi settings screen, advanced, settings section.  This is a header shown above advanced wifi settings. [CHAR LIMIT=30] -->
    <string name="wifi_advanced_titlebar">Advanced Wi\u2011Fi</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the Wi-Fi device's MAC address. -->
    <string name="wifi_advanced_mac_address_title">MAC address</string>
    <!-- Title of the screen to adjust IP settings -->
    <!-- Wi-Fi settings screen, advanced, title of the item to show the Wi-Fi device's current IP address. -->
    <string name="wifi_advanced_ip_address_title">IP address</string>

    <!-- Wifi Network Details -->
    <!-- Wifi details title-->
    <string name="wifi_details_title">Network details</string>
    <!-- Wifi details preference title to display router IP subnet mask -->
    <string name="wifi_details_subnet_mask">Subnet mask</string>
    <!-- Wifi details preference title to display router DNS info -->
    <string name="wifi_details_dns">DNS</string>
    <!-- Wifi details preference category title for IPv6 information -->
    <string name="wifi_details_ipv6_address_header">IPv6 addresses</string>

    <!-- Wifi saved access points.  Used as a label under the shortcut icon that goes to Wifi saved access points. [CHAR LIMIT=20] -->
    <string name="wifi_saved_access_points_label">Saved networks</string>
    <!-- Wifi Advanced settings.  Used as a label under the shortcut icon that goes to Wifi advanced settings. [CHAR LIMIT=20] -->
    <string name="wifi_advanced_settings_label">IP settings</string>
    <!-- Error message for users that aren't allowed to see or modify WiFi advanced settings [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_not_available">Wi\u2011Fi advanced settings are not available for this user</string>
    <!-- Menu item to save the IP settings -->
    <string name="wifi_ip_settings_menu_save">Save</string>
    <!-- Menu ietm to cancel the IP settings -->
    <string name="wifi_ip_settings_menu_cancel">Cancel</string>
    <!-- Error message if the IP address is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_ip_address">Type a valid IP address.</string>
    <!-- Error message if the gateway is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_gateway">Type a valid gateway address.</string>
    <!-- Error message if the dns is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_dns">Type a valid DNS address.</string>
    <!-- Error message if the network prefix length is not valid [CHAR LIMIT=50]-->
    <string name="wifi_ip_settings_invalid_network_prefix_length">Type a network prefix length between 0 and 32.</string>
    <!-- Label for the DNS (first one) -->
    <string name="wifi_dns1">DNS 1</string>
    <!-- Label for the DNS (second one)-->
    <string name="wifi_dns2">DNS 2</string>
    <!-- Label for the gateway of the network -->
    <string name="wifi_gateway">Gateway</string>
    <!-- Label for the network prefix of the network [CHAR LIMIT=25]-->
    <string name="wifi_network_prefix_length">Network prefix length</string>

    <!-- Wi-Fi p2p / Wi-Fi Direct settings -->
    <!-- Used in the 1st-level settings screen to launch Wi-fi Direct settings [CHAR LIMIT=25] -->
    <string name="wifi_p2p_settings_title">Wi\u2011Fi Direct</string>
    <string name="wifi_p2p_device_info">Device information</string>
    <string name="wifi_p2p_persist_network">Remember this connection</string>
    <!-- Menu option to discover peers-->
    <string name="wifi_p2p_menu_search">Search for devices</string>
    <!-- Menu option when discovery is in progress [CHAR LIMIT=25] -->
    <string name="wifi_p2p_menu_searching">Searching\u2026</string>
    <!-- Menu option to Rename-->
    <string name="wifi_p2p_menu_rename">Rename device</string>
    <!-- Title for available p2p devices -->
    <string name="wifi_p2p_peer_devices">Peer devices</string>
    <!-- Title for remembered p2p groups -->
    <string name="wifi_p2p_remembered_groups">Remembered groups</string>
    <!-- Toast text for a failed connection initiation -->
    <string name="wifi_p2p_failed_connect_message">Couldn\u2019t connect.</string>
    <!-- Message text for failure to rename -->
    <string name="wifi_p2p_failed_rename_message">Failed to rename device.</string>
    <!-- Title for disconnect dialog -->
    <string name="wifi_p2p_disconnect_title">Disconnect?</string>
    <!-- Message text for disconnection from one device-->
    <string name="wifi_p2p_disconnect_message">If you disconnect, your connection with <xliff:g id="peer_name">%1$s</xliff:g> will end.</string>
    <!-- Message text for disconnection from multiple devices-->
    <string name="wifi_p2p_disconnect_multiple_message">If you disconnect, your connection with <xliff:g id="peer_name">%1$s</xliff:g> and <xliff:g id="peer_count">%2$s</xliff:g> other devices will end.</string>
    <!-- Title for cancel connect dialog -->
    <string name="wifi_p2p_cancel_connect_title">Cancel invitation?</string>
    <!-- Message text for disconnection from one device-->
    <string name="wifi_p2p_cancel_connect_message">Do you want to cancel invitation to connect with <xliff:g id="peer_name">%1$s</xliff:g>?</string>
    <!-- Message text for remembered group deletion-->
    <string name="wifi_p2p_delete_group_message">Forget this group?</string>

    <!-- Wifi AP settings-->
    <!-- Label for Wifi tether checkbox. Toggles Access Point on/off  [CHAR LIMIT=30] -->
    <string name="wifi_hotspot_checkbox_text">Wi\u2011Fi hotspot</string>
    <!-- Summary text when turning hotspot off -->
    <string name="wifi_hotspot_off_subtext">Not sharing internet or content with other devices</string>
    <!-- Summary text when tethering is on -->
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet">Sharing this tablet\u2019s internet connection via hotspot</string>
    <!-- Summary text when tethering is on -->
    <string name="wifi_hotspot_tethering_on_subtext" product="default">Sharing this phone\u2019s internet connection via hotspot</string>
    <!-- Summary text when hotspot is on for local-only -->
    <string name="wifi_hotspot_on_local_only_subtext">App is sharing content. To share internet connection, turn hotspot off, then on</string>
    <!-- Summary text when no password is set [CHAR LIMIT=60] -->
    <string name="wifi_hotspot_no_password_subtext">No password set</string>

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

    <!-- Title for the toggle to turn off hotspot automatically [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_auto_off_title">Turn off hotspot automatically</string>
    <!-- Summary for the toggle to turn off hotspot automatically [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_auto_off_summary">Wi\u2011Fi hotspot will turn off if no devices are connected</string>

    <!-- Summary text when turning hotspot on -->
    <string name="wifi_tether_starting">Turning hotspot on\u2026</string>
    <!-- Summary text when turning hotspot off -->
    <string name="wifi_tether_stopping">Turning off hotspot\u2026</string>
    <!-- Subtext for wifi tether checkbox on success -->
    <string name="wifi_tether_enabled_subtext"><xliff:g id="network_ssid">%1$s</xliff:g> is active</string>
    <!-- Subtext for wifi tether checkbox on failure -->
    <string name="wifi_tether_failed_subtext">Portable Wi\u2011Fi hotspot error</string>
    <!-- Used to open the ssid and security dialog for Wifi Access Point -->
    <string name="wifi_tether_configure_ap_text">Set up Wi\u2011Fi hotspot</string>
    <!-- Used to open the ssid and security dialog for Wifi Access Point.  [CHAR LIMIT=30]-->
    <string name="wifi_hotspot_configure_ap_text">Wi\u2011Fi hotspot setup</string>
    <!-- Summary Used to open the ssid and security dialog for Wifi Access Point.  [CHAR LIMIT=60] -->
    <string name="wifi_hotspot_configure_ap_text_summary">AndroidAP WPA2 PSK hotspot</string>
    <!-- Default access point SSID used for tethering -->
    <string name="wifi_tether_configure_ssid_default">AndroidHotspot</string>
    <!-- Summary text when hotspot is disabled because airplane mode is on [CHAR LIMIT=80]-->
    <string name="wifi_tether_disabled_by_airplane">Unavailable because airplane mode is turned on</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Wi-Fi Testing on the diagnostic screen-->
    <string name="testing_wifi_info" translatable="false">Wi-Fi information</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager disableNetwork API-->
    <string name="disableNetwork" translatable="false">disableNetwork</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager enableNetwork API-->
    <string name="enableNetwork" translatable="false">enableNetwork</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager disconnect API-->
    <string name="disconnect" translatable="false">disconnect</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager getConfiguredNetworks API-->
    <string name="getConfiguredNetworks" translatable="false">getConfiguredNetworks</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager getConnectionInfo API-->
    <string name="getConnectionInfo" translatable="false">getConnectionInfo</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_api_test" translatable="false">Wi-Fi API</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_status_test" translatable="false">Wi-Fi status</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Button text on Wifi Status screen-->
    <string name="wifi_update" translatable="false">Refresh stats</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="wifi_state_label" translatable="false">Wi-Fi state:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="network_state_label" translatable="false">Network state:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
        Label on Wifi Status screen-->
    <string name="supplicant_state_label" translatable="false">Supplicant state:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="rssi_label" translatable="false">RSSI:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="bssid_label" translatable="false">BSSID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="ssid_label" translatable="false">SSID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="hidden_ssid_label" translatable="false">Hidden SSID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="ipaddr_label" translatable="false">IPaddr:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="macaddr_label" translatable="false">MAC addr:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="networkid_label" translatable="false">Network ID:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="link_speed_label" translatable="false">Link speed:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="scan_list_label" translatable="false">Scan results:</string>

    <!-- wifi state values-->
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_disabling" translatable="false">Disabling</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_disabled" translatable="false">Disabled</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_enabling" translatable="false">Enabling</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_enabled" translatable="false">Enabled</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_unknown" translatable="false">Unknown</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_config_info" translatable="false">Wi-Fi config</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Configuration screen-->
    <string name="config_list_label" translatable="false">Configured networks</string>

    <!-- Wireless networks, item title to go into the WFC settings [CHAR LIMIT=30] -->
    <string name="wifi_calling_settings_title">Wi-Fi calling</string>
    <!-- Title of suggestion to turn on wifi calling [CHAR LIMIT=46] -->
    <string name="wifi_calling_suggestion_title">Extend calls with Wi\u2011Fi</string>
    <!-- Summary of suggestion to turn on wifi calling [CHAR LIMIT=55] -->
    <string name="wifi_calling_suggestion_summary">Turn on Wi\u2011Fi calling to extend coverage</string>
    <!-- Title of WFC preference item [CHAR LIMIT=30] -->
    <string name="wifi_calling_mode_title">Calling preference</string>
    <!-- Title of WFC preference selection dialog [CHAR LIMIT=30] -->
    <string name="wifi_calling_mode_dialog_title">Wi-Fi calling mode</string>
    <!-- Title of WFC roaming preference item [CHAR LIMIT=45] -->
    <string name="wifi_calling_roaming_mode_title">Roaming preference</string>
    <!-- Summary of WFC roaming preference item [CHAR LIMIT=NONE]-->
    <string name="wifi_calling_roaming_mode_summary"><xliff:g id="wfc_roaming_preference" example="Wi-Fi">%1$s</xliff:g></string>
    <!-- WFC mode dialog [CHAR LIMIT=45] -->
    <string name="wifi_calling_roaming_mode_dialog_title">Roaming preference</string>
    <string-array name="wifi_calling_mode_choices">
        <item>Wi-Fi preferred</item>
        <item>Mobile preferred</item>
        <item>Wi-Fi only</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_v2">
        <item>Wi-Fi</item>
        <item>Mobile</item>
        <item>Wi-Fi only</item>
    </string-array>
    <string-array name="wifi_calling_mode_values">
        <item>"2"</item>
        <item>"1"</item>
        <item>"0"</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_without_wifi_only">
        <item>Wi-Fi preferred</item>
        <item>Mobile preferred</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
        <item>Wi-Fi</item>
        <item>Mobile</item>
    </string-array>
    <string-array name="wifi_calling_mode_values_without_wifi_only">
        <item>"2"</item>
        <item>"1"</item>
    </string-array>
    <!-- Wi-Fi Calling settings. Text displayed when Wi-Fi Calling is off -->
    <string name="wifi_calling_off_explanation">When Wi-Fi calling is on, your phone can route calls via Wi-Fi networks or your carrier\u2019s network, depending on your preference and which signal is stronger. Before turning on this feature, check with your carrier regarding fees and other details.</string>
    <!-- Wi-Fi Calling settings. Additional text displayed when Wi-Fi Calling is off. Default empty. [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_off_explanation_2"></string>
    <!-- Title of a preference for updating emergency address [CHAR LIMIT=40] -->
    <string name="emergency_address_title">Emergency Address</string>
    <!-- Summary of Update Emergency Address preference, explaining usage of emergency address [CHAR LIMIT=NONE] -->
    <string name="emergency_address_summary">Used as your location when you make an emergency call over Wi\u2011Fi</string>
    <!-- Message of private dns that provides a help link. [CHAR LIMIT=NONE] -->
    <string name="private_dns_help_message"><annotation id="url">Learn more</annotation> about Private DNS features</string>

    <!-- Message to display when setting wifi calling are not editable [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_pref_managed_by_carrier">Setting managed by carrier</string>
    <!-- Message to display when wifi calling needs activation [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_settings_activation_instructions">Activate Wi\u2011Fi Calling</string>
    <!-- Message to display when wifi calling should be on [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_turn_on">Turn on Wi\u2011Fi calling</string>
    <!-- Message to display when carrier does not support wifi calling or doesn't want the user
         to modify the settings [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_not_supported">Wi\u2011Fi calling is not supported for %1$s</string>
    <!-- Carrier string to use in other messages -->
    <string name="carrier">Carrier</string>
    <!-- Sound and alerts settings -->
    <skip/>
    <string name="display_settings_title">Display</string>
    <!-- Sound settings screen heading -->
    <string name="sound_settings">Sound</string>
    <!-- DO NOT TRANSLATE Summary placeholder -->
    <string name="summary_placeholder" translatable="false">&#160;</string>
    <!-- DO NOT TRANSLATE Summary placeholder reserving 2 lines -->
    <string name="summary_two_lines_placeholder" translatable="false">&#160;\n&#160;</string>
    <!-- Sound settings screen, volume title -->
    <string name="all_volume_title">Volumes</string>
    <!-- Sound settings screen, music effects title [CHAR LIMIT=30]-->
    <string name="musicfx_title">Music effects</string>
    <!-- Sound settings screen, setting option name -->
    <string name="ring_volume_title">Ring volume</string>
    <!-- Sound settings screen, setting option name checkbox -->
    <string name="vibrate_in_silent_title">Vibrate when silent</string>
    <!-- Sound settings screen, setting option name -->
    <string name="notification_sound_title">Default notification sound</string>
    <!-- Sound settings screen, the title of the volume bar to adjust the incoming call volume -->
    <string name="incoming_call_volume_title">Ringtone</string>
    <!-- Sound settings screen, the title of the volume bar to adjust the notification volume -->
    <string name="notification_volume_title">Notification</string>
    <!-- Sound settings screen, the caption of the checkbox for having the notification volume be
         the same as the incoming call volume. -->
    <string name="checkbox_notification_same_as_incoming_call">Use incoming call volume for notifications</string>

    <!-- Home settings screen, text indicating that a launcher does not support work profiles [CHAR LIMIT=100] -->
    <string name="home_work_profile_not_supported">Doesn\'t support work profiles</string>

    <!-- Sound settings screen, setting option title-->
    <string name="notification_sound_dialog_title">Default notification sound</string>
    <!-- Sound settings screen, setting option name -->
    <string name="media_volume_title">Media</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="media_volume_summary">Set volume for music and videos</string>
    <!-- Sound settings screen, alarm volume slider title -->
    <string name="alarm_volume_title">Alarm</string>
    <!-- Sound settings screen, dock settings summary-->
    <string name="dock_settings_summary">Audio settings for the attached dock</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="dtmf_tone_enable_title">Dial pad touch tones</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="sound_effects_enable_title">Tap sounds</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="lock_sounds_enable_title">Screen lock sound</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="haptic_feedback_enable_title">Vibrate on tap</string>
    <!-- Sound settings screen, setting option name checkbox to enable/disable audio recording features that improve audio recording in noisy environments -->
    <string name="audio_record_proc_title">Noise cancellation</string>
    <!-- Volume description for media volume -->
    <string name="volume_media_description">Music, video, games, &amp; other media</string>
    <!-- Volume description for ringtone and notification volume -->
    <string name="volume_ring_description">Ringtone &amp; notifications</string>
    <!-- Volume description for notification volume -->
    <string name="volume_notification_description">Notifications</string>
    <!-- Volume description for alarm volume -->
    <string name="volume_alarm_description">Alarms</string>
    <!-- Image description for ring volume mute button. -->
    <string name="volume_ring_mute">Mute ringtone &amp; notifications</string>
    <!-- Image description for media volume mute button. -->
    <string name="volume_media_mute">Mute music &amp; other media</string>
    <!-- Image description for notification volume mute button. -->
    <string name="volume_notification_mute">Mute notifications</string>
    <!-- Image description for alarm volume mute button. -->
    <string name="volume_alarm_mute">Mute alarms</string>

    <!-- Dock settings title, top level -->
    <string name="dock_settings">Dock</string>
    <!-- Dock settings title -->
    <string name="dock_settings_title">Dock settings</string>
    <!-- Dock audio settings -->
    <string name="dock_audio_settings_title">Audio</string>
    <!-- Dock audio summary for docked to desk dock -->
    <string name="dock_audio_summary_desk">Settings for the attached desktop dock</string>
    <!-- Dock audio summary for docked to car dock -->
    <string name="dock_audio_summary_car">Settings for the attached car dock</string>
    <!-- Dock audio summary for undocked -->
    <string name="dock_audio_summary_none" product="tablet">Tablet not docked</string>
    <!-- Dock audio summary for undocked -->
    <string name="dock_audio_summary_none" product="default">Phone not docked</string>
    <!-- Dock audio summary for docked to unknown -->
    <string name="dock_audio_summary_unknown">Settings for the attached dock</string>
    <!-- Dock not found dialog title -->
    <string name="dock_not_found_title">Dock not found</string>
    <!-- Dock not found dialog text -->
    <string name="dock_not_found_text" product="tablet">You need to dock the tablet before setting up dock audio.</string>
    <!-- Dock not found dialog text -->
    <string name="dock_not_found_text" product="default">You need to dock the phone before setting up dock audio.</string>
    <!-- Dock settings screen, dock events SFX setting check box label -->
    <string name="dock_sounds_enable_title">Dock insert sound</string>
    <!-- Dock settings screen, setting option summary text when check box is selected -->
    <string name="dock_sounds_enable_summary_on" product="tablet">Play sound when inserting or removing tablet from dock</string>
    <!-- Dock settings screen, setting option summary text when check box is selected -->
    <string name="dock_sounds_enable_summary_on" product="default">Play sound when inserting or removing phone from dock</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="dock_sounds_enable_summary_off" product="tablet">Don\u2019t play sound when inserting or removing tablet from dock</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="dock_sounds_enable_summary_off" product="default">Don\u2019t play sound when inserting or removing phone from dock</string>

    <!-- Account settings header. [CHAR LIMIT=30] -->
    <string name="account_settings">Accounts</string>
    <!-- Content description for work profile accounts group [CHAR LIMIT=NONE] -->
    <string name="accessibility_category_work">Work profile accounts - <xliff:g id="managed_by" example="Managed by Corporate application">%s</xliff:g></string>
    <!-- Content description for personal profile accounts group [CHAR LIMIT=NONE] -->
    <string name="accessibility_category_personal">Personal profile accounts</string>
    <!-- Content description for work profile details page title [CHAR LIMIT=NONE] -->
    <string name="accessibility_work_account_title">Work account - <xliff:g id="managed_by" example="Email provider">%s</xliff:g></string>
    <!-- Content description for personal profile details page title [CHAR LIMIT=NONE] -->
    <string name="accessibility_personal_account_title">Personal account - <xliff:g id="managed_by" example="Email provider">%s</xliff:g></string>

    <!-- Main Settings screen, setting option name to go into search settings -->
    <string name="search_settings">Search</string>

    <!-- Display settings --><skip/>
    <!-- Sound & display settings screen, section header for settings related to display -->
    <string name="display_settings">Display</string>
    <!-- Sound & display settings screen, accelerometer-based rotation check box label -->
    <string name="accelerometer_title">Auto-rotate screen</string>
    <!-- Display settings screen, Color mode settings title [CHAR LIMIT=30] -->
    <string name="color_mode_title">Colors</string>
    <!-- Display settings screen, Color mode option for "natural(sRGB) color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_natural">Natural</string>
    <!-- Display settings screen, Color mode option for "Boosted(sRGB + 10%) color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_boosted">Boosted</string>
    <!-- Display settings screen, Color mode option for "Saturated color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_saturated">Saturated</string>
    <!-- Display settings screen, Color mode option for "Adaptive color"  [CHAR LIMIT=45] -->
    <string name="color_mode_option_automatic">Adaptive</string>
    <!-- Display settings screen, "natural(sRGB) color" setting option summary [CHAR LIMIT=NONE] -->
    <string name="color_mode_summary_natural">Use accurate colors only</string>
    <!-- Display settings screen, "Adaptive color" setting option summary [CHAR LIMIT=NONE] -->
    <string name="color_mode_summary_automatic">Adjust between vivid and accurate colors</string>

    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is selected -->
    <string name="accelerometer_summary_on" product="tablet">Switch orientation automatically when rotating tablet</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is selected -->
    <string name="accelerometer_summary_on" product="default">Switch orientation automatically when rotating phone</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is clear -->
    <string name="accelerometer_summary_off" product="tablet">Switch orientation automatically when rotating tablet</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is clear -->
    <string name="accelerometer_summary_off" product="default">Switch orientation automatically when rotating phone</string>
    <!-- Sound & display settings screen, setting option name to change brightness level -->
    <string name="brightness">Brightness level</string>
    <!-- Sound & display settings screen, setting option name to change brightness level [CHAR LIMIT=30] -->
    <string name="brightness_title">Brightness</string>
    <!-- Sound & display settings screen, setting option summary to change brightness level -->
    <string name="brightness_summary">Adjust the brightness of the screen</string>
    <!-- Sound & display settings screen, setting option name to enable adaptive brightness [CHAR LIMIT=30] -->
    <string name="auto_brightness_title">Adaptive brightness</string>
    <!-- Sound & display settings screen, setting option summary to enable adaptive brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary">Optimize brightness level for available light</string>
    <!-- Sound & display settings screen, setting option summary when adaptive brightness is off [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_off">Off</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is very low [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_very_low">Preferred brightness is very low</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is low [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_low">Preferred brightness is low</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is the default [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_default">Preferred brightness is default</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is high [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_high">Preferred brightness is high</string>
    <!-- Sound & display settings screen, setting option summary when preferred adaptive brightness is very high [CHAR LIMIT=100] -->
    <string name="auto_brightness_summary_very_high">Preferred brightness is very high</string>
    <!-- Adaptive brightness settings screen, setting option to disable adaptive brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_off_title">Off</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers very low brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_very_low_title">Very low</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers low brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_low_title">Low</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers default brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_default_title">Default</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers high brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_high_title">High</string>
    <!-- Adaptive brightness settings screen, setting option to enable adaptive brightness when user prefers very high brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_very_high_title">Very high</string>
    <!-- Adaptive brightness settings screen, subtitle [CHAR LIMIT=100] -->
    <string name="auto_brightness_subtitle">Your preferred brightness level</string>
    <!-- Adaptive brightness settings screen, setting option summary to disable adaptive brightness [CHAR LIMIT=100] -->
    <string name="auto_brightness_off_summary">Don\'t adjust for available light</string>
    <!-- Adaptive brightness settings screen, setting option summary to enable adaptive brightness when user prefers very high brightness.
         Meant to make it clear that preferring very high brightness uses more battery. [CHAR LIMIT=100] -->
    <string name="auto_brightness_very_high_summary">Increased battery usage</string>
    <!-- Adaptive brightness settings screen, disclaimer that explains in more detail about how adaptive brightness works [CHAR LIMIT=150] -->
    <string name="auto_brightness_disclaimer">Optimize brightness level for available light. When this feature is on, you can still adjust brightness temporarily.</string>
    <!-- Description about the feature adaptive brightness -->
    <string name="auto_brightness_description">Your screen brightness will automatically adjust to your environment and activities. You can move the slider manually to help adaptive brightness learn your preferences.</string>

    <!-- Night display screen, setting option name to enable night display (renamed "Night Light" with title caps). [CHAR LIMIT=30] -->
    <string name="night_display_title">Night Light</string>
    <!-- Night display screen, description of night display feature (renamed "Night Light" with title caps). [CHAR LIMIT=NONE] -->
    <string name="night_display_text">Night Light tints your screen amber. This makes it easier to look at your screen or read in dim light, and may help you fall asleep more easily.</string>
    <!-- Night display screen, setting option name to configure whether night display turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_title">Schedule</string>
    <!-- Night display screen, setting option value for night display to *never* turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="night_display_auto_mode_never">None</string>
    <!-- Night display screen, setting option value for night display to turn on/off automatically according to a user defined schedule. [CHAR LIMIT=32] -->
    <string name="night_display_auto_mode_custom">Turns on at custom time</string>
    <!-- Night display screen, setting option value for night display to turn on/off automatically at sunset/sunrise. [CHAR LIMIT=32] -->
    <string name="night_display_auto_mode_twilight">Turns on from sunset to sunrise</string>
    <!-- Night display screen, setting option name to configure time to automatically turn on night display. [CHAR LIMIT=30] -->
    <string name="night_display_start_time_title">Start time</string>
    <!-- Night display screen, setting option name to configure time to automatically turn off night display. [CHAR LIMIT=30] -->
    <string name="night_display_end_time_title">End time</string>
    <!-- Night display screen, setting option name controlling the current activation status. [CHAR LIMIT=30] -->
    <string name="night_display_status_title">Status</string>
    <!-- Night display screen, setting the color temperature of the display. [CHAR LIMIT=30] -->
    <string name="night_display_temperature_title">Intensity</string>
    <!-- Display settings screen, summary format of night display when off. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off">Off / <xliff:g name="auto_mode_summary" example="Never turn on automatically">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of night display when off and will *never* turn on automatically. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off_auto_mode_never">Will never turn on automatically</string>
    <!-- Display settings screen, summary format of night display when off and will turn on automatically at a user defined time. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off_auto_mode_custom">Will turn on automatically at <xliff:g name="time" example="6 AM">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of night display when off and will turn on automatically at sunset. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_off_auto_mode_twilight">Will turn on automatically at sunset</string>
    <!-- Display settings screen, summary format of night display when on. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on">On / <xliff:g name="auto_mode_summary" example="Never turn off automatically">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of night display when on and will *never* turn off automatically. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on_auto_mode_never">Will never turn off automatically</string>
    <!-- Display settings screen, summary format of night display when on and will turn off automatically at a user defined time. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on_auto_mode_custom">Will turn off automatically at <xliff:g name="time" example="10 PM">%1$s</xliff:g></string>
    <!-- Display settings screen, summary of night display when on and will turn off automatically at sunrise. [CHAR LIMIT=NONE] -->
    <string name="night_display_summary_on_auto_mode_twilight">Will turn off automatically at sunrise</string>
    <!-- Display settings screen, activation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="night_display_activation_on_manual">Turn on now</string>
    <!-- Display settings screen, deactivation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="night_display_activation_off_manual">Turn off now</string>
    <!-- Display settings screen, activation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_on_twilight">Turn on until sunrise</string>
    <!-- Display settings screen, deactivation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_off_twilight">Turn off until sunset</string>
    <!-- Display settings screen, activation button action for custom schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_on_custom">Turn on until <xliff:g name="time" example="6 AM">%1$s</xliff:g></string>
    <!-- Display settings screen, deactivation button action for custom schedule [CHAR LIMIT=40] -->
    <string name="night_display_activation_off_custom">Turn off until <xliff:g name="time" example="10 PM">%1$s</xliff:g></string>

    <!-- Sound & display settings screen, setting option name to change screen timeout -->
    <string name="screen_timeout">Sleep</string>
    <!-- Sound & display settings screen, setting option name to change screen timeout [CHAR LIMIT=30] -->
    <string name="screen_timeout_title">Screen turns off</string>
    <!-- Sound & display settings screen, setting option summary to change screen timeout -->
    <string name="screen_timeout_summary">After <xliff:g id="timeout_description">%1$s</xliff:g> of inactivity</string>
    <!-- Wallpaper settings title [CHAR LIMIT=30] -->
    <string name="wallpaper_settings_title">Wallpaper</string>
    <!-- Wallpaper settings summary when default wallpaper is used [CHAR LIMIT=NONE] -->
    <string name="wallpaper_settings_summary_default">Default</string>
    <!-- Wallpaper settings summary when wallpaper has been updated [CHAR LIMIT=NONE] -->
    <string name="wallpaper_settings_summary_custom">Custom</string>
    <!-- Wallpaper suggestion title [CHAR LIMIT=46] -->
    <string name="wallpaper_suggestion_title">Change wallpaper</string>
    <!-- Wallpaper suggestion summary [CHAR LIMIT=55] -->
    <string name="wallpaper_suggestion_summary">Personalize your screen</string>
    <!-- Wallpaper settings fragment title [CHAR LIMIT=30] -->
    <string name="wallpaper_settings_fragment_title">Choose wallpaper from</string>
    <!-- Display settings screen, trigger for screen saver options -->
    <string name="screensaver_settings_title">Screen saver</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when docked or asleep and charging -->
    <string name="screensaver_settings_summary_either_long">While charging or docked</string>
    <!-- Dream settings screen, dialog option, activated when docked or asleep and charging -->
    <string name="screensaver_settings_summary_either_short">Either</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when asleep and charging -->
    <string name="screensaver_settings_summary_sleep">While charging</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when docked  -->
    <string name="screensaver_settings_summary_dock">While docked</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated never  -->
    <string name="screensaver_settings_summary_never">Never</string>
    <!-- Display settings screen, summary for screen saver options, screen saver is turned off -->
    <string name="screensaver_settings_summary_off">Off</string>
    <!-- Dream settings screen, caption for when dreams are disabled -->
    <string name="screensaver_settings_disabled_prompt">To control what happens when the phone is docked and/or sleeping, turn screen saver on.</string>
    <!-- Dream settings screen, action label, when to dream -->
    <string name="screensaver_settings_when_to_dream">When to start</string>
    <!-- Dream settings screen, action label, current selected screen saver -->
    <string name="screensaver_settings_current">Current screen saver</string>
    <!-- Dream settings screen, button label to start dreaming -->
    <string name="screensaver_settings_dream_start">Start now</string>
    <!-- Dream settings screen, button label for settings for a specific screensaver -->
    <string name="screensaver_settings_button">Settings</string>
    <!-- Sound & display settings screen, setting option name to change whether the screen adjusts automatically based on lighting conditions -->
    <string name="automatic_brightness">Automatic brightness</string>
    <!-- [CHAR LIMIT=40] Display settings screen, setting option name to change whether the device wakes up when a lift gesture is detected. -->
    <string name="lift_to_wake_title">Lift to wake</string>

    <!-- [CHAR LIMIT=30] Title of the preference that opens the Ambient display settings screen. -->
    <string name="ambient_display_screen_title">Ambient display</string>

    <!-- [CHAR LIMIT=50] Summary of the preference that opens the Ambient display settings screen, when Ambient display is set to be always on -->
    <string name="ambient_display_screen_summary_always_on">Always on / Increased battery usage</string>
    <!-- [CHAR LIMIT=30] Summary of the preference that opens the Ambient display settings screen, when Ambient display is set to show when new notifications come in. -->
    <string name="ambient_display_screen_summary_notifications">New notifications</string>
    <!-- [CHAR LIMIT=30] Category title for the settings that control when Ambient display shows. -->
    <string name="ambient_display_category_triggers">When to show</string>
    <!-- [CHAR LIMIT=30] Ambient display screen, title for setting to change whether the ambient display feature is triggered for new incoming notifications. -->
    <string name="doze_title">New notifications</string>
    <!-- [CHAR LIMIT=NONE] Ambient display screen, summary for setting to change whether the ambient display feature is triggered for new incoming notifications. -->
    <string name="doze_summary">Wake screen when you receive notifications</string>
    <!-- [CHAR LIMIT=30] Display settings screen, setting option name to change whether the always-on ambient display feature is enabled. -->
    <string name="doze_always_on_title">Always on</string>
    <!-- [CHAR LIMIT=NONE] Display settings screen, setting description for the always-on ambient display feature. -->
    <string name="doze_always_on_summary">Show time, notification icons, and other info. Increased battery usage.</string>
    <!-- [CHAR LIMIT=30] Sound & display settings screen, setting option name to change font size -->
    <string name="title_font_size">Font size</string>
    <!-- Summary for Font size. Lets the user know that this will make text larger or smaller. Appears in the accessibility portion of setup wizard. [CHAR LIMIT=NONE] -->
    <string name="short_summary_font_size">Make text larger or smaller</string>
    <!-- Sound & display settings screen, setting option summary displaying the currently selected font size -->
    <string name="summary_font_size" translatable="false">%1$s</string>

    <!-- SIM lock settings title  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings">SIM card lock settings</string>
    <!-- Security & screen lock settings screen, SIM card lock setting option name  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings_category">SIM card lock</string>
    <!-- Security & screen lock settings screen, SIM card lock setting summary when off [CHAR LIMIT=NONE] -->
    <string name="sim_lock_settings_summary_off">Off</string>
    <!-- Security & screen lock settings screen, SIM card lock setting summary when on [CHAR LIMIT=NONE] -->
    <string name="sim_lock_settings_summary_on">Locked</string>
    <!-- Security & location settings screen, section heading for settings related to sim card locking  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings_title">SIM card lock</string>
    <!-- SIM card lock settings screen, setting check box label  [CHAR LIMIT=40] -->
    <string name="sim_pin_toggle">Lock SIM card</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected  [CHAR LIMIT=40] -->
    <string name="sim_lock_on" product="tablet">Require PIN to use tablet</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected  [CHAR LIMIT=40] -->
    <string name="sim_lock_on" product="default">Require PIN to use phone</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear  [CHAR LIMIT=40] -->
    <string name="sim_lock_off" product="tablet">Require PIN to use tablet</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear  [CHAR LIMIT=40] -->
    <string name="sim_lock_off" product="default">Require PIN to use phone</string>
    <!-- SIM card lock settings screen, setting option name to change the SIM PIN  [CHAR LIMIT=40] -->
    <string name="sim_pin_change">Change SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enter_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enable_sim_lock">Lock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_disable_sim_lock">Unlock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enter_old">Old SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enter_new">New SIM PIN</string>
    <!-- SIM card lock settings screen, Re-type new PIN.  [CHAR LIMIT=40] -->
    <string name="sim_reenter_new">Re\u2011type new PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_change_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered  [CHAR LIMIT=40] -->
    <string name="sim_bad_pin">Incorrect PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match  [CHAR LIMIT=40] -->
    <string name="sim_pins_dont_match">PINs don\u2019t match</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN  [CHAR LIMIT=40] -->
    <string name="sim_change_failed">Can\u2019t change PIN.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when the entered PIN is correct [CHAR LIMIT=40] -->
    <string name="sim_change_succeeded">SIM PIN changed successfully</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN [CHAR LIMIT=40] -->
    <string name="sim_lock_failed">Can\u2019t change SIM card lock state.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: [CHAR LIMIT=40] -->
    <string name="sim_enter_ok">OK</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: [CHAR LIMIT=40] -->
    <string name="sim_enter_cancel">Cancel</string>
    <!-- Multiple SIMs found title.  [CHAR LIMIT=40] -->
    <string name="sim_multi_sims_title">Multiple SIMs found</string>
    <!-- Multiple SIMs found summary.  [CHAR LIMIT=100] -->
    <string name="sim_multi_sims_summary">Choose the SIM you prefer for mobile data.</string>
    <!-- Title asking user if they wish to change the default sim for cellular data.  [CHAR LIMIT=30] -->
    <string name="sim_change_data_title">Change data SIM?</string>
    <!-- Message confirming the user wishes to change the default data SIM from one to another.  [CHAR LIMIT=NONE] -->
    <string name="sim_change_data_message">Use <xliff:g id="new_sim">%1$s</xliff:g> instead of <xliff:g id="old_sim">%2$s</xliff:g> for mobile data?</string>
    <!-- Title for the dialog asking to user to change the preferred SIM  [CHAR LIMIT=30] -->
    <string name="sim_preferred_title">Update preferred SIM card?</string>
    <!-- Message for the dialog asking to user to change the preferred SIM  [CHAR LIMIT=NONE] -->
    <string name="sim_preferred_message"><xliff:g id="new_sim">%1$s</xliff:g> is the only SIM in your device. Do you want to use this SIM for mobile data, calls, and SMS messages?</string>

    <!-- Instructions telling the user that they entered the wrong SIM PIN for the last time.
         Displayed in a dialog box.  [CHAR LIMIT=100] -->
    <string name="wrong_pin_code_pukked">Incorrect SIM PIN code you must now contact your carrier to unlock your device.</string>
    <!-- Instructions telling the user that they entered the wrong SIM PIN while trying to unlock the keyguard.  Displayed in a dialog box.  [CHAR LIMIT=100] -->
    <plurals name="wrong_pin_code">
        <item quantity="one">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempt before you must contact your carrier to unlock your device.</item>
        <item quantity="other">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempts.</item>
    </plurals>
    <!-- Instructions telling the user that the operation to unlock the keyguard with SIM PIN failed. Displayed in one line in a large font.  [CHAR LIMIT=40] -->
    <string name="pin_failed">SIM PIN operation failed!</string>

    <!-- Advanced (used for diagnostics) device info activity title [CHAR LIMIT=40] -->
    <string name="device_info_settings" product="tablet">Tablet status</string>
    <!-- Advanced (used for diagnostics) device info activity title [CHAR LIMIT=40] -->
    <string name="device_info_settings" product="default">Phone status</string>

    <!-- About phone screen, list item title.  Takes the user to the screen for seeing and installing system updates. [CHAR LIMIT=40] -->
    <string name="system_update_settings_list_item_title">System updates</string>
    <!-- About phone screen, list item summary.  Takes the user to the screen for seeing and installing system updates. [CHAR LIMIT=40] -->
    <string name="system_update_settings_list_item_summary">""</string>

    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
    <string name="firmware_version">Android version</string>
    <!-- About phone screen, dialog title for showing device software information such as android version, security patch level, etc  [CHAR LIMIT=60] -->
    <string name="firmware_title">Android</string>
    <!-- About phone screen, status item label  [CHAR LIMIT=60] -->
    <string name="security_patch">Android security patch level</string>
    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
    <string name="model_info">Model</string>
    <!-- About phone screen, status item summary  [CHAR LIMIT=40] -->
    <string name="model_summary">Model&#58; %1$s</string>
    <!-- About phone screen, dialog title for showing hardware information such as model, serial number, etc.[CHAR LIMIT=60] -->
    <string name="hardware_info">Model &amp; hardware</string>
    <!-- Label for device's hardware revision value [CHAR LIMIT=40] -->
    <string name="hardware_revision">Hardware version</string>
    <!-- About phone screen, fcc equipment id label  [CHAR LIMIT=40] -->
    <string name="fcc_equipment_id">Equipment ID</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="baseband_version">Baseband version</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="kernel_version">Kernel version</string>
    <!-- About phone screen,  setting option name  [CHAR LIMIT=40] -->
    <string name="build_number">Build number</string>

    <!-- About phone screen, show when a value of some status item is unavailable. -->
    <string name="device_info_not_available">Not available</string>
    <!-- About phone screen, phone status screen title -->
    <string name="device_status_activity_title">Status</string>
    <!-- About phone screen, title of the item to go into the Phone status screen -->
    <string name="device_status">Status</string>
    <!-- About tablet screen, summary of the item that takes you to tablet status screen -->
    <string name="device_status_summary" product="tablet">Status of the battery, network, and other information</string>
    <!-- About phone screen, summary of the item to go into the phone status screen -->
    <string name="device_status_summary" product="default">Phone number, signal, etc.</string>
    <!-- Main settings screen item's title to go into the storage settings screen [CHAR LIMIT=25] -->
    <string name="storage_settings" >Storage</string>
    <!-- Main settings screen item's title to go into the storage & USB settings screen [CHAR LIMIT=25] -->
    <string name="storage_usb_settings" >Storage</string>
    <!-- Storage settings screen title -->
    <string name="storage_settings_title">Storage settings</string>
    <!-- [CHAR LIMIT=100] Main settings screen item's summary for the SD card and storage settings -->
    <string name="storage_settings_summary" product="nosdcard">Unmount USB storage, view available storage</string>
    <!-- [CHAR LIMIT=100] Main settings screen item's summary for the SD card and storage settings -->
    <string name="storage_settings_summary" product="default">Unmount SD card, view available storage</string>
    <!-- About phone screen, title for IMEI for multi-sim devices -->
    <string name="imei_multi_sim">IMEI (sim slot %1$d)</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_imei">IMEI</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_imei_sv">IMEI SV</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_iccid">ICCID</string>
    <!-- About tablet, status item title.  The Mobile Directory Number [CHAR LIMIT=40] -->
    <string name="status_number" product="tablet">MDN</string>
    <!-- About phone, status item title.  The phone number of the current device [CHAR LIMIT=40] -->
    <string name="status_number" product="default">Phone number</string>
    <!-- About tablet, status item title for multi-sim devices.  The Mobile Directory Number [CHAR LIMIT=40] -->
    <string name="status_number_sim_slot" product="tablet">MDN (sim slot %1$d)</string>
    <!-- About phone, status item title for multi-sim devices.  The phone number of the current device [CHAR LIMIT=40] -->
    <string name="status_number_sim_slot" product="default">Phone number (sim slot %1$d)</string>
    <!-- About tablet, status item title.  The Mobile Directory Number [CHAR LIMIT=30] -->
    <string name="status_number_sim_status" product="tablet">MDN on SIM</string>
    <!-- About phone, status item title.  The phone number of the current device [CHAR LIMIT=30] -->
    <string name="status_number_sim_status" product="default">Phone number on SIM</string>
    <!-- About phone, status item title.  The phone MIN number of the current device.-->
    <string name="status_min_number">MIN</string>
    <!-- About phone, status item title.  The phone MSID number of the current device.-->
    <string name="status_msid_number">MSID</string>
    <!-- About phone, status item title.  The phone PRL Version of the current device.-->
    <string name="status_prl_version">PRL version</string>
    <!-- About phone screen, title for MEID for multi-sim devices -->
    <string name="meid_multi_sim">MEID (sim slot %1$d)</string>
    <!-- About phone, status item title.  The phone MEID number of the current LTE/CDMA device. [CHAR LIMIT=30] -->
    <string name="status_meid_number">MEID</string>
    <!-- About phone, status item title.  The ICCID of the current LTE device. [CHAR LIMIT=30] -->
    <string name="status_icc_id">ICCID</string>
    <!-- About phone, status item title for the type of data phone network we're connected to, for example 3G or Edge or GPRS -->
    <string name="status_data_network_type">Mobile data network type</string>
    <!-- About phone, status item title for the type of voice phone network we're connected to, for example 3G or Edge or GPRS -->
    <string name="status_voice_network_type">Mobile voice network type</string>
    <!-- About phone, status item title for the latest area info cell broadcast received (Brazil only). -->
    <string name="status_latest_area_info">Operator info</string>
    <!-- About phone, status item title. The status of data access.  For example, the value may be "Connected" -->
    <string name="status_data_state">Mobile network state</string>
    <!-- About phone, status item title. The ID of embedded SIM card. -->
    <string name="status_esim_id">EID</string>
    <!-- About phone, status item title. The status of whether we have service.  for example, the value may be "In service" -->
    <string name="status_service_state">Service state</string>
    <!-- About phone, status item title. The  current cell tower signal strength -->
    <string name="status_signal_strength">Signal strength</string>
    <!-- About phone, status item title, The status for roaming.  For example, the value might be "Not roaming" -->
    <string name="status_roaming">Roaming</string>
    <!-- About phone, status item title. The cell carrier that the user is connected to.  -->
    <string name="status_operator">Network</string>
    <!-- About phone, status item title.  The MAC address of the Wi-Fi network adapter. -->
    <string name="status_wifi_mac_address">Wi\u2011Fi MAC address</string>
    <!-- About phone, status item title.  The bluetooth adapter's hardware address-->
    <string name="status_bt_address">Bluetooth address</string>
    <!-- About phone, status item title.  The hardware serial number. [CHAR LIMIT=30]-->
    <string name="status_serial_number">Serial number</string>
    <!-- About phone, status item title.  How long the device has been running since its last reboot. -->
    <string name="status_up_time">Up time</string>
    <!-- About phone, status item title.  How much time the device has had its main CPU awake. -->
    <string name="status_awake_time">Awake time</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the phone's internal storage  -->
    <string name="internal_memory">Internal storage</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the SD card [CHAR LIMIT=30] -->
    <string name="sd_memory" product="nosdcard">USB storage</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the SD card -->
    <string name="sd_memory" product="default">SD card</string>
    <!-- SD card & phone storage settings title. The amount of free space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section. -->
    <string name="memory_available">Available</string>
    <!-- SD card & phone storage settings title. The amount of free space for some storage partition when the volume is read-only. [CHAR LIMIT=64] -->
    <string name="memory_available_read_only">Available (read-only)</string>
    <!-- SD card & phone storage settings screen heading.  The total amount of storage space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section -->
    <string name="memory_size">Total space</string>
    <!-- SD card & phone storage settings summary. Displayed when the total memory usage is being calculated. Will be replaced with a number like "12.3 GB" when finished calucating. [CHAR LIMIT=30] -->
    <string name="memory_calculating_size">Calculating\u2026</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of applications installed. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_apps_usage">Apps &amp; app data</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of media on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_media_usage">Media</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of /sdcard/Download on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_downloads_usage">Downloads</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of all pictures, videos in /sdcard/DCIM, /sdcard/Pictures folders on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_dcim_usage">Pictures, videos</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of audio files in /sdcard on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_music_usage">Audio (music, ringtones, podcasts, etc.)</string>
    <!-- SD card & phone storage settings title. Displayed as a title when showing the total usage of misc files on the device. Below it will be a number like "123.4 MB" indicating used storage. [CHAR LIMIT=50] -->
    <string name="memory_media_misc_usage">Other files</string>
    <!-- Storage item representing all cached data on device. [CHAR LIMIT=48] -->
    <string name="memory_media_cache_usage">Cached data</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   [CHAR LIMIT=25] -->
    <string name="sd_eject" product="nosdcard">Unmount shared storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   -->
    <string name="sd_eject" product="default">Unmount SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   [CHAR LIMIT=30] -->
    <string name="sd_eject_summary" product="nosdcard">Unmount the internal USB storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   -->
    <string name="sd_eject_summary" product="default">Unmount the SD card so you can safely remove it</string>
    <!-- SD card & phone storage settings item title for toggling PTP mode on and off.  When PTP mode is on the device will appear on the USB bus as a PTP camera device instead of an MTP music player.   -->

    <!-- SD card & phone storage settings item summary that is displayed when no SD card is inserted.  This version of the string can probably never come up on current hardware. [CHAR LIMIT=25] -->
    <string name="sd_insert_summary" product="nosdcard">Insert USB storage for mounting</string>
    <!-- SD card & phone storage settings item summary that is displayed when no SD card is inserted -->
    <string name="sd_insert_summary" product="default">Insert an SD card for mounting</string>

    <!-- Storage setting item that will mount USB storage if it unmounted. A user should never see this. [CHAR LIMIT=25] -->
    <string name="sd_mount" product="nosdcard">Mount USB storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone mounting the SD card. -->
    <string name="sd_mount" product="default">Mount SD card</string>

    <!-- Subtext for Mount USB storage in Storage settings. User should never see this since we use automount. -->
    <string name="sd_mount_summary" product="nosdcard"></string>
    <!-- Subtext for Mount SD Card in Storage settings. User should never see this since we use automount. -->
    <string name="sd_mount_summary" product="default"></string>
    <!-- SD card & phone storage settings item title that will result in the phone formatting the USB storage.   [CHAR LIMIT=25] -->
    <string name="sd_format" product="nosdcard">Erase USB storage</string>
    <!-- SD card & phone storage settings item title that will result in the phone formatting the SD card.   [CHAR LIMIT=25] -->
    <string name="sd_format" product="default">Erase SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.   [CHAR LIMIT=80] -->
    <string name="sd_format_summary" product="nosdcard">Erases all data on the internal USB storage, such as music and photos</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.   [CHAR LIMIT=80] -->
    <string name="sd_format_summary" product="default">Erases all data on the SD card, such as music and photos</string>
    <!-- SD card status when it is mounted as read only. Will be appended to size, starts with an unbreakable space -->

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

    <!-- SD card & phone storage settings item summary that will result in the phone connected to PC and MTP/PTP enabled.   [CHAR LIMIT=80] -->
    <string name="mtp_ptp_mode_summary">MTP or PTP function is active</string>

    <!-- SD card eject confirmation dialog title   [CHAR LIMIT=25] -->
    <string name="dlg_confirm_unmount_title" product="nosdcard">Unmount USB storage?</string>
    <!-- SD card eject confirmation dialog title   -->
    <string name="dlg_confirm_unmount_title" product="default">Unmount SD card?</string>
    <!-- SD card eject confirmation dialog  [CHAR LIMIT=NONE] -->
    <string name="dlg_confirm_unmount_text" product="nosdcard">If you unmount the USB storage, some apps you are using will stop and may be unavailable until you remount the USB storage.</string>
    <!-- SD card eject confirmation dialog  -->
    <string name="dlg_confirm_unmount_text" product="default">If you unmount the SD card, some apps you are using will stop and may be unavailable until you remount the SD card.</string>
    <!-- SD card eject error dialog title   [CHAR LIMIT=30] -->
    <string name="dlg_error_unmount_title" product="nosdcard"></string>
    <!-- SD card eject error dialog title   -->
    <string name="dlg_error_unmount_title" product="default"></string>
    <!-- SD card eject error dialog text   [CHAR LIMIT=NONE] -->
    <string name="dlg_error_unmount_text" product="nosdcard">Couldn\u2019t unmount USB storage. Try again later.</string>
    <!-- SD card eject error dialog text   -->
    <string name="dlg_error_unmount_text" product="default">Couldn\u2019t unmount SD card. Try again later.</string>
    <!-- SD card unmount informative text   [CHAR LIMIT=NONE] -->
    <string name="unmount_inform_text" product="nosdcard">USB storage will be unmounted.</string>
    <!-- SD card unmount informative text   [CHAR LIMIT=NONE] -->
    <string name="unmount_inform_text" product="default">SD card will be unmounted.</string>
    <!-- SD card eject progress title   -->
    <string name="sd_ejecting_title">Unmounting</string>
    <!-- SD card eject progress text   -->
    <string name="sd_ejecting_summary">Unmount in progress</string>

    <!-- Settings item title when storage is running low [CHAR LIMIT=32] -->
    <string name="storage_low_title">Storage space is running out</string>
    <!-- Settings item summary when storage is running low [CHAR LIMIT=NONE] -->
    <string name="storage_low_summary">Some system functions, such as syncing, may not work correctly. Try to free space by deleting or unpinning items, such as apps or media content.</string>

    <!-- Storage setting.  Menu option for renaming a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_rename">Rename</string>
    <!-- Storage setting.  Menu option for mounting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_mount">Mount</string>
    <!-- Storage setting.  Menu option for unmounting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_unmount">Eject</string>
    <!-- Storage setting.  Menu option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format">Format</string>
    <!-- Storage setting.  Menu option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format_public">Format as portable</string>
    <!-- Storage setting.  Menu option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format_private">Format as internal</string>
    <!-- Storage setting.  Menu option for migrating data to a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_migrate">Migrate data</string>
    <!-- Storage setting.  Menu option for forgetting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_forget">Forget</string>
    <!-- Storage setting.  Menu option for setting up a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_set_up">Set up</string>
    <!-- Storage setting.  Menu option for exploring a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_explore">Explore</string>
    <!-- Storage setting. Menu option for using the deletion helper. [CHAR LIMIT=30] -->
    <string name="storage_menu_free">Free up space</string>
    <!-- Storage setting. Menu option for accessing the storage manager settings. [CHAR LIMIT=30] -->
    <string name="storage_menu_manage">Manage storage</string>

    <!-- Storage setting.  Title for USB transfer settings [CHAR LIMIT=30]-->
    <string name="storage_title_usb">USB computer connection</string>
    <!-- Storage setting.  USB connection category [CHAR LIMIT=30]-->
    <string name="usb_connection_category">Connect as</string>
    <!-- Storage setting.  Title for MTP checkbox [CHAR LIMIT=30]-->
    <string name="usb_mtp_title">Media device (MTP)</string>
    <!-- Storage setting.  Summary for MTP checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_mtp_summary">Lets you transfer media files on Windows, or using Android File Transfer on Mac (see www.android.com/filetransfer)</string>
    <!-- Storage setting.  Title for PTP checkbox [CHAR LIMIT=30]-->
    <string name="usb_ptp_title">Camera (PTP)</string>
    <!-- Storage setting.  Summary for PTP checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_ptp_summary">Lets you transfer photos using camera software, and transfer any files on computers that don\u2019t support MTP</string>
    <!-- Storage setting.  Title for MIDI checkbox [CHAR LIMIT=30]-->
    <string name="usb_midi_title">MIDI</string>
    <!-- Storage setting.  Summary for MIDI checkbox [CHAR LIMIT=NONE]-->
    <string name="usb_midi_summary">Lets MIDI enabled applications work over USB with MIDI software on your computer.</string>

    <!-- Section header above list of other users storage [CHAR LIMIT=32] -->
    <string name="storage_other_users">Other users</string>

    <!-- Section header above list of internal storage devices [CHAR LIMIT=30]-->
    <string name="storage_internal_title">Device storage</string>
    <!-- Section header above list of external storage devices [CHAR LIMIT=30]-->
    <string name="storage_external_title">Portable storage</string>

    <!-- Summary of a single storage volume, constrasting available and total storage space. [CHAR LIMIT=48]-->
    <string name="storage_volume_summary"><xliff:g id="used" example="1.2GB">%1$s</xliff:g> used of <xliff:g id="total" example="32GB">%2$s</xliff:g></string>
    <!-- Summary of a single storage volume used space. [CHAR LIMIT=24] -->
    <string name="storage_size_large"><xliff:g id="number" example="128">^1</xliff:g><small><small> <xliff:g id="unit" example="KB">^2</xliff:g></small></small></string>
    <!-- Summary of a single storage volume total space. [CHAR LIMIT=48]-->
    <string name="storage_volume_used">Used of <xliff:g id="total" example="32GB">%1$s</xliff:g></string>
    <!-- Summary of a single storage volume total space. [CHAR LIMIT=48]-->
    <string name="storage_volume_used_total">Total used of <xliff:g id="total" example="32GB">%1$s</xliff:g></string>

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

    <!-- Toast informing that storage unmount operation was successful. [CHAR LIMIT=64]-->
    <string name="storage_unmount_success"><xliff:g id="name" example="SD card">%1$s</xliff:g> is safely ejected</string>
    <!-- Toast informing that storage unmount operation failed. [CHAR LIMIT=64]-->
    <string name="storage_unmount_failure">Couldn\u2019t safely eject <xliff:g id="name" example="SD card">%1$s</xliff:g></string>

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

    <!-- Title of dialog prompting user to rename a storage volume [CHAR LIMIT=32]-->
    <string name="storage_rename_title">Rename storage</string>

    <!-- Dialog body informing user about an unmounted storage device. [CHAR LIMIT=NONE]-->
    <string name="storage_dialog_unmounted">This <xliff:g id="name" example="SD card">^1</xliff:g> is safely ejected, but still available.
\n\nTo use this <xliff:g id="name" example="SD card">^1</xliff:g>, you have to mount it first.</string>

    <!-- Dialog body informing user about an unmountable storage device. [CHAR LIMIT=NONE]-->
    <string name="storage_dialog_unmountable">This <xliff:g id="name" example="SD card">^1</xliff:g> is corrupted.
\n\nTo use this <xliff:g id="name" example="SD card">^1</xliff:g>, you have to set it up first.</string>

    <!-- Dialog body informing user about an unsupported storage device. [CHAR LIMIT=NONE]-->
    <string name="storage_dialog_unsupported">This device doesn\u2019t support this <xliff:g id="name" example="SD card">^1</xliff:g>.
\n\nTo use this <xliff:g id="name" example="SD card">^1</xliff:g> with this device, you have to set it up first.</string>

    <!-- Body of dialog informing user about consequences of formatting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_format_details">After formatting, you can use this <xliff:g id="name" example="SD card">^1</xliff:g> in other devices.
\n\nAll data on this <xliff:g id="name" example="SD card">^1</xliff:g> will be erased. Consider backing up first.
\n\n<b>Back up photos &amp; other media</b>
\nMove your media files to alternative storage on this device, or transfer them to a computer using a USB cable.
\n\n<b>Back up apps</b>
\nAll apps stored on this <xliff:g id="name" example="SD card">^1</xliff:g> will be uninstalled and their data will be erased. To keep these apps, move them to alternative storage on this device.</string>

    <!-- Body of dialog informing user about consequences of ejecting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_unmount_details"><b>When you eject this <xliff:g id="name" example="SD card">^1</xliff:g>, apps stored on it will stop working, and media files stored on it will not be available until it is reinserted.</b>
\n\nThis <xliff:g id="name" example="SD card">^1</xliff:g> is formatted to work on this device only.  It won\u2019t work on any others.</string>

    <!-- Body of dialog informing user about consequences of forgetting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_forget_details">To use the apps, photos, or data this <xliff:g id="name" example="SD card">^1</xliff:g> contains, reinsert it.
\n\nAlternatively, you can choose to forget this storage if the device isn\u2019t available.
\n\nIf you choose to forget, all the data the device contains will be lost forever.
\n\nYou can reinstall the apps later, but their data stored on this device will be lost.</string>

    <!-- Title of dialog confirming that user wants to forget an internal storage device [CHAR LIMIT=32]-->
    <string name="storage_internal_forget_confirm_title">Forget <xliff:g id="name" example="SD card">^1</xliff:g>?</string>
    <!-- Body of dialog confirming that user wants to forget an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_forget_confirm">All the apps, photos, and data stored on this <xliff:g id="name" example="SD card">^1</xliff:g> will be lost forever.</string>

    <!-- Item title describing storage used by apps [CHAR LIMIT=48]-->
    <string name="storage_detail_apps">Apps</string>
    <!-- Item title describing storage used by images [CHAR LIMIT=48]-->
    <string name="storage_detail_images">Images</string>
    <!-- Item title describing storage used by videos [CHAR LIMIT=48]-->
    <string name="storage_detail_videos">Videos</string>
    <!-- Item title describing storage used by audio [CHAR LIMIT=48]-->
    <string name="storage_detail_audio">Audio</string>
    <!-- Item title describing storage used by cached data [CHAR LIMIT=48]-->
    <string name="storage_detail_cached">Cached data</string>
    <!-- Item title describing storage used by other data [CHAR LIMIT=48]-->
    <string name="storage_detail_other">Other</string>
    <!-- Item title describing internal storage used by the Android System [CHAR LIMIT=48]-->
    <string name="storage_detail_system">System</string>
    <!-- Item title that will launch a file explorer [CHAR LIMIT=48]-->
    <string name="storage_detail_explore">Explore <xliff:g id="name" example="SD card">^1</xliff:g></string>

    <!-- Body of dialog informing user about other files on a storage device [CHAR LIMIT=NONE]-->
    <string name="storage_detail_dialog_other">Other includes shared files saved by apps, files downloaded from the internet or Bluetooth, Android files, and so on.
\n\nTo see the visible contents of this <xliff:g id="name" example="SD card">^1</xliff:g>, tap Explore.</string>

    <!-- Body of dialog informing user about the storage used by the Android System [CHAR LIMIT=NONE]-->
    <string name="storage_detail_dialog_system">System includes files used to run Android version <xliff:g id="version" example="8.0">%s</xliff:g></string>

    <!-- Body of dialog informing user about other users on a storage device [CHAR LIMIT=NONE]-->
    <string name="storage_detail_dialog_user"><xliff:g id="user" example="Guest user">^1</xliff:g> may have saved photos, music, apps, or other data, using <xliff:g id="size" example="1.2 GB">^2</xliff:g> of storage.
\n\nTo view details, switch to <xliff:g id="user" example="Guest user">^1</xliff:g>.</string>

    <!-- Title of wizard step prompting user to setup a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_init_title">Set up your <xliff:g id="name" example="SD card">^1</xliff:g></string>
    <!-- Title of wizard choice to use storage device as external storage [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_external_title">Use as portable storage</string>
    <!-- Summary of wizard choice to use storage device as external storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_init_external_summary">For moving photos and other media between devices.</string>
    <!-- Title of wizard choice to use storage device as internal storage [CHAR LIMIT=64] -->
    <string name="storage_wizard_init_internal_title">Use as internal storage</string>
    <!-- Summary of wizard choice to use storage device as internal storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_init_internal_summary">For storing anything on this device only, including apps and photos. Requires formatting that prevents it from working with other devices.</string>

    <!-- Title of wizard step prompting user to format a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_title">Format as internal storage</string>
    <!-- Body of wizard step prompting user to format a storage device [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_confirm_body">This requires the <xliff:g id="name" example="SD card">^1</xliff:g> to be formatted to make it secure.
\n\nAfter formatting, this <xliff:g id="name" example="SD card">^1</xliff:g> will only work in this device.
\n\n<b>Formatting erases all data currently stored on the <xliff:g id="name" example="SD card">^1</xliff:g>.</b> To avoid losing the data, consider backing it up.
    </string>

    <!-- Title of wizard step prompting user to format a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_public_title">Format as portable storage</string>
    <!-- Body of wizard step prompting user to format a storage device [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_confirm_public_body">This requires the <xliff:g id="name" example="SD card">^1</xliff:g> to be formatted.
\n\n<b>Formatting erases all data currently stored on the <xliff:g id="name" example="SD card">^1</xliff:g>.</b> To avoid losing the data, consider backing it up.
    </string>

    <!-- Next button text of wizard step prompting user to format a storage device [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_confirm_next">Erase &amp; format</string>

    <!-- In-progress title. This string lets the user know the SD card is being formatted. The user won't be able to proceed with setup until this step is finished. The placeholder is for the name of the device (e.g. brand name of the SD card). [CHAR LIMIT=32] -->
    <string name="storage_wizard_format_progress_title">Formatting <xliff:g id="name" example="SD card">^1</xliff:g>\u2026</string>
    <!-- Subtext for a full-screen title. This string lets the user know that the SD card can't be removed during this process. The user won't be able to proceed with setup until this step is finished. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_format_progress_body">Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g> while it\u2019s being formatting.</string>

    <!-- Title of wizard step prompting user to migrate data to new storage [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_title">Move data to new storage</string>
    <!-- Body of wizard step prompting user to migrate data to new storage [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_body">You can move your photos, files, and some apps to this new <xliff:g id="name" example="SD card">^1</xliff:g>.
\n\nThe move takes about <xliff:g id="time" example="1 hour">^2</xliff:g> and will free <xliff:g id="size" example="1.2 GB">^3</xliff:g> on internal storage. Some apps won\u2019t work while it\u2019s underway.
    </string>

    <!-- Title of wizard choice to migrate data right now [CHAR LIMIT=64] -->
    <string name="storage_wizard_migrate_now">Move now</string>
    <!-- Title of wizard choice to migrate data at later time [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_later">Move later</string>

    <!-- Title of wizard step prompting user to start data migration [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_confirm_title">Move data now</string>
    <!-- Body of wizard step providing details about data migration [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_confirm_body"><b>The move takes about <xliff:g id="time" example="1 hour">^1</xliff:g>. It will free <xliff:g id="size" example="1.2 GB">^2</xliff:g> on <xliff:g id="name" example="Internal storage">^3</xliff:g>.</b></string>
    <!-- Title of wizard button prompting user to start data migration [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_confirm_next">Move</string>

    <!-- Title of wizard step showing migration progress [CHAR LIMIT=32] -->
    <string name="storage_wizard_migrate_progress_title">Moving data\u2026</string>

    <!-- Body of wizard step providing details about data migration [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_migrate_details">During the move:
\n\u2022 Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g>.
\n\u2022 Some apps won\u2019t work correctly.
\n\u2022 Keep the device charged.
    </string>

    <!-- Title of a full-screen message. This string lets the user know that their storage device is ready to use. They can tap a button at the bottom of the screen to complete the setup process. The placeholder is for the specific device (e.g. SD card, USB drive, etc.). [CHAR LIMIT=32] -->
    <string name="storage_wizard_ready_title">Your <xliff:g id="name" example="SD card">^1</xliff:g> is ready to use</string>
    <!-- Body of wizard step indicating that external storage is ready [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_external_body">Your <xliff:g id="name" example="SD card">^1</xliff:g> is all set to use with photos and other media.</string>
    <!-- Body of wizard step indicating that internal storage is ready [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_ready_internal_body">Your new <xliff:g id="name" example="SD card">^1</xliff:g> is working.
\n\nTo move photos, files, and app data to this device, go to Settings > Storage.
    </string>

    <!-- Title of wizard step prompting user to move an app [CHAR LIMIT=32] -->
    <string name="storage_wizard_move_confirm_title">Move <xliff:g id="app" example="Calculator">^1</xliff:g></string>
    <!-- Body of wizard step prompting user to move an app [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_move_confirm_body">Moving <xliff:g id="app" example="Calculator">^1</xliff:g> and its data to <xliff:g id="name" example="SD card">^2</xliff:g> will take only a few moments. You won\u2019t be able to use the app until the move is complete.
\n\nDon\u2019t remove the <xliff:g id="name" example="SD card">^2</xliff:g> during the move.
    </string>

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

    <!-- Title of wizard step showing app move progress [CHAR LIMIT=32] -->
    <string name="storage_wizard_move_progress_title">Moving <xliff:g id="app" example="Calculator">^1</xliff:g>\u2026</string>
    <!-- Body of wizard step showing app move progress [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_move_progress_body">Don\u2019t remove the <xliff:g id="name" example="SD card">^1</xliff:g> during the move.
\n\nThe <xliff:g id="app" example="Calculator">^2</xliff:g> app on this device won\u2019t be available until the move is complete.
    </string>
    <!-- Title of wizard button offering to cancel move [CHAR LIMIT=32] -->
    <string name="storage_wizard_move_progress_cancel">Cancel move</string>

    <!-- Title of wizard step prompting user to start data migration [CHAR LIMIT=NONE] -->
    <string name="storage_wizard_slow_body">This <xliff:g id="name" example="SD card">^1</xliff:g> appears to be slow.
\n\nYou can continue, but apps moved to this location may stutter and data transfers may take a long time.
\n\nConsider using a faster <xliff:g id="name" example="SD card">^1</xliff:g> for better performance.
</string>

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

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

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

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

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

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

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

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

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

    <!-- Phone info screen, section titles: -->
    <string name="battery_status_title">Battery status</string>
    <!-- Phone info screen, section titles: -->
    <string name="battery_level_title">Battery level</string>

    <!-- APN Settings -->
    <!-- APN settings screen title -->
    <string name="apn_settings">APNs</string>
    <!-- Screen title after user selects APNs setting option -->
    <string name="apn_edit">Edit access point</string>
    <!-- Edit access point label summary text when no value has been set -->
    <string name="apn_not_set">Not set</string>
    <!-- Edit access point labels: A label the user can give to the APN to allow him to differentiate it from the others -->
    <string name="apn_name">Name</string>
    <!-- Edit access point labels: The actual access point name-->
    <string name="apn_apn">APN</string>
    <!-- Edit access point labels: The addess of the proxy to use for this APN -->
    <string name="apn_http_proxy">Proxy</string>
    <!-- Edit access point labels: The port number of the proxy to use for this APN -->
    <string name="apn_http_port">Port</string>
    <!-- Edit access point labels: The username that will be used when conencting to this APN-->
    <string name="apn_user">Username</string>
    <!-- Edit access point labels: The password that will be used when connecting to this APN -->
    <string name="apn_password">Password</string>
    <!-- Edit access point labels: The server address to conenct to for this APN -->
    <string name="apn_server">Server</string>
    <!-- Edit access point labels: -->
    <string name="apn_mmsc">MMSC</string>
    <!-- Edit access point labels: The proxy to use for MMS (multimedia messages)-->
    <string name="apn_mms_proxy">MMS proxy</string>
    <!-- Edit access point labels: The port on the proxy used for MMS-->
    <string name="apn_mms_port">MMS port</string>
    <!-- Edit access point labels: -->
    <string name="apn_mcc">MCC</string>
    <!-- Edit access point labels: -->
    <string name="apn_mnc">MNC</string>
    <!-- Edit acces  point labels: Authenticaton type-->
    <string name="apn_auth_type">Authentication type</string>
    <!-- Authentication Typs: None -->
    <string name="apn_auth_type_none">None</string>
    <!-- Authentication Typs: PAP -->
    <string name="apn_auth_type_pap">PAP</string>
    <!-- Authentication Typs: CHAP -->
    <string name="apn_auth_type_chap">CHAP</string>
    <!-- Authentication Typs: PAP or CHAP -->
    <string name="apn_auth_type_pap_chap">PAP or CHAP</string>
    <!-- Edit access point labels: The type of APN -->
    <string name="apn_type">APN type</string>
    <!-- Edit access point labels: The protocol of the APN, e.g., "IPv4", "IPv6", or "IPv4/IPv6". -->
    <string name="apn_protocol">APN protocol</string>
    <!-- Edit access point labels: The protocol of the APN when roaming, e.g., "IPv4", "IPv6", or "IPv4/IPv6". -->
    <string name="apn_roaming_protocol">APN roaming protocol</string>
    <!-- Edit enable/disable of APN -->
    <string name="carrier_enabled">APN enable/disable</string>
    <string name="carrier_enabled_summaryOn">APN enabled</string>
    <string name="carrier_enabled_summaryOff">APN disabled</string>
    <!-- Edit Beaerer Info of APN -->
    <string name="bearer">Bearer</string>
    <!-- Edit Mvno Type Info of APN -->
    <string name="mvno_type">MVNO type</string>
    <!-- Edit Mvno Match Data Info of APN -->
    <string name="mvno_match_data">MVNO value</string>
    <!-- Edit access point screen menu option to delete this APN -->
    <string name="menu_delete">Delete APN</string>
    <!-- APNs screen menu option to create a brand spanking new APN -->
    <string name="menu_new">New APN</string>
    <!-- Edit access point screen menu option to save the user's changes for this APN to the persistent storage -->
    <string name="menu_save">Save</string>
    <!-- Edit access point screen menu option to discard the user's changes for this APN -->
    <string name="menu_cancel">Discard</string>
    <!-- APN error dialog title -->
    <string name="error_title"></string>
    <!-- APN error dialog messages: -->
    <string name="error_name_empty">The Name field can\u2019t be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_apn_empty">The APN can\u2019t be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_mcc_not3">MCC field must be 3 digits.</string>
    <!-- APN error dialog messages: -->
    <string name="error_mnc_not23">MNC field must be 2 or 3 digits.</string>
    <!-- APN error dialog messages: -->
    <string name="error_adding_apn_type">Carrier does not allow adding APNs of type %s.</string>
    <!-- The message of dialog indicated restoring default APN settings in progress -->
    <string name="restore_default_apn">Restoring default APN settings.</string>
    <!-- APNs screen menu option to reset default APN settings -->
    <string name="menu_restore">Reset to default</string>
    <!-- APNs screen toast message to inform reset default APN settings is completed -->
    <string name="restore_default_apn_completed">Reset default APN settings completed.</string>


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

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

    <!-- Reset Network -->
    <!-- Button title to reset Wi-Fi settings, Mobile data setting, bluetooth settings -->
    <string name="reset_network_title">Reset Wi-Fi, mobile &amp; Bluetooth</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset network settings [CHAR LIMIT=NONE] -->
    <string name="reset_network_desc">This will reset all network settings, including:\n\n<li>Wi\u2011Fi</li>\n<li>Mobile data</li>\n<li>Bluetooth</li>"</string>
    <!-- SD card & phone storage settings screen, title for the checkbox to let user decide whether erase eSIM data together [CHAR LIMIT=NONE] -->
    <string name="reset_esim_title">Also reset eSIM</string>
    <!-- SD card & phone storage settings screen, message for the checkbox to let user decide whether erase eSIM data together [CHAR LIMIT=NONE] -->
    <string name="reset_esim_desc">Erase all eSIMs on the phone. You\u2019ll have to contact your carrier to redownload your eSIMs. This will not cancel your mobile service plan.</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset network settings -->
    <string name="reset_network_button_text">Reset settings</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset settings button -->
    <string name="reset_network_final_desc">Reset all network settings? You can\u2019t undo this action!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset settings button -->
    <string name="reset_network_final_button_text">Reset settings</string>
    <!-- Reset settings confirmation screen title [CHAR LIMIT=30] -->
    <string name="reset_network_confirm_title">Reset?</string>
    <!-- Error message for users that aren't allowed to reset network settings [CHAR LIMIT=none] -->
    <string name="network_reset_not_available">Network reset is not available for this user</string>
    <!-- Reset settings complete toast text [CHAR LIMIT=75] -->
    <string name="reset_network_complete_toast">Network settings have been reset</string>
    <!-- Title of the error message shown when error happens during erase eSIM data [CHAR LIMIT=NONE] -->
    <string name="reset_esim_error_title">Cant\u2019t reset eSIMs</string>
    <!-- Message of the error message shown when error happens during erase eSIM data [CHAR LIMIT=NONE] -->
    <string name="reset_esim_error_msg">The eSIMs can\u2019tt be reset due to an error.</string>

    <!-- Master Clear -->
    <!-- Button title to factory data reset the entire device -->
    <string name="master_clear_title">Erase all data (factory reset)</string>
    <!-- Button title to factory data reset the entire device. The "(factory reset)" part is optional for translation. [CHAR LIMIT=30 BACKUP_MESSAGE_ID=3531267871084279512]-->
    <string name="master_clear_short_title">Erase all data (factory reset)</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc" product="tablet">"This will erase all data from your tablet\u2019s <b>internal storage</b>, including:\n\n<li>Your Google account</li>\n<li>System and app data and settings</li>\n<li>Downloaded apps</li>"</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc" product="default">"This will erase all data from your phone\u2019s <b>internal storage</b>, including:\n\n<li>Your Google account</li>\n<li>System and app data and settings</li>\n<li>Downloaded apps</li>"</string>
    <!-- SD card & phone storage settings screen, instructions and list of current accounts.  The list of accounts follows this text[CHAR LIMIT=NONE] -->
    <string name="master_clear_accounts" product="default">"\n\nYou are currently signed into the following accounts:\n"</string>
    <!-- SD card & phone storage settings screen, notification if other users are present on the device [CHAR LIMIT=NONE] -->
    <string name="master_clear_other_users_present" product="default">"\n\nThere are other users present on this device.\n"</string>
    <!-- SD card & phone storage settings screen, list of items in user data storage (USB storage or SD card) that will be erased during this operation [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_also_erases_external">"<li>Music</li>\n<li>Photos</li>\n<li>Other user data</li>"</string>
    <!-- SD card & phone storage settings screen, list of items on an eSIM (embedded SIM) that will be erased during this operation [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_also_erases_esim">"<li>eSIMs</li>"</string>
    <!-- SD card & phone storage settings screen, notification if there are eSIM (embedded SIM) profiles present that the user's mobile service plan will not be canceled [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_no_cancel_mobile_plan">"\n\nThis will not cancel your mobile service plan.</string>
    <!-- SD card & phone storage settings screen, instructions about whether to also erase the external storage (SD card) when erasing the internal storage [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_erase_external_storage" product="nosdcard">"\n\nTo clear music, pictures, and other user data, the <b>USB storage</b> needs to be erased."</string>
    <!-- SD card & phone storage settings screen, instructions about whether to also erase the external storage (SD card) when erasing the internal storage [CHAR LIMIT=NONE] -->
    <string name="master_clear_desc_erase_external_storage" product="default">"\n\nTo clear music, pictures, and other user data, the <b>SD card</b> needs to be erased."</string>
    <!-- SD card & phone storage settings screen, label for check box to erase USB storage [CHAR LIMIT=30] -->
    <string name="erase_external_storage" product="nosdcard">Erase USB storage</string>
    <!-- SD card & phone storage settings screen, label for check box to erase SD card [CHAR LIMIT=30] -->
    <string name="erase_external_storage" product="default">Erase SD card</string>
    <!-- SD card & phone storage settings screen, description for check box to erase USB storage [CHAR LIMIT=NONE] -->
    <string name="erase_external_storage_description" product="nosdcard">Erase all the data on the internal USB storage, such as music or photos</string>
    <!-- SD card & phone storage settings screen, description for check box to erase USB storage [CHAR LIMIT=NONE] -->
    <string name="erase_external_storage_description" product="default">Erase all the data on the SD card, such as music or photos</string>
    <!-- SD card & phone storage settings screen, label for check box to erase all the carriers information on the embedded SIM card [CHAR LIMIT=30] -->
    <string name="erase_esim_storage">Erase eSIM</string>
    <!-- SD card & phone storage settings screen, description for check box to erase eSIMs for default devices [CHAR LIMIT=NONE] -->
    <string name="erase_esim_storage_description" product="default">Erase all eSIMs on the phone. This will not cancel your mobile service plan.</string>
    <!-- SD card & phone storage settings screen, description for check box to erase eSIMs for tablets [CHAR LIMIT=NONE] -->
    <string name="erase_esim_storage_description" product="tablet">Erase all eSIMs on the tablet. This will not cancel your mobile service plan.</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="master_clear_button_text" product="tablet">Reset tablet</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="master_clear_button_text" product="default">Reset phone</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button -->
    <string name="master_clear_final_desc">Erase all your personal information and downloaded apps? You can\u2019t undo this action!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset phone button -->
    <string name="master_clear_final_button_text">Erase everything</string>
    <!-- Master clear failed message -->
    <string name="master_clear_failed">No reset was performed because the System Clear service isn\u2019t available.</string>
    <!-- Master clear confirmation screen title [CHAR LIMIT=30] -->
    <string name="master_clear_confirm_title">Reset?</string>
    <!-- Error message for users that aren't allowed to factory reset [CHAR LIMIT=none] -->
    <string name="master_clear_not_available">Factory reset is not available for this user</string>
    <!-- Master clear progress screen title [CHAR LIMIT=30] -->
    <string name="master_clear_progress_title" >Erasing</string>
    <!-- Master clear progress screen text [CHAR LIMIT=75] -->
    <string name="master_clear_progress_text">Please wait...</string>

    <!-- Main settings screen, Call settings title for item to go into the call settings -->
    <string name="call_settings_title">Call settings</string>
    <!-- Main settings screen, Call settings summary for item to go into call settings -->
    <string name="call_settings_summary">Set up voicemail, call forwarding, call waiting, caller ID</string>

    <!-- TODO: Remove them once the same entries in SettingsLib is translated. -->
    <!-- Tethering controls, item title to go into the tethering settings -->
    <!-- Tethering controls, item title to go into the tethering settings when only USB tethering is available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_usb">USB tethering</string>
    <!-- Tethering controls, item title to go into the tethering settings when only Wifi tethering is available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_wifi">Portable hotspot</string>
    <!-- Tethering controls, item title to go into the tethering settings when only Bluetooth tethering is available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_bluetooth">Bluetooth tethering</string>
    <!-- Tethering controls, item title to go into the tethering settings when USB and Bluetooth tethering are available [CHAR LIMIT=25]-->
    <string name="tether_settings_title_usb_bluetooth">Tethering</string>
    <!-- Tethering controls, item title to go into the tethering settings when USB, Bluetooth and Wifi tethering are available [CHAR LIMIT=60]-->
    <string name="tether_settings_title_all">Hotspot &amp; tethering</string>
    <!-- Tethering setting summary when both Wi-Fi hotspot and tether are turned on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_on_tether_on">Hotspot on, tethering</string>
    <!-- Tethering setting summary when Wi-Fi hotspot is on and tether is off [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_on_tether_off">Hotspot on</string>
    <!-- Tethering setting summary when Wi-Fi hotspot is off and tether is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_off_tether_on">Tethering</string>
    <!-- Tethering controls, footer note displayed when tethering is disabled because Data Saver mode is on [CHAR LIMIT=none]-->
    <string name="tether_settings_disabled_on_data_saver">"Can\u2019t tether or use portable hotspots while Data Saver is on"</string>

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

    <!-- Bluetooth Tethering settings-->
    <!-- Label for bluetooth tether checkbox [CHAR LIMIT=25]-->
    <string name="bluetooth_tether_checkbox_text">Bluetooth tethering</string>
    <!-- Bluetooth Tethering subtext [CHAR LIMIT=70]-->
    <string name="bluetooth_tethering_subtext" product="tablet">Share tablet\u2019s internet connection via Bluetooth</string>
    <!-- Bluetooth Tethering subtext [CHAR LIMIT=70]-->
    <string name="bluetooth_tethering_subtext" product="default">Share phone\u2019s internet connection via Bluetooth</string>
    <!-- Bluetooth tethering off subtext - shown when Bluetooth Tethering is turned off [CHAR LIMIT=80]-->
    <string name="bluetooth_tethering_off_subtext_config">Sharing this <xliff:g id="device_name">%1$d</xliff:g>\u2019s internet connection via Bluetooth</string>
    <!-- Bluetooth Tethering settings. Error message shown when trying to connect an 8th device [CHAR LIMIT=50]-->
    <string name="bluetooth_tethering_overflow_error">Can\u2019t tether to more than <xliff:g id="maxConnection">%1$d</xliff:g> devices.</string>
    <!-- Bluetooth Tethering settings.  Message for untethering from a bluetooth device [CHAR LIMIT=50]-->
    <string name="bluetooth_untether_blank"><xliff:g id="device_name">%1$s</xliff:g> will be untethered.</string>

    <!-- Tethering footer info [CHAR LIMIT=NONE]-->
    <string name="tethering_footer_info">Use hotspot and tethering to provide internet to other devices through your mobile data connection. Apps can also create a hotspot to share content with nearby devices.</string>

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

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

    <!-- Mobile plan [CHAR LIMIT=35]-->
    <string name="manage_mobile_plan_title" translatable="true">Mobile plan</string>

    <!-- SMS Application [CHAR LIMIT=35]-->
    <string name="sms_application_title" translatable="true">SMS app</string>
    <string name="sms_change_default_dialog_title" translatable="true">Change SMS app?</string>
    <string name="sms_change_default_dialog_text" translatable="true">Use <xliff:g id="new_app">%1$s</xliff:g> instead of <xliff:g id="current_app">%2$s</xliff:g> as your SMS app?</string>
    <string name="sms_change_default_no_previous_dialog_text" translatable="true">Use <xliff:g id="new_app">%s</xliff:g> as your SMS app?</string>

    <!-- Network Scorer Picker title [CHAR LIMIT=40]-->
    <string name="network_scorer_picker_title">Network rating provider</string>
    <string name="network_scorer_picker_none_preference">None</string>

    <!-- Wifi Assistant change wi-fi assistant title.  [CHAR LIMIT=40] -->
    <string name="network_scorer_change_active_dialog_title">Change Wi\u2011Fi assistant?</string>
    <!-- Wifi Assistant request message.  This message asks the user if it is okay for an app to become the Wifi Assistant instead of the current Wifi Assistant app. [CHAR LIMIT=100] -->
    <string name="network_scorer_change_active_dialog_text">Use <xliff:g id="new_app">%1$s</xliff:g> instead of <xliff:g id="current_app">%2$s</xliff:g> to manage your network connections?</string>
    <!-- Wifi Assistant request message.  This message asks the user if it is okay for an app to become the Wifi Assistant. [CHAR LIMIT=100] -->
    <string name="network_scorer_change_active_no_previous_dialog_text">Use <xliff:g id="new_app">%s</xliff:g> to manage your network connections?</string>

    <!-- The SIM operator is not known [CHAR_ LIMIT=50]-->
    <string name="mobile_unknown_sim_operator" translatable="true">Unknown SIM operator</string>

    <!-- There is no mobile provisiong website for the operator which is the firat parameter [CHAR_ LIMIT=50]-->
    <string name="mobile_no_provisioning_url"><xliff:g id="operator">%1$s</xliff:g> has no known provisioning website</string>

    <!-- Ask user to insert a SIM card [CHAR_ LIMIT=50]-->
    <string name="mobile_insert_sim_card" translatable="true">Please insert SIM card and restart</string>

    <!-- Ask user to connect to the internet [CHAR_ LIMIT=50]-->
    <string name="mobile_connect_to_internet" translatable="true">Please connect to the internet</string>

    <!-- Security & location settings screen, section header for settings relating to location -->
    <string name="location_title">My Location</string>
    <!-- [CHAR LIMIT=30] Title for managed profile location switch  -->
    <string name="managed_profile_location_switch_title">Location for work profile</string>
    <!-- [CHAR LIMIT=30] Location settings screen. It's a link that directs the user to a page that
      shows the location permission setting for each installed app -->
    <string name="location_app_level_permissions">App-level permissions</string>
    <!-- [CHAR LIMIT=42] 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're more than three recent location requests -->
    <string name="location_recent_location_requests_see_all">See all</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, sub category for location services -->
    <string name="location_category_location_services">Location services</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=30] Wireless background scanning settings screen, screen title -->
    <string name="location_scanning_screen_title">Scanning</string>
    <!-- [CHAR LIMIT=130] Preference title for Wi-Fi always scanning -->
    <string name="location_scanning_wifi_always_scanning_title">Wi\u2011Fi scanning</string>
    <!-- Preference description text for Wi-Fi always scanning -->
    <string name="location_scanning_wifi_always_scanning_description">Allow apps and services to scan for Wi\u2011Fi networks at any time, even when Wi\u2011Fi is off. This can be used, for example, to improve location-based features and services.</string>
    <!-- [CHAR LIMIT=130] Description text for Bluetooth always scanning -->
    <string name="location_scanning_bluetooth_always_scanning_title">Bluetooth scanning</string>
    <!-- Description text for Bluetooth always scanning -->
    <string name="location_scanning_bluetooth_always_scanning_description">Allow apps and services to scan for nearby devices at any time, even when Bluetooth is off. This can be used, for example, to improve location-based features and services.</string>

    <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for Google location service (cell ID, wifi, etc.) -->
    <string name="location_network_based">Wi\u2011Fi &amp; mobile network location</string>
    <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary for Google location service check box-->
    <string name="location_neighborhood_level">Let apps use Google\u2019s location service to estimate your location faster. Anonymous location data will be collected and sent to Google.</string>
    <!-- [CHAR LIMIT=130] Security & location settings screen, setting summary when Use wireless networks check box is selected, for wifi-only devices -->
    <string name="location_neighborhood_level_wifi">Location determined by Wi\u2011Fi</string>
    <!-- [CHAR LIMIT=30] Security & location settings screen, setting check box label for GPS satellites -->
    <string name="location_gps">GPS satellites</string>
    <!-- [CHAR LIMIT=100] Security & location settings screen, setting check box summary for GPS satellites on a tablet -->
    <string name="location_street_level" product="tablet">Let apps use GPS on your tablet to pinpoint your location</string>
    <!-- [CHAR LIMIT=100] Security & location settings screen, setting check box summary for GPS satellites on a phone -->
    <string name="location_street_level" product="default">Let apps use GPS on your phone to pinpoint your location</string>
    <!-- Security & location settings screen, setting check box label if Assisted GPS should be enabled -->
    <string name="assisted_gps">Use assisted GPS</string>
    <!-- Security & location settings screen, setting summary when Assisted GPS check box is selected -->
    <string name="assisted_gps_enabled">Use server to assist GPS (uncheck to reduce network usage)</string>
    <!-- Security & location settings screen, setting summary when Assisted GPS check box is clear -->
    <string name="assisted_gps_disabled">Use server to assist GPS (uncheck to improve GPS performance)</string>
    <!-- [CHAR_LIMIT=30] Security & location settings screen, setting check box label for Google search -->
    <string name="use_location_title">Location &amp; Google search</string>
    <!-- [CHAR_LIMIT=100] Security & location settings screen, setting check box summary for Google search -->
    <string name="use_location_summary">Let Google use your location to improve search results and other services</string>
    <!-- [CHAR LIMIT=45] Label for turning on/off location access completely. -->
    <string name="location_access_title">Access to my location</string>
    <!-- [CHAR LIMIT=none] Description text for location access switch -->
    <string name="location_access_summary">Let apps that have asked your permission use your location information</string>
    <!-- [CHAR LIMIT=45] Section heading for location sources -->
    <string name="location_sources_heading">Location sources</string>

    <!-- About --> <skip />
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings" product="tablet">About tablet</string>
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings" product="default">About phone</string>
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings" product="device">About device</string>
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings" product="emulator">About emulated device</string>
    <!-- Main settings screen, setting summary for the user to go into the About phone screen-->
    <string name="about_settings_summary">View legal info, status, software version</string>
    <!-- About phone settings screen, setting option name to go to dialog that shows legal info -->
    <string name="legal_information">Legal information</string>
    <!-- About phone settings screen, setting option name to see a list of contributors -->
    <string name="contributors_title">Contributors</string>
    <!-- About phone settings screen, setting option name to show Manual [CHAR LIMIT=25] -->
    <string name="manual">Manual</string>
    <!-- About phone settings screen, setting option name to show regulatory labels [CHAR LIMIT=25] -->
    <string name="regulatory_labels">Regulatory labels</string>
    <!-- About phone settings screen, setting option name to show the safety and regulatory manual [CHAR LIMIT=40] -->
    <string name="safety_and_regulatory_info">Safety &amp; regulatory manual</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see copyright-related info -->
    <string name="copyright_title">Copyright</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see licensing info -->
    <string name="license_title">License</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see terms and conditions -->
    <string name="terms_title">Terms and conditions</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see licensing info for WebView component. [CHAR LIMIT=35] -->
    <string name="webview_license_title">System WebView License</string>
    <!-- About phone settings screen, setting option name to see wallpapers attributions -->
    <string name="wallpaper_attributions">Wallpapers</string>
    <!-- About phone settings screen, setting option name to see wallpapers attributions values -->
    <string name="wallpaper_attributions_values">Satellite imagery providers:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky</string>

    <!-- Phone Manual -->
    <string name="settings_manual_activity_title">Manual</string>
    <!-- About phone settings screen, Manual dialog message when manual cannot be loaded -->
    <string name="settings_manual_activity_unavailable">There is a problem loading the manual.</string>

    <!-- Title for actual Settings license activity. --> <skip />
    <!-- About phone settings, Legal information setting option name and title of dialog box holding license info -->
    <string name="settings_license_activity_title">Third-party licenses</string>
    <!-- About phone settings screen, Open source license dialog message when licenses cannot be loaded -->
    <string name="settings_license_activity_unavailable">There is a problem loading the licenses.</string>
    <!-- About phone settings screen, Open source license dialog title until license is fully loaded -->
    <string name="settings_license_activity_loading">Loading\u2026</string>

    <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
    <string name="settings_safetylegal_title">Safety information</string>
    <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
    <string name="settings_safetylegal_activity_title">Safety information</string>
    <!-- About phone settings screen, Safety legal dialog message when data network is not connected -->
    <string name="settings_safetylegal_activity_unreachable">You don\u2019t have a data connection. To view this information now, go to %s from any computer connected to the internet.</string>
    <!-- About phone settings screen, Safety Legal dialog title until the link is fully loaded -->
    <string name="settings_safetylegal_activity_loading">Loading\u2026</string>

    <!-- Lock Pattern settings -->
    <!-- Header on first screen of choose password/PIN flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_screen_lock_header">Set screen lock</string>
    <!-- Message on first screen of choose password flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_password_message">For security, set password</string>
    <!-- Header on first screen of choose password/PIN as backup for fingerprint flow. If this string cannot be translated in under 40 characters, please translate "Set fingerprint backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_password_header_for_fingerprint">To use fingerprint, set password</string>
    <!-- Header on first screen of choose pattern as backup for fingerprint flow. If this string cannot be translated in under 40 characters, please translate "Set fingerprint backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint">To use fingerprint, set pattern</string>
    <!-- Message on first screen of choose PIN flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_pin_message">For security, set PIN</string>
    <!-- Header on first screen of choose password/PIN as backup for fingerprint flow. If this string cannot be translated in under 40 characters, please translate "Set fingerprint backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pin_header_for_fingerprint">To use fingerprint, set PIN</string>
    <!-- Message on first screen of choose pattern flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_pattern_message">For security, set pattern</string>
    <!-- Header on password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_password_header">Re-enter your password</string>
    <!-- Header on pattern confirm screen [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_pattern_header">Confirm your pattern</string>
    <!-- Header on password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_pin_header">Re-enter your PIN</string>
    <!-- Header on password confirm screen if second password doesn't match the first. [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_passwords_dont_match">Passwords don\u2019t match</string>
    <!-- Header on pin confirm screen if second pin doesn't match the first. [CHAR LIMIT=30]-->
    <string name="lockpassword_confirm_pins_dont_match">PINs don\u2019t match</string>
    <!-- Header on pattern confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_draw_your_pattern_again_header">Draw your pattern again</string>
    <!-- Header shown to ask the user to select an unlock method [CHAR LIMIT=30] -->
    <string name="lockpassword_choose_lock_generic_header">Unlock selection</string>
    <!-- Toast shown if setting password was successful -->
    <string name="lockpassword_password_set_toast">Password has been set</string>
    <!-- Toast shown if setting PIN was successful -->
    <string name="lockpassword_pin_set_toast">PIN has been set</string>
    <!-- Toast shown if setting pattern was successful -->
    <string name="lockpassword_pattern_set_toast">Pattern has been set</string>

    <!-- Message to be used to explain the user that he needs to enter his pattern to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pattern_generic">Use your device pattern to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his PIN to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pin_generic">Enter your device PIN to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his password to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_password_generic">Enter your device password to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his work pattern to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pattern_generic_profile">Use your work pattern to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his work PIN to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pin_generic_profile">Enter your work PIN to continue</string>
    <!-- Message to be used to explain the user that he needs to enter his work password to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_password_generic_profile">Enter your work password to continue</string>

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

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

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

    <!-- Header shown when pattern needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_pattern_header_frp">Verify pattern</string>
    <!-- Header shown when the pin needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_pin_header_frp">Verify PIN</string>
    <!-- Header shown when the password needs to be solved because the device was factory reset. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_your_password_header_frp">Verify password</string>

    <!-- Security & location settings screen, change security method screen instruction if user
         enters incorrect PIN [CHAR LIMIT=30] -->
    <string name="lockpassword_invalid_pin">Wrong PIN</string>
    <!-- Security & location settings screen, change security method screen instruction if user
         enters incorrect password [CHAR LIMIT=30] -->
    <string name="lockpassword_invalid_password">Wrong password</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction if user
         draws incorrect pattern [CHAR LIMIT=30] -->
    <string name="lockpattern_need_to_unlock_wrong">Wrong pattern</string>

    <!-- Lock Pattern settings -->
    <!-- Security & location settings screen, header -->
    <string name="lock_settings_title">Device security</string>
    <!-- Security & location settings screen, setting option name -->
    <string name="lockpattern_change_lock_pattern_label">Change unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction when the user chooses "Change unlock pattern".  We first ask the user toe nter the current pattern, and this is the message seen -->
    <string name="lockpattern_change_lock_pin_label">Change unlock PIN</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen.  This si when they are supposed to draw a new unlock pattern (for example, if they are changing their unlock patterns)..-->
    <string name="lockpattern_recording_intro_header">Draw an unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen hint on bottom of screen.  We are telling them to press the menu button to see more options or help. -->
    <string name="lockpattern_recording_intro_footer">Press Menu for help.</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen while drawing pattern -->
    <string name="lockpattern_recording_inprogress">Release finger when done</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen if user doesn't connect enough dots -->
    <string name="lockpattern_recording_incorrect_too_short">Connect at least <xliff:g id="number">%d</xliff:g> dots. Try again.</string>
    <!-- Security & location settings screen, change unlock pattern screen message on top of screen after drawing pattern -->
    <string name="lockpattern_pattern_entered_header">Pattern recorded</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen to confirm pattern -->
    <string name="lockpattern_need_to_confirm">Draw pattern again to confirm</string>
    <string name="lockpattern_pattern_confirmed_header">Your new unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen.  After they draw a pattern and release their finger, we display the pattern so they remember.  When they are ready to draw it once again to confirm it, they press this button. -->
    <string name="lockpattern_confirm_button_text">Confirm</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen.  After they draw a pattern and release their finger, we display the pattern so they remember.  If they are nto satisfied with this pattern, they click this button to redraw the pattern. -->
    <string name="lockpattern_restart_button_text">Redraw</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen. If they are supposed to enter their current pattern before being able to draw another one, and they screw up, they hit this button to try again -->
    <string name="lockpattern_retry_button_text">Clear</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen. Once they draw a new pattern and confirm it by drawing it again, they press this button to exit -->
    <string name="lockpattern_continue_button_text">Continue</string>
    <!-- Security & location settings screen, unlock screen activity title -->
    <string name="lockpattern_settings_title">Unlock pattern</string>
    <!-- Security & location settings screen, setting check box title if the unlock pattern MUST be drawn everytime they turn on the screen -->
    <string name="lockpattern_settings_enable_title">Require pattern</string>
    <!-- Security & location settings screen, setting summary for the checkbox "Require pattern" -->
    <string name="lockpattern_settings_enable_summary">Must draw pattern to unlock screen</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether a visible green line is drawn as the user moves his finger around while drawing the unlock pattern.  If checked, this line is drawn.  If unchecked, there is nothing drawn so the user does not reveal his pattern while he unlocks the phone.-->
    <string name="lockpattern_settings_enable_visible_pattern_title">Make pattern visible</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether a visible green line is drawn as the user moves his finger around while drawing the profile unlock pattern.  If checked, this line is drawn.  If unchecked, there is nothing drawn so the user does not reveal his pattern while he unlocks the profile.-->
    <string name="lockpattern_settings_enable_visible_pattern_title_profile">Make profile pattern visible</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether tactile feedback will be produced when the user draws the pattern.-->
    <string name="lockpattern_settings_enable_tactile_feedback_title">Vibrate on tap</string>
    <!-- Security & location settings screen, setting check box title. This controls whether the device locks immediately when the power button is pressed. [CHAR LIMIT=28]-->
    <string name="lockpattern_settings_enable_power_button_instantly_locks">Power button instantly locks</string>
    <!-- Security & location settings screen, setting optional summary when a trust agent is enabled-->
    <string name="lockpattern_settings_power_button_instantly_locks_summary">Except when kept unlocked by <xliff:g id="trust_agent_name">%1$s</xliff:g></string>
    <!-- Security & location settings screen, setting option name when user has never set an unlock pattern -->
    <string name="lockpattern_settings_choose_lock_pattern">Set unlock pattern</string>
    <!-- Security & location settings screen, setting option name when user has previously set an unlock pattern and wants to change to a new pattern -->
    <string name="lockpattern_settings_change_lock_pattern">Change unlock pattern</string>
    <!-- Security & location settings screen, the help instructions (an animation) caption -->
    <string name="lockpattern_settings_help_how_to_record">How to draw an unlock pattern</string>
    <!-- Security & location settings screen, confirm unlock pattern screen hint at the bottom after
         too many incorrect attempts [CHAR LIMIT=120]-->
    <string name="lockpattern_too_many_failed_confirmation_attempts">Too many incorrect attempts. Try again in <xliff:g id="number">%d</xliff:g> seconds.</string>
    <!-- Displayed when user launches a widget configuration activity that was uninstalled -->
    <string name="activity_not_found">Application is not installed on your phone.</string>

    <!-- Profile Lock settings -->
    <!-- Security & location settings screen, header for profile specific section -->
    <string name="lock_settings_profile_title">Work profile security</string>
    <!-- Security & location settings screen, title when changing or confirming the work profile lock -->
    <string name="lock_settings_profile_screen_lock_title">Work profile screen lock</string>
    <!-- Security & location settings screen, setting option name to unify work and personal locks -->
    <string name="lock_settings_profile_unification_title">Use one lock</string>
    <!-- Security & location settings screen, setting option explanation to unify work and personal locks -->
    <string name="lock_settings_profile_unification_summary">Use one lock for work profile and device screen</string>
    <!-- Security & location settings screen, title of the dialog asking if the user wants to unify work and personal locks -->
    <string name="lock_settings_profile_unification_dialog_title">Use one lock?</string>
    <!-- Security & location settings screen, explanation in the dialog asking if the user wants to unify work and personal locks -->
    <string name="lock_settings_profile_unification_dialog_body">Your device will use your work profile screen lock. Work policies will apply to both locks.</string>
    <!-- Security & location settings screen, explanation in the dialog asking if the user wants to create a new lock for personal and work as the current work lock is not enough for the device. -->
    <string name="lock_settings_profile_unification_dialog_uncompliant_body">Your work profile lock doesn\'t meet your organization\'s security requirements. You can use the same lock for your device screen and your work profile, but any work lock policies will apply.</string>
    <!-- Security & location settings screen, confirmation button of the dialog for user with compliant lock, asking to create a new lock for both personal and work profiles. -->
    <string name="lock_settings_profile_unification_dialog_confirm">Use one lock</string>
    <!-- Security & location settings screen, confirmation button of the dialog for user with uncompliant lock, asking to create a new lock for both personal and work profiles. -->
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm">Use one lock</string>
    <!-- Security & location settings screen, summary of the item that changes your work profile lock when it is unified with the personal lock -->
    <string name="lock_settings_profile_unified_summary">Same as device screen lock</string>

    <!-- Applications Settings --> <skip />
    <!-- Applications settings screen, setting option name for the user to go to the screen to manage installed applications  -->
    <string name="manageapplications_settings_title">Manage apps</string>
    <!-- Applications settings screen, setting option summary for the user to go to the screen to manage installed applications  -->
    <string name="manageapplications_settings_summary">Manage and remove installed apps</string>
    <!-- Applications settings title, on main settings screen. If clicked, the user is taken to a settings screen full of application settings-->
    <string name="applications_settings">App info</string>
    <!-- Applications settings summary, on main settings screen. The summary for the "Applications" item on the main settings screen. Describes what settings are accessible from the "Applications" screen. -->
    <string name="applications_settings_summary">Manage apps, set up quick launch shortcuts</string>
    <!-- Applications settings screen heading. The header for the Application settings screen. -->
    <string name="applications_settings_header">App settings</string>
    <!-- Applications settings screen, setting check box title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  -->
    <string name="install_applications">Unknown sources</string>
    <!-- Applications settings screen, setting check box title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  [CHAR LIMIT=30] -->
    <string name="install_applications_title">Allow all app sources</string>
    <!-- Category title listing recently used apps [CHAR_LIMIT=50]-->
    <string name="recent_app_category_title">Recently opened apps</string>
    <!-- Preference title for showing all apps on device [CHAR_LIMIT=50]-->
    <string name="see_all_apps_title">See all <xliff:g id="count" example="3">%1$d</xliff:g> apps</string>

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

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

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

    <!-- Applications settings screen, setting check box title. If checked, applications show more settings options. -->
    <string name="advanced_settings">Advanced settings</string>
    <!-- Applications settings screen, setting check box summary.  This is the summary for "Advanced settings" checkbox  -->
    <string name="advanced_settings_summary">Enable more settings options</string>
    <!-- Manage applications, individual application info screen title. For example, if they click on "Browser" in "Manage applications", the title of the next screen will be this -->
    <string name="application_info_label">App info</string>
    <!-- Manage applications, individual application info screen, section heading for stuff relating to an app's storage settings. -->
    <string name="storage_label">Storage</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling whether this app is the default for some actions -->
    <string name="auto_launch_label">Open by default</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling whether this app is the default for some actions *and* whether the app was given permission by the user to create widgets -->
    <string name="auto_launch_label_generic">Defaults</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling application screen compatibility -->
    <string name="screen_compatibility_label">Screen compatibility</string>
    <!-- Manage applications, individual application info screen, heading for settings related to the app's permissions. for example, it may list all the permissions the app has. -->
    <string name="permissions_label">Permissions</string>
    <!-- Manage applications, Header name used for cache information -->
    <string name="cache_header_label">Cache</string>
    <!-- Manage applications, text label for button -->
    <string name="clear_cache_btn_text">Clear cache</string>
    <!-- Manage applications, label that appears next to the cache size -->
    <string name="cache_size_label">Cache</string>
    <!-- Manage applications, individual application info storage screen. Describes the number of URIs (directories or files) an app has been granted access (by another apps)-->
    <plurals name="uri_permissions_text">
        <item quantity="one">1 item</item>
        <item quantity="other">%d items</item>
    </plurals>
    <!-- Manage applications, individual application info storage screen. Button below list of URIs. -->
    <string name="clear_uri_btn_text">Clear access</string>
    <!-- Manage applications, Header name used for other controls -->
    <string name="controls_label">Controls</string>
    <!-- Manage applications, text label for button to kill / force stop an application -->
    <string name="force_stop">Force stop</string>
    <!-- Manage applications, individual application info screen,label under Storage heading.  The total storage space taken up by this app. -->
    <string name="total_size_label">Total</string>
    <!-- Manage applications, individual application info screen, label under Storage heading. The amount of space taken up by the application itself (for example, the java compield files and things like that) -->
    <string name="application_size_label">App size</string>
    <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's code on USB storage [CHARSIZE=40] -->
    <string name="external_code_size_label">USB storage app</string>
    <!-- Manage applications, individual application info screen, label under Storage heading.  The amount of sapce taken up by the app's data (for example, downloaded emails or something like that) -->
    <string name="data_size_label">User data</string>
    <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's data on USB storage [CHARSIZE=40] -->
    <string name="external_data_size_label" product="nosdcard">USB storage data</string>
    <!--  Manage applications, individual application info screen, label under Storage heading.  The amount of space taken up by the app's data on the SD card [CHARSIZE=40] -->
    <string name="external_data_size_label" product="default">SD card</string>
    <!-- Manage applications, individual application info screen, button label under Storage heading. Button to remove the application from the system. -->
    <string name="uninstall_text">Uninstall</string>
    <!-- Manage applications, individual application info screen, menu item to uninstall an application for all users. -->
    <string name="uninstall_all_users_text">Uninstall for all users</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, individual application info screen, button label under Storage heading. Button to install an application for the user. -->
    <string name="install_text">Install</string>
    <!-- [CHAR LIMIT=25] Manage applications, individual application info screen, button label under Storage heading. Button to disable an existing application. -->
    <string name="disable_text">Disable</string>
    <!-- [CHAR LIMIT=25] Manage applications, individual application info screen, button label under Storage heading. Button to re-enable an existing application. -->
    <string name="enable_text">Enable</string>
    <!-- Manage applications, individual application info screen, button label under Storage heading. Button to clear all data associated with tis app (for example, remove all cached emails for an Email app) -->
    <string name="clear_user_data_text">Clear storage</string>
    <!-- Manage applications, restore updated system application to factory version -->
    <string name="app_factory_reset">Uninstall updates</string>
    <!-- Manage applications, individual application info screen, screen, message text under Launch by default heading. This is present if the app is set as a default for some actions. -->
    <string name="auto_launch_enable_text">You\u2019ve chosen to launch this app by default for some actions.</string>
    <!-- Manage applications, individual application info screen, screen, message text under Launch by default heading. This is present if the app was given user permission to create widgets. -->
    <string name="always_allow_bind_appwidgets_text">You\u2019ve chosen to allow this app to create widgets and access their data.</string>
    <!-- Manage applications, individual application screen, text under Launch by default heading if the app is NOT a default for actions -->
    <string name="auto_launch_disable_text">No defaults set.</string>
    <!-- Manage applications, individual application screen, button label under Launch by default heading.  This is used to clear any default actions that may be assigned to this app.  -->
    <string name="clear_activities">Clear defaults</string>
    <!-- Manage applications, individual application info screen, screen, message text under screen compatibility heading -->
    <string name="screen_compatibility_text">This app may not be designed for your screen. You can control how it
            adjusts to your screen here.</string>
    <!-- Manage applications, individual application screen, checkbox to control asking for compatibility mode.  -->
    <string name="ask_compatibility">Ask when launched</string>
    <!-- Manage applications, individual application screen, checkbox to control compatibility mode.  -->
    <string name="enable_compatibility">Scale app</string>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Manage apps, individual app screen, substituted for the application's label when the app's label CAN NOT be determined.-->
    <string name="unknown">Unknown</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Sorts all of the apps in the list alphabetically. -->
    <string name="sort_order_alpha">Sort by name</string>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on their file size.  This is used to uninstall when space is getting low. -->
    <string name="sort_order_size">Sort by size</string>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on how recently they sent notifications.-->
    <string name="sort_order_recent_notification">Most recent</string>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on how often they send notifications. -->
    <string name="sort_order_frequent_notification">Most frequent</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Show running services. -->
    <string name="show_running_services">Show running services</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Show background cached processes. -->
    <string name="show_background_processes">Show cached processes</string>
    <!-- [CHAR LIMIT=NONE] Advanced applications screen, preference title.  Choose the emergency application. -->
    <string name="default_emergency_app">Emergency app</string>
    <!-- [CHAR LIMIT=NONE] Manage applications screen, menu item.  Reset all of user's app preferences. -->
    <string name="reset_app_preferences">Reset app preferences</string>
    <!-- [CHAR LIMIT=NONE] Manage applications screen, menu item.  Title of dialog to confirm resetting user's app preferences. -->
    <string name="reset_app_preferences_title">Reset app preferences?</string>
    <!-- [CHAR LIMIT=NONE] Manage applications screen, menu item.  Body of dialog to confirm resetting user's app preferences. -->
    <string name="reset_app_preferences_desc">This will reset all preferences for:\n\n
        <li>Disabled apps</li>\n
        <li>Disabled app notifications</li>\n
        <li>Default applications for actions</li>\n
        <li>Background data restrictions for apps</li>\n
        <li>Any permission restrictions</li>\n\n
        You will not lose any app data.</string>
    <!-- [CHAR LIMIT=25] Manage applications screen, menu item.  Confirmation button of dialog to confirm resetting user's app preferences. -->
    <string name="reset_app_preferences_button">Reset apps</string>
    <!-- Manage applications screen, individual app screen, button label when the user wants to manage the space taken up by an app. -->
    <string name="manage_space_text">Manage space</string>
    <!-- Text for menu option in ManageApps screen to present various menu options -->
    <string name="filter">Filter</string>
    <!-- Title of dialog for presenting filter options -->
    <string name="filter_dlg_title">Choose filter options</string>
    <!-- Text for filter option in ManageApps screen to display all installed
    applications -->
    <string name="filter_apps_all">All apps</string>
    <!-- [CHAR LIMIT=NONE] Text for filter option in ManageApps screen to display disabled apps -->
    <string name="filter_apps_disabled">Disabled apps</string>
    <!-- Text for filter option in ManageApps screen to display third party
    applications only -->
    <string name="filter_apps_third_party">Downloaded</string>
    <!-- Text for filter option in ManageApps screen to display list of running
    packages only. -->
    <string name="filter_apps_running">Running</string>
    <!-- Text for filter option in ManageApps screen to display list of
    packages installed on sdcard. [CHAR LIMIT=30] -->
    <string name="filter_apps_onsdcard" product="nosdcard">USB storage</string>
    <!-- Text for filter option in ManageApps screen to display list of
    packages installed on sdcard. -->
    <string name="filter_apps_onsdcard" product="default">On SD card</string>
    <!-- [CHAR LIMIT=30] Manage applications, text telling using an application is not installed for the current user. The key part is that it's not installed. -->
    <string name="not_installed">Not installed for this user</string>
    <!-- [CHAR LIMIT=30] App details, text telling an application is installed. -->
    <string name="installed">Installed</string>
    <!-- [CHAR LIMIT=25] Text shown when there are no applications to display. -->
    <string name="no_applications">No apps.</string>
    <!-- [CHAR LIMIT=15] Manage applications, label for chart showing internal storage use. -->
    <string name="internal_storage">Internal storage</string>
    <!-- [CHAR LIMIT=30] Title for internal device storage that is capitalized for placement as a phrase into another sentence -->
    <string name="internal_storage_sentence">internal storage</string>
    <!-- [CHAR LIMIT=15] Manage applications, label for chart showing SD card storage use. -->
    <string name="sd_card_storage" product="nosdcard">USB storage</string>
    <!-- [CHAR LIMIT=15] Manage applications, label for chart showing SD card storage use. -->
    <string name="sd_card_storage" product="default">SD card storage</string>
    <!-- Manage app screen, shown when the activity is busy recomputing the size of each app -->
    <string name="recompute_size">Recomputing size\u2026</string>
    <!-- Manage applications, individual application screen, confirmation dialog title. Displays when user selects to "Clear data". -->
    <string name="clear_data_dlg_title">Delete app data?</string>
    <!-- Manage applications, individual application screen, confirmation dialog message. Displays when user selects to "Clear data". It warns the user of the consequences of clearing the data for an app. -->
    <string name="clear_data_dlg_text">All this app\u2019s data will be deleted permanently. This includes all files, settings, accounts, databases, etc.</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". Goes through with the clearing of the data. -->
    <string name="dlg_ok">OK</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". -->
    <string name="dlg_cancel">Cancel</string>
    <!-- Manage applications, individual application dialog box title. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
    <string name="app_not_found_dlg_title"></string>
    <!-- Manage applications, individual application dialog box message. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
    <string name="app_not_found_dlg_text"> The app wasn\u2019t found in the list of installed apps.</string>
    <!-- Manage applications, text for dialog if clear data fails-->
    <string name="clear_failed_dlg_text">Couldn\u2019t clear storage for app.</string>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
    <string name="security_settings_desc" product="tablet">This app can access the following on your tablet:</string>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
    <string name="security_settings_desc" product="default">This app can access the following on your phone:</string>
    <!-- [CHAR_LIMIT=NONE] Manage applications, individual application info screen, text that appears under the "Permissions" heading.
         This describes the permissions that the application has.  It is used when multiple packages are contributing
         to the permissions and need to be listed here. -->
    <string name="security_settings_desc_multi" product="tablet">This app can access the following on your tablet.
         In order to improve performance and reduce memory usage, some of these permissions
         are available to <xliff:g id="base_app_name">%1$s</xliff:g>
         because it runs in the same process as <xliff:g id="additional_apps_list">%2$s</xliff:g>:</string>
    <!-- [CHAR_LIMIT=NONE] Manage applications, individual application info screen, text that appears under the "Permissions" heading.
         This describes the permissions that the application has.  It is used when multiple packages are contributing
         to the permissions and need to be listed here. -->
    <string name="security_settings_desc_multi" product="default">This app can access the following on your phone.
         In order to improve performance and reduce memory usage, some of these permissions
         are available to <xliff:g id="base_app_name">%1$s</xliff:g>
         because it runs in the same process as <xliff:g id="additional_apps_list">%2$s</xliff:g>:</string>
    <!-- [CHAR_LIMIT=NONE] Format to put together two items in a list. -->
    <string name="join_two_items"><xliff:g id="first_item">%1$s</xliff:g> and <xliff:g id="second_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put together two unrelated items in a list when "and" is not an appropriate conjunction for these 2 items -->
    <string name="join_two_unrelated_items"><xliff:g id="first_item">%1$s</xliff:g>, <xliff:g id="second_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put the last item at the end of a series of 3 or more items in a list -->
    <string name="join_many_items_last"><xliff:g id="all_but_last_item">%1$s</xliff:g>, and <xliff:g id="last_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put the first item at the start of a series of 3 or more items in a list -->
    <string name="join_many_items_first"><xliff:g id="first_item">%1$s</xliff:g>, <xliff:g id="all_but_first_and_last_item">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Format to put the middle items together in a series of 4 or more items in a list -->
    <string name="join_many_items_middle"><xliff:g id="added_item">%1$s</xliff:g>, <xliff:g id="rest_of_items">%2$s</xliff:g></string>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading after the app has tried to send to a premium SMS. [CHAR LIMIT=50] -->
    <string name="security_settings_billing_desc">This app may charge you money:</string>
    <!-- Manage applications, text for permission to send to premium SMS short codes. [CHAR LIMIT=40] -->
    <string name="security_settings_premium_sms_desc">Send premium SMS</string>
    <string name="computing_size">Computing\u2026</string>
    <string name="invalid_size_value">Couldn\u2019t compute package size.</string>
    <!-- String displayed when list is empty -->
    <string name="empty_list_msg">You don\u2019t have any third-party apps installed.</string>
    <!-- Manage applications, version string displayed in app snippet -->
    <string name="version_text">version <xliff:g id="version_num">%1$s</xliff:g></string>
    <!-- Manage applications, text for Move button -->
    <string name="move_app">Move</string>
    <!-- Manage applications, text for Move button to move app to internal storage -->
    <string name="move_app_to_internal" product="tablet">Move to tablet</string>
    <!-- Manage applications, text for Move button to move app to internal storage -->
    <string name="move_app_to_internal" product="default">Move to phone</string>
    <!-- Manage applications, text for Move button  to move app to sdcard [CHAR LIMIT=25] -->
    <string name="move_app_to_sdcard" product="nosdcard">Move to USB storage</string>
    <!-- Manage applications, text for Move button  to move app to sdcard -->
    <string name="move_app_to_sdcard" product="default">Move to SD card</string>
    <!-- Manage applications, title for dialog when killing persistent apps-->
    <!-- Manage applications, text for Move button when move is in progress -->
    <string name="moving">Moving</string>

    <!-- Text of pop up message if the request for a "migrate primary storage" operation
         (see storage_menu_migrate) is denied as another is already in progress. [CHAR LIMIT=75] -->
    <string name="another_migration_already_in_progress">Another migration is already in progress.</string>

    <!-- Manage applications, text for move error messages -->
    <string name="insufficient_storage">Not enough storage space.</string>
    <string name="does_not_exist">App doesn\u2019t exist.</string>
    <string name="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 admin app can\'t be installed on external media</string>

    <string name="force_stop_dlg_title">Force stop?</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when killing persistent apps-->
    <string name="force_stop_dlg_text">If you force stop an app, it may misbehave.</string>
    <!-- Manage applications, text for dialog when moving an app -->
    <string name="move_app_failed_dlg_title"></string>
    <!-- Manage applications, text for dialog moving an app -->
    <string name="move_app_failed_dlg_text">Couldn\u2019t move app. <xliff:g id="reason">%1$s</xliff:g></string>
    <!-- Manage applications, application installation location title -->
    <string name="app_install_location_title">Preferred install location</string>
    <!-- Manage applications. application installation location summary -->
    <string name="app_install_location_summary">Change the preferred installation location for new apps</string>
    <!-- [CHAR LIMIT=30] Manage applications, title for dialog when disabling apps -->
    <string name="app_disable_dlg_title">Disable built-in app?</string>
    <!-- [CHAR LIMIT=30] Manage applications, label for option to disable app -->
    <string name="app_disable_dlg_positive">Disable app</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when disabling apps -->
    <string name="app_disable_dlg_text">If you disable this app, Android and other apps may no longer function as intended.</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, title for dialog when disabling updated apps -->
    <string name="app_special_disable_dlg_title">Delete data and disable app?</string>
    <!-- [CHAR LIMIT=NONE] Manage applications, text for dialog when disabling update apps -->
    <string name="app_special_disable_dlg_text">If you disable this app, Android and other apps may no longer function as intended.  Your data will also be deleted.</string>
    <!-- [CHAR LIMIT=30] Manage applications, title for dialog when disabling notifications for an app -->
    <string name="app_disable_notifications_dlg_title">Turn off notifications?</string>
    <!-- [CHAR LIMIT=200] Manage applications, text for dialog when disabling notifications for an app -->
    <string name="app_disable_notifications_dlg_text">
        If you turn off notifications for this app, you may miss important alerts and updates.
    </string>

    <!-- Manage applications, individual application info screen, section heading for information about the app installer [CHAR_LIMIT=25] -->
    <string name="app_install_details_group_title">Store</string>
    <!-- Manage applications, individual application info screen, title for the option which will trigger application info in it's installer [CHAR_LIMIT=25] -->
    <string name="app_install_details_title">App details</string>
    <!-- Manage applications, individual application info screen, summary for the option which will trigger application info in it's installer [CHAR_LIMIT=50] -->
    <string name="app_install_details_summary">App installed from <xliff:g id="app_store">%1$s</xliff:g></string>

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

    <!-- App Ops Settings --> <skip />
    <!-- [CHAR LIMIT=NONE] Time label for an operation that is currently running. -->
    <string name="app_ops_running">Running</string>
    <!-- [CHAR LIMIT=NONE] Time label for an operation that has never executed. -->
    <string name="app_ops_never_used">(Never used)</string>

    <!-- [CHAR LIMIT=25] Text shown when there are no default Apps -->
    <string name="no_default_apps">No default Apps.</string>

    <!-- [CHAR LIMIT=25] Services settings screen, setting option name for the user to go to the screen to view app storage use -->
    <string name="storageuse_settings_title">Storage use</string>
    <!-- Services settings screen, setting option summary for the user to go to the screen to app storage use -->
    <string name="storageuse_settings_summary">View storage used by apps</string>

    <!-- Label for a service item when it is restarting -->
    <string name="service_restarting">Restarting</string>
    <!-- Label for a process item representing a background process -->
    <string name="cached">Cached background process</string>
    <!-- [CHAR LIMIT=25] Text shown when there are no services running -->
    <string name="no_running_services">Nothing running.</string>
    <!-- Running services, description for a service in the started state -->
    <string name="service_started_by_app">Started by app.</string>
    <!-- Running services, description for a service in the started state -->
    <string name="service_client_name"><xliff:g id="client_name">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=10] Running services, summary of background processes -->
    <string name="service_background_processes"><xliff:g id="memory">%1$s</xliff:g> free</string>
    <!-- [CHAR LIMIT=10] Running services, summary of foreground processes -->
    <string name="service_foreground_processes"><xliff:g id="memory">%1$s</xliff:g> used</string>
    <!-- [CHAR LIMIT=10] Running services, label for chart showing memory use. -->
    <string name="memory">RAM</string>
    <!-- Text to label a process entry with the process name. -->
    <string name="service_process_name"><xliff:g id="process">%1$s</xliff:g></string>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- [CHAR LIMIT=NONE] Label of a running process that represents another user -->
    <string name="running_process_item_user_label">User: <xliff:g id="user_name">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Label of a running process that represents a removed -->
    <string name="running_process_item_removed_user_label">Removed user</string>
    <!-- Descriptive text of a running process: singular process, singular service. -->
    <string name="running_processes_item_description_s_s"><xliff:g id="numprocess">%1$d</xliff:g>
        process and <xliff:g id="numservices">%2$d</xliff:g> service</string>
    <!-- Descriptive text of a running process: singular process, plural service. -->
    <string name="running_processes_item_description_s_p"><xliff:g id="numprocess">%1$d</xliff:g>
        process and <xliff:g id="numservices">%2$d</xliff:g> services</string>
    <!-- Descriptive text of a running process: plural process, singular service. -->
    <string name="running_processes_item_description_p_s"><xliff:g id="numprocess">%1$d</xliff:g>
        processes and <xliff:g id="numservices">%2$d</xliff:g> service</string>
    <!-- Descriptive text of a running process: plural process, plural service. -->
    <string name="running_processes_item_description_p_p"><xliff:g id="numprocess">%1$d</xliff:g>
        processes and <xliff:g id="numservices">%2$d</xliff:g> services</string>
    <!-- [CHAR LIMIT=NONE] Top title of the header of the running processes/services list. -->
    <string name="running_processes_header_title">Device memory</string>
    <!-- [CHAR LIMIT=NONE] Bottom test of the header leading in to the running
         processes/services list. -->
    <string name="running_processes_header_footer">App RAM usage</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing RAM
         used by system. -->
    <string name="running_processes_header_system_prefix">System</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing RAM
         used by apps. -->
    <string name="running_processes_header_apps_prefix">Apps</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing RAM
         that is free. -->
    <string name="running_processes_header_free_prefix">Free</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing total RAM
         used by everything. -->
    <string name="running_processes_header_used_prefix">Used</string>
    <!-- [CHAR LIMIT=20] Running processes/services header: prefix for line showing portion
         of free RAM that is used by cached apps. -->
    <string name="running_processes_header_cached_prefix">Cached</string>
    <!-- [CHAR_LIMIT=20] Running processes/services header: formatter for RAM use amount. -->
    <string name="running_processes_header_ram"><xliff:g id="ram">%1$s</xliff:g> of RAM</string>

    <!-- Details about an application's running services. -->
    <string name="runningservicedetails_settings_title">Running app</string>
    <!-- Message displayed when there are no active services in a process. -->
    <string name="no_services">Not active</string>
    <!-- Title for list of services. -->
    <string name="runningservicedetails_services_title">Services</string>
    <!-- Title for list of services. -->
    <string name="runningservicedetails_processes_title">Processes</string>
    <!-- Running service details, stop a service that has started itself. -->
    <string name="service_stop">Stop</string>
    <!-- Running service details, manage a service that is running for some other reason. -->
    <string name="service_manage">Settings</string>
    <!-- Running service details, default description for services that are started. -->
    <string name="service_stop_description">This service was started by its
        app. Stopping it may cause the app to fail.</string>
    <!-- Running service details, description for running heavy-weight process. -->
    <string name="heavy_weight_stop_description">This app can\u2019t safely
        be stopped. If you stop it, you may lose some of your current work.</string>
    <!-- Running service details, description for background process. -->
    <string name="background_process_stop_description">This is an old app
        process that is still running in case it\u2019s needed again.
        There is usually no reason to stop it.</string>
    <!-- Running service details, default description for services that are managed. -->
    <string name="service_manage_description"><xliff:g id="client_name">%1$s</xliff:g>:
        currently in use. Tap Settings to control it.</string>
    <!-- Description of the main process in the details. -->
    <string name="main_running_process_description">Main process in use.</string>
    <!-- Message that a process's service is in use. -->
    <string name="process_service_in_use_description">Service <xliff:g id="comp_name">%1$s</xliff:g>
        is in use.</string>
    <!-- Message that a process's provider is in use. -->
    <string name="process_provider_in_use_description">Provider <xliff:g id="comp_name">%1$s</xliff:g>
        is in use.</string>
    <!-- Running service details, stop confirmation dialog title. Displays when user selects selects to stop a system service. -->
    <string name="runningservicedetails_stop_dlg_title">Stop system service?</string>
    <!-- Running service details, stop confirmation descriptive text. Displays when user selects selects to stop a system service. -->
    <string name="runningservicedetails_stop_dlg_text" product="tablet">If you stop this service, some
        features of your tablet may stop working correctly until you power it off
        and then on again.</string>
    <!-- Running service details, stop confirmation descriptive text. Displays when user selects selects to stop a system service. -->
    <string name="runningservicedetails_stop_dlg_text" product="default">If you stop this service, some
        features of your phone may stop working correctly until you power it off
        and then on again.</string>

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

    <!-- Title of setting on main settings screen.  This item will take the user to the screen to tweak settings realted to locale and text -->
    <string name="language_settings">Languages&#160;&amp; input</string>
    <!-- Text displayed when user has restriction DISALLOW_CONFIG_LOCALE [CHAR LIMIT=NONE]-->
    <string name="language_empty_list_user_restricted">You don\u2019t have permission to change the device language.</string>
    <!-- Title of Languages & input settings screen -->
    <string name="language_keyboard_settings_title">Languages&#160;&amp; input</string>
    <!-- Title of preference category that lists all settings about helping user text input such as spell checker [CHAR LIMIT=60]-->
    <string name="input_assistance">Input assistance</string>
    <!-- On Languages & input settings screen, heading. Inside the "Languages & input settings" screen, this is the header for settings that relate to keyboard (enable/disable each keyboard, settings for each keyboard). -->
    <string name="keyboard_settings_category">Keyboard &amp; input methods</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to take the user to a screen to select the locale. -->
    <string name="phone_language">Languages</string>
    <!-- On Text & language settings screen, setting option name. summary of the setting to take the user to a screen to select the locale. -->
    <string name="phone_language_summary">""</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to enable autoreplace of entered text. auto replace is a feature that will automatically correct mistyped words. -->
    <string name="auto_replace">Auto-replace</string>
    <!-- On Text & language settings screen, setting summary.  This is the summary for the "Auto-replace" setting. -->
    <string name="auto_replace_summary">Correct mistyped words</string>
    <!-- On Text & language settings screen, setting option name.  title of the setting to enable autocapitalization of entered text.  for example, after the user finishes a sentence, the next letter he types will automatically be capitalizated. [CHAR LIMIT=25] -->
    <string name="auto_caps">Auto-capitalization</string>
    <!-- On Text & language settings screen, setting summary. Summary for the Auto-cap setting. [CHAR LIMIT=100]-->
    <string name="auto_caps_summary">Capitalize first letter in sentences</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to enable automatic punctuation of entered text.  for example, it will change an entered "youre" to "you're". -->
    <string name="auto_punctuate">Auto-punctuate</string>
    <!-- On Text & language settings screen, category for physical keyboard text entry options. -->
    <string name="hardkeyboard_category">Physical keyboard settings</string>
    <!-- On Text & language settings screen, setting summary for the Auto-punctuate setting. -->
    <string name="auto_punctuate_summary">Press Space key twice to insert \u0022.\u0022</string>
    <!-- On Security & location settings screen, setting check box name. Title of the checkbox to set whether password edit fields will show the most recent character typed and then hide it, or just hide it right away.  By hide, I mean mask it out. -->
    <string name="show_password">Show passwords</string>
    <!-- On Security & location settings screen. This is a short summary text describing what "Show passwords" setting does -->
    <string name="show_password_summary">Display characters briefly as you type</string>
    <!-- Warning message about security implications of enabling a spell checker, displayed as a dialog
         message when the user selects to enable a spell checker. -->
    <string name="spellchecker_security_warning">This spell checker may be able to collect
    all the text you type, including personal data like passwords and credit
    card numbers.  It comes from the app
    <xliff:g id="spellchecker_application_name">%1$s</xliff:g>.
    Use this spell checker?</string>
    <!-- Image button description for spell checker quick settings. -->
    <string name="spellchecker_quick_settings">Settings</string>
    <!-- Image button description for spell checker language. -->
    <string name="spellchecker_language">Language</string>
    <!-- Title for the 'keyboard and input methods' preference category. [CHAR LIMIT=45] -->
    <string name="keyboard_and_input_methods_category">Keyboard &amp; inputs</string>
    <!-- Title for the 'virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="virtual_keyboard_category">Virtual keyboard</string>
    <!-- Title for the 'available virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="available_virtual_keyboard_category">Available virtual keyboard</string>
    <!-- Title for the button to trigger the 'Manage keyboards' preference sub-screen, where the user can turn on/off installed virtual keyboards.[CHAR LIMIT=35] -->
    <string name="add_virtual_keyboard">Manage keyboards</string>
    <!-- Title for the 'keyboard assistance' preference category. [CHAR LIMIT=35] -->
    <string name="keyboard_assistance_category">Keyboard assistance</string>
    <!-- Title for the 'physical keyboard' settings screen. [CHAR LIMIT=35] -->
    <string name="physical_keyboard_title">Physical keyboard</string>
    <!-- Title for the 'show virtual keyboard' preference switch. [CHAR LIMIT=35] -->
    <string name="show_ime">Show virtual keyboard</string>
    <!-- Summary text for the 'add virtual keyboard' preference sub-screen. [CHAR LIMIT=100] -->
    <string name="show_ime_summary">Keep it on screen while physical keyboard is active</string>
    <!-- Title for the button to trigger the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=35] -->
    <string name="keyboard_shortcuts_helper">Keyboard shortcuts helper</string>
    <!-- Summary text for the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=100] -->
    <string name="keyboard_shortcuts_helper_summary">Display available shortcuts</string>

    <!-- Summary text for keyboards when no layout has been selected. [CHAR LIMIT=35] -->
    <string name="default_keyboard_layout">Default</string>

    <!-- On Languages & input settings screen, setting summary.  Setting for mouse pointer speed. [CHAR LIMIT=35] -->
    <string name="pointer_speed">Pointer speed</string>

    <!-- On Languages & input settings screen, heading. Inside the "Languages & input settings" screen, this is the header for settings that relate to game controller devices. [CHAR LIMIT=40] -->
    <string name="game_controller_settings_category">Game Controller</string>
    <!-- On Languages & input settings screen, setting title.  Setting to redirect vibration to input devices. [CHAR LIMIT=35] -->
    <string name="vibrate_input_devices">Redirect vibration</string>
    <!-- On Languages & input settings screen, setting summary.  Setting to redirect vibration to input devices. [CHAR LIMIT=100] -->
    <string name="vibrate_input_devices_summary">Send vibration to game controller when connected</string>

    <!-- Keyboard Layout Preference Dialog --> <skip />
    <!-- Title for the keyboard layout preference dialog. [CHAR LIMIT=35] -->
    <string name="keyboard_layout_dialog_title">Choose keyboard layout</string>
    <!-- Button to configure keyboard layouts.  [CHAR LIMIT=35] -->
    <string name="keyboard_layout_dialog_setup_button">Set up keyboard layouts</string>
    <!-- Hint describing how to switch keyboard layouts using the keyboard.  [CHAR LIMIT=48] -->
    <string name="keyboard_layout_dialog_switch_hint">To switch, press Control-Spacebar</string>
    <!-- Label of the default keyboard layout.  [CHAR LIMIT=35] -->
    <string name="keyboard_layout_default_label">Default</string>

    <!-- Keyboard Layout Picker --> <skip />
    <!-- Title for the keyboard layout picker activity. [CHAR LIMIT=35] -->
    <string name="keyboard_layout_picker_title">Keyboard layouts</string>

    <!-- User dictionary settings --><skip />
    <!-- User dictionary settings. The title of the list item to go into the Personal dictionary settings screen. [CHAR LIMIT=35] -->
    <string name="user_dict_settings_title">Personal dictionary</string>
    <!-- User dictionary settings.  The summary of the list item to go into the Personal dictionary settings screen. -->
    <string name="user_dict_settings_summary">""</string>
    <!-- User dictionary settings. The title of the menu item to add a new word to the user dictionary. -->
    <string name="user_dict_settings_add_menu_title">Add</string>
    <!-- User dictionary settings. The title of the dialog to add a new word to the user dictionary. [CHAR LIMIT=25] -->
    <string name="user_dict_settings_add_dialog_title">Add to dictionary</string>
    <!-- User dictionary settings. The title of the screen to add/edit a new word to the user dictionary; it describes the phrase that will be added to the user dictionary. [CHAR LIMIT=25] -->
    <string name="user_dict_settings_add_screen_title">Phrase</string>
    <!-- User dictionary settings. Text on the dialog button to pop more options for adding a word. [CHAR LIMIT=16] -->
    <string name="user_dict_settings_add_dialog_more_options">More options</string>
    <!-- User dictionary settings. Text on the dialog button mask advanced options. [CHAR LIMIT=15] -->
    <string name="user_dict_settings_add_dialog_less_options">Less options</string>
    <!-- User dictionary settings. Text on the dialog button to confirm adding a word. [CHAR LIMIT=15] -->
    <string name="user_dict_settings_add_dialog_confirm">OK</string>
    <!-- User dictionary settings. Label to put before the word field (that's the word that will actually be added to the user dictionary when OK is pressed). [CHAR LIMIT=20] -->
    <string name="user_dict_settings_add_word_option_name">Word:</string>
    <!-- User dictionary settings. Label to put before the shortcut field (once a shortcut is registered, the user can type the shortcut and get the word it points to in the suggestions). [CHAR LIMIT=20] -->
    <string name="user_dict_settings_add_shortcut_option_name">Shortcut:</string>
    <!-- User dictionary settings. Label to put before the language field. [CHAR LIMIT=20] -->
    <string name="user_dict_settings_add_locale_option_name">Language:</string>
    <!-- User dictionary settings. Hint for the text field to type the word to add to the user dictionary. [CHAR LIMIT=35] -->
    <string name="user_dict_settings_add_word_hint">Type a word</string>
    <!-- User dictionary settings. Hint for the text field to type the optional shortcut to add to the user dictionary. [CHAR LIMIT=35] -->
    <string name="user_dict_settings_add_shortcut_hint">Optional shortcut</string>
    <!-- User dictionary settings. The title of the dialog to edit an existing word in the user dictionary. -->
    <string name="user_dict_settings_edit_dialog_title">Edit word</string>
    <!-- User dictionary settings. The title of the context menu item to edit the current word -->
    <string name="user_dict_settings_context_menu_edit_title">Edit</string>
    <!-- User dictionary settings. The title of the context menu item to delete the current word -->
    <string name="user_dict_settings_context_menu_delete_title">Delete</string>
    <!-- User dictionary settings. The text to show when there are no user-defined words in the dictionary  [CHAR LIMIT=200] -->
    <string name="user_dict_settings_empty_text">You don\u2019t have any words in the user dictionary. To add a word, tap the Add (+) button.</string>
    <!-- User dictionary settings. The list item to choose to insert a word into the user dictionary for all languages -->
    <string name="user_dict_settings_all_languages">For all languages</string>
    <!-- User dictionary settings. The text to show for the option that shows the entire list of supported locales to choose one [CHAR LIMIT=30] -->
    <string name="user_dict_settings_more_languages">More languages…</string>

    <!-- This is for diagnostics screen. The title of a screen with various items realted to launching screens that will giev the user info. For example, it contains "Phone information" and "Battery information" -->
    <string name="testing">Testing</string>
    <!-- In the Testing screen.  The item title of the activity that shows a bunch of phone-related information.  -->
    <string name="testing_phone_info" product="tablet">Tablet information</string>
    <!-- In the Testing screen.  The item title of the activity that shows a bunch of phone-related information.  -->
    <string name="testing_phone_info" product="default">Phone information</string>
    <!-- Do not translate. In the Testing screen. The item title of the activity that shows a bunch of SIM-related operations.  -->
    <string name="testing_sim_toolkit">SIM toolkit</string>

    <!-- Input methods Settings -->
    <string name="input_methods_settings_title">Text input</string>
    <!-- Setting name for Input Method chooser -->
    <string name="input_method">Input method</string>
    <!-- Title for the option to press to choose the current keyboard, also known as input method [CHAR LIMIT=35] -->
    <string name="current_input_method">Current Keyboard</string>
    <!-- Title for setting the visibility of input method selector [CHAR LIMIT=35] -->
    <string name="input_method_selector">Input method selector</string>
    <!-- An option to always show input method selector automatically when needed [CHAR LIMIT=25] -->
    <string name="input_method_selector_show_automatically_title">Automatic</string>
    <!-- An option to always show input method selector [CHAR LIMIT=25] -->
    <string name="input_method_selector_always_show_title">Always show</string>
    <!-- An option to always hide input method selector [CHAR LIMIT=25] -->
    <string name="input_method_selector_always_hide_title">Always hide</string>
    <!-- Title for configuring input method settings [CHAR LIMIT=35] -->
    <string name="configure_input_method">Set up input methods</string>
    <!-- Title for settings of each IME [CHAR LIMIT=25] -->
    <string name="input_method_settings">Settings</string>
    <!-- Spoken description for IME settings image button [CHAR LIMIT=NONE] -->
    <string name="input_method_settings_button">Settings</string>
    <!-- Input Methods Settings localized format string for generating the appropriate "Foo settings" menu label for the Input Method named "Foo" [CHAR LIMIT=35] -->
    <string name="input_methods_settings_label_format"><xliff:g id="ime_name">%1$s</xliff:g> settings</string>
    <!-- Title for the settings of selecting active input methods of an IME [CHAR LIMIT=35] -->
    <string name="input_methods_and_subtype_enabler_title">Choose active input methods</string>
    <!-- Summary for on-screen keyboard settings -->
    <string name="onscreen_keyboard_settings_summary">Onscreen keyboard settings</string>
    <!-- Title for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_title">Physical keyboard</string>
    <!-- Summary for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_summary">Physical keyboard settings</string>

    <!-- Title for the screen that lets the user choose a gadget to add to the home screen
         (or other screens that can host gadgets).  Note to translators: we're still determining
         the final name for Gadgets/Widgets, so please translate both for now. -->
    <string name="gadget_picker_title">Choose gadget</string>

    <!-- Title for the screen that lets the user choose a widget to add to the home screen
         (or other screens that can host widgets).  Note to translators: we're still determining
         the final name for Gadgets/Widgets, so please translate both for now. -->
    <string name="widget_picker_title">Choose widget</string>

    <!-- Title in dialog that pops up when an app requests permission to bind a widget [CHAR LIMIT=NONE] -->
    <string name="allow_bind_app_widget_activity_allow_bind_title">Create widget and allow access?</string>

    <!-- Message in dialog that pops up when an app requests permission to bind a widget [CHAR LIMIT=NONE] -->
    <string name="allow_bind_app_widget_activity_allow_bind">After you create the widget, <xliff:g id="widget_host_name">%1$s</xliff:g> can access all data it displays.</string>

    <!-- Text for checkbox that pops up when an app requests permission to bind a widget [CHAR LIMIT=NONE] -->
    <string name="allow_bind_app_widget_activity_always_allow_bind">Always allow <xliff:g id="widget_host_name">%1$s</xliff:g> to create widgets and access their data</string>

    <!-- XXX remove? Strings used for displaying usage statistics -->
    <string name="usage_stats_label">Usage statistics</string>

    <!-- In the Testing screen. The item title of the activity that shows usage statistics.  -->
    <string name="testing_usage_stats">Usage statistics</string>
    <!-- label for text to indicate sort options -->
    <string name="display_order_text">Sort by:</string>
    <!-- label for application name -->
    <string name="app_name_label">App</string>
    <!-- label for last time used -->
    <string name="last_time_used_label">Last time used</string>
    <!-- label for usage time -->
    <string name="usage_time_label">Usage time</string>

    <!-- Accessibility settings -->
    <skip />

    <!-- Settings title in main settings screen for accessibility settings -->
    <string name="accessibility_settings">Accessibility</string>
    <!-- Settings title for accessibility settings screen -->
    <string name="accessibility_settings_title">Accessibility settings</string>
    <!-- Summary for Accessibility settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="accessibility_settings_summary">Screen readers, display, interaction controls</string>
    <!-- Settings title for a brief version of Vision-Related Accessibility Settings. Displayed in Setup Wizard only. [CHAR LIMIT=35] -->
    <string name="vision_settings_title">Vision Settings</string>
    <!-- Settings description for a brief version of Vision-Related Accessibility Settings. Tells the user that they can adjust these settings now to help them through the remainder of the Setup Wizard and that they can later be changed in Settings. Displayed in Setup Wizard only. [CHAR LIMIT=none] -->
    <string name="vision_settings_description">You can customize this device to fit your needs. These accessibility features can be changed later in Settings.</string>
    <!-- Label for suggested action which will allow the user to change the font size and other accessibility settings. [CHAR LIMIT=40] -->
    <string name="vision_settings_suggestion_title">Change font size</string>
    <!-- Title for the accessibility preference category of screen reader services and settings. [CHAR LIMIT=50] -->
    <string name="screen_reader_category_title">Screen readers</string>
    <!-- Title for the accessibility preference category of audio services and settings. [CHAR LIMIT=50] -->
    <string name="audio_and_captions_category_title">Audio &amp; on-screen text</string>
    <!-- Title for the accessibility preference category of display services and settings. [CHAR LIMIT=50] -->
    <string name="display_category_title">Display</string>
    <!-- Title for the accessibility preference category of interaction control services and settings. [CHAR LIMIT=50] -->
    <string name="interaction_control_category_title">Interaction controls</string>
    <!-- Title for the accessibility preference category of services downloaded by the user. [CHAR LIMIT=50] -->
    <string name="user_installed_services_category_title">Downloaded services</string>
    <!-- Title for the accessibility preference category of settings considered to be experimental, meaning they might be changed or removed in the future. [CHAR LIMIT=50] -->
    <string name="experimental_category_title">Experimental</string>
    <!-- Title for feature flags dashboard DO NOT TRANSLATE -->
    <string name="feature_flags_dashboard_title" translatable="false">Feature flags</string>
    <!-- Title for the Talkback Accessibility Service. Displayed on the Accessibility Settings screen in Setup Wizard. [CHAR_LIMIT=25] -->
    <string name="talkback_title">Talkback</string>
    <!-- Summary for the Talkback Accessibility Service. Lets the user know that Talkback is a screenreader and that it is usually most helpful to blind and low vision users and whether the service is on. [CHAR_LIMIT=none] -->
    <string name="talkback_summary">Screen reader primarily for people with blindness and low vision</string>
    <!-- Summary for the Select to Speak Accessibility Service. [CHAR_LIMIT=none] -->
    <string name="select_to_speak_summary">Tap items on your screen to hear them read aloud</string>
    <!-- Title for the accessibility preference screen to enable video captioning. [CHAR LIMIT=35] -->
    <string name="accessibility_captioning_title">Captions</string>
    <!-- Title for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_title">Magnification</string>
    <!-- Title for the accessibility preference screen to enable triple-tap gesture screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_gestures_title">Magnify with triple-tap</string>
    <!-- Title for the accessibility preference screen to enable navigation bar screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_navbar_title">Magnify with button</string>
    <!-- Summary for the accessibility magnification setting indicating both "Magnify with button" and "Magnify with triple-tap" are enabled [CHAR LIMIT=50] -->
    <string name="accessibility_screen_magnification_state_navbar_gesture">Magnify with button &amp; triple-tap</string>
    <!-- Summary for the accessibility preference to enable screen magnification. [CHAR LIMIT=25] -->
    <string name="accessibility_preference_magnification_summary">Zoom in on screen</string>
    <!-- Short summary for Magnification gesture. Tells the user that this feature allows the user to magnify the screen by tapping 3 times. Appears in accessibility portion of setup wizard -->
    <string name="accessibility_screen_magnification_short_summary">Tap 3 times to zoom</string>
    <!-- Short summary for nav bar Magnification. Tells the user that this feature allows the user to magnify the screen using a button in the nav bar -->
    <string name="accessibility_screen_magnification_navbar_short_summary">Tap a button to zoom</string>
    <!-- Summary for the accessibility preference screen to enable screen magnification gestures. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_summary"><b>To zoom</b>, quickly tap the screen 3 times.\n<ul><li>Drag 2 or more fingers to scroll</li>\n<li>Pinch 2 or more fingers to adjust zoom</li></ul>\n\n<b>To zoom temporarily</b>, quickly tap the screen 3 times and hold down your finger on the third tap.\n<ul><li>Drag to move around the screen</li>\n<li>Lift finger to zoom out</li></ul>\n\nYou can\'t zoom in on the keyboard and navigation bar.</string>
    <!-- Summary for the accessibility preference screen to enable screen magnification via the nav bar. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_navbar_summary">When magnification is turned on, use the Accessibility button at the bottom of the screen to quickly magnify.\n\n<b>To zoom</b>, tap the Accessibility button, then tap anywhere on the screen.\n<ul><li>Drag 2 or more fingers to scroll</li>\n<li>Pinch 2 or more fingers to adjust zoom</li></ul>\n\n<b>To zoom temporarily</b>, tap the Accessibility button, then touch &amp; hold anywhere on the screen.\n<ul><li>Drag to move around the screen</li>\n<li>Lift finger to zoom out</li></ul>\n\nYou can’t zoom in on the keyboard or navigation bar.</string>
    <!-- Summary text appearing on the accessibility preference screen to enable screen magnification from the nav bar when the feature is enabled, but the accessibility button is not configured correctly for the feature to be used [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_navbar_configuration_warning">The Accessibility button is set to <xliff:g id="service" example="Select to Speak">%1$s</xliff:g>. To use magnification, touch &amp; hold the Accessibility button, then select magnification.</string>
    <!-- Title for the preference to configure the accessibility shortcut, which uses the volume keys. [CHAR LIMIT=35] -->
    <string name="accessibility_global_gesture_preference_title">Volume key shortcut</string>
    <!-- Title for the preference to choose the service that is turned on and off by the accessibility shortcut. [CHAR LIMIT=35] -->
    <string name="accessibility_shortcut_service_title">Shortcut service</string>
    <!-- Title for the switch preference that controls whether or not the accessibility shortcut works on the lock screen. [CHAR LIMIT=35] -->
    <string name="accessibility_shortcut_service_on_lock_screen_title">Allow from lock screen</string>
    <!-- Description of accessibility shortcut. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_description">When the shortcut is on, you can press both volume keys for 3 seconds to start an accessibility feature.</string>
    <!-- Title for the accessibility preference to high contrast text. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_high_text_contrast_preference_title">High contrast text</string>
    <!-- Title for the accessibility preference to auto update screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title">Auto
        update screen magnification</string>
    <!-- Summary for the accessibility preference to auto update screen magnification. [CHAR LIMIT=50] -->
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary">Update
        screen magnification on app transitions</string>
    <!-- Title for the accessibility preference to power button to end a call. [CHAR LIMIT=35] -->
    <string name="accessibility_power_button_ends_call_prerefence_title">Power button ends call</string>
    <!-- Title for the accessibility preference for enabling/disabling large icons for mouse/trackpad pointers. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_large_pointer_icon_title">Large mouse pointer</string>
    <!-- Title for the accessibility preference for disabling animations. [CHAR LIMIT=35] -->
    <string name="accessibility_disable_animations">Remove animations</string>
    <!-- Title for the accessibility preference for master mono. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_master_mono_title">Mono audio</string>
    <!-- Summary for the accessibility preference for master mono. [CHAR LIMIT=50] -->
    <string name="accessibility_toggle_master_mono_summary">Combine channels when playing audio</string>
    <!-- Title for accessibility preference to choose long-press delay i.e. timeout before it is detected. [CHAR LIMIT=35] -->
    <string name="accessibility_long_press_timeout_preference_title">Touch &amp; hold delay</string>
    <!-- Title for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_title">Color inversion</string>
    <!-- Subtitle for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_subtitle">May affect performance</string>
    <!-- Title for accessibility preference for configuring feature that performs click action soon after mouse/trackpad pointer stops moving. [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_preference_title">Dwell timing</string>
    <!-- Footer text to explain what autoclick does -->
    <string name="accessibility_autoclick_description">If you are using a mouse, you can set the cursor to take action automatically when it stops moving for a certain amount of time.</string>
    <!-- Title for accessibility preference for configuring amount of time that has to pass after pointer stops moving before click action can be performed (if automatic click after pointer stops moving feature is enabled). [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_delay_preference_title">Delay before click</string>
    <!-- Title for accessibility preference screen for configuring vibrations. -->
    <string name="accessibility_vibration_settings_title">Vibration</string>
    <!-- Title for accessibility preference for configuring notification vibrations. -->
    <string name="accessibility_notification_vibration_title">Ring &amp; notification vibration</string>
    <!-- Title for accessibility preference for configuring touch feedback vibrations. -->
    <string name="accessibility_touch_vibration_title">Touch vibration</string>
    <!-- Used in the acessibilty service settings to control turning on/off the service entirely -->
    <string name="accessibility_service_master_switch_title">Use service</string>
    <!-- Used in the Color correction settings screen to control turning on/off the feature entirely -->
    <string name="accessibility_daltonizer_master_switch_title">Use color correction</string>
    <!-- Used in the Captions settings screen to control turning on/off the feature entirely -->
    <string name="accessibility_caption_master_switch_title">Use captions</string>

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

    <!-- Preference's state when enabled. -->
    <string name="accessibility_summary_state_enabled">On</string>
    <!-- Preference's state when disabled. -->
    <string name="accessibility_summary_state_disabled">Off</string>
    <!-- Accessibility service's preference's state when enabled but not running (like maybe it crashed). -->
    <string name="accessibility_summary_state_stopped">Not working. Tap for info.</string>
    <!-- Accessibility service's description when enabled but not running (like maybe it crashed). -->
    <string name="accessibility_description_state_stopped">This service is malfunctioning.</string>

    <!-- Title for the preference to show a tile for a particular feature in the Quick Settings pane. [CHAR LIMIT=NONE] -->
    <string name="enable_quick_setting">Show in Quick Settings</string>
    <!-- Title for the preference to configure the type of color space correction to apply. [CHAR LIMIT=NONE] -->
    <string name="daltonizer_type">Correction mode</string>

    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay">
        <item quantity="one">Extremely short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Extremely short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay">
        <item quantity="one">Very short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Very short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay">
        <item quantity="one">Short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Short delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay">
        <item quantity="one">Long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>
    <!-- Subtitle for the accessibility preference to configure feature that performs click action soon after mouse/trackpad pointer stops moving, in case delay before click is extremely short. Placeholder will be set to the number of milliseconds to which the delay amounts. [CHAR LIMIT=NONE] -->
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay">
        <item quantity="one">Very long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
        <item quantity="other">Very long delay (<xliff:g id="click_delay_label" example="200">%1$d</xliff:g> ms)</item>
    </plurals>

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

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

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

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

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

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

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

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

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

    <!-- Title for accessibility menu item to lauch a settings activity. [CHAR LIMIT=15] -->
    <string name="accessibility_menu_item_settings">Settings</string>

    <!-- Summary for the enabled state of an accessibility feature. [CHAR LIMIT=10] -->
    <string name="accessibility_feature_state_on">On</string>
    <!-- Summary for the disabled state of an accessibility feature. [CHAR LIMIT=10] -->
    <string name="accessibility_feature_state_off">Off</string>

    <!-- Title for the preference category containing the video caption preview. [CHAR LIMIT=35] -->
    <string name="captioning_preview_title">Preview</string>
    <!-- Title for the preference catgeory containing standard video caption options. [CHAR LIMIT=35] -->
    <string name="captioning_standard_options_title">Standard options</string>
    <!-- Title for the preference to change video caption locale. [CHAR LIMIT=35] -->
    <string name="captioning_locale">Language</string>
    <!-- Title for the preference to change video caption text size. [CHAR LIMIT=35] -->
    <string name="captioning_text_size">Text size</string>
    <!-- Title for the preference category containing video caption property presets. [CHAR LIMIT=35] -->
    <string name="captioning_preset">Caption style</string>
    <!-- Title for the preference catgeory containing custom video caption properties. [CHAR LIMIT=35] -->
    <string name="captioning_custom_options_title">Custom options</string>
    <!-- Title for the preference to change video caption background color. [CHAR LIMIT=35] -->
    <string name="captioning_background_color">Background color</string>
    <!-- Title for the preference to change video caption background opacity. [CHAR LIMIT=35] -->
    <string name="captioning_background_opacity">Background opacity</string>
    <!-- Title for the preference to change video caption window color. [CHAR LIMIT=35] -->
    <string name="captioning_window_color">Caption window color</string>
    <!-- Title for the preference to change video caption window opacity. [CHAR LIMIT=35] -->
    <string name="captioning_window_opacity">Caption window opacity</string>
    <!-- Title for the preference to change video caption text color. [CHAR LIMIT=35] -->
    <string name="captioning_foreground_color">Text color</string>
    <!-- Title for the preference to change video caption text opacity. [CHAR LIMIT=35] -->
    <string name="captioning_foreground_opacity">Text opacity</string>
    <!-- Title for the preference to change video caption edge color. [CHAR LIMIT=35] -->
    <string name="captioning_edge_color">Edge color</string>
    <!-- Title for the preference to change video caption edge type. [CHAR LIMIT=35] -->
    <string name="captioning_edge_type">Edge type</string>
    <!-- Title for the preference to change video caption font family (ex. monospace, sans-serif). [CHAR LIMIT=35] -->
    <string name="captioning_typeface">Font family</string>
    <!-- Sample text for previewing video caption preferences. [CHAR LIMIT=NONE] -->
    <string name="captioning_preview_text">Captions will look like this</string>
    <!-- Sample characters for previewing video caption preferences. [CHAR LIMIT=2] -->
    <string name="captioning_preview_characters">Aa</string>

    <!-- Label for the default device locale. [CHAR LIMIT=35] -->
    <string name="locale_default">Default</string>

    <!-- Label for color selection title in sim settings [CHAR LIMIT=35] -->
    <string name = "color_title">Color</string>
    <!-- Label for default color. This lets the app pick the color. [CHAR LIMIT=35] -->
    <string name="color_unspecified">Default</string>
    <!-- Label for no color (transparent). [CHAR LIMIT=35] -->
    <string name="color_none">None</string>
    <!-- Label for the color white. [CHAR LIMIT=35] -->
    <string name="color_white">White</string>
    <!-- Label for the color gray. [CHAR LIMIT=35] -->
    <string name="color_gray">Gray</string>
    <!-- Label for the color black. [CHAR LIMIT=35] -->
    <string name="color_black">Black</string>
    <!-- Label for the color red. [CHAR LIMIT=35] -->
    <string name="color_red">Red</string>
    <!-- Label for the color green. [CHAR LIMIT=35] -->
    <string name="color_green">Green</string>
    <!-- Label for the color blue. [CHAR LIMIT=35] -->
    <string name="color_blue">Blue</string>
    <!-- Label for the color cyan. [CHAR LIMIT=35] -->
    <string name="color_cyan">Cyan</string>
    <!-- Label for the color yellow. [CHAR LIMIT=35] -->
    <string name="color_yellow">Yellow</string>
    <!-- Label for the color magenta. [CHAR LIMIT=35] -->
    <string name="color_magenta">Magenta</string>
    <!-- Label for custom colors, formats as a HTML color. -->
    <string name="color_custom" translatable="false">#%1$02X%2$02X%3$02X</string>

    <!-- Title for a warning about security implications of enabling an accessibility
         service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_title">Use
         <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Title for the list of capabilities of an accessibility service. -->
    <string name="capabilities_list_title"><xliff:g id="service" example="TalkBack">%1$s</xliff:g>
        needs to:</string>
    <!-- Warning shown when user input has been blocked due to another app overlaying screen
         content. Since we don't know what the app is showing on top of the input target, we
         can't verify user consent. [CHAR LIMIT=NONE] -->
    <string name="touch_filtered_warning">Because an app is obscuring a permission request, Settings
        can’t verify your response.</string>
    <!-- Warning that the device data will not be encrypted with password or PIN if
        enabling an accessibility service and there is a secure lock setup. [CHAR LIMIT=NONE] -->
    <string name="enable_service_encryption_warning">If you turn on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g>, your device won’t use your screen lock to enhance
        data encryption.</string>
    <!-- Warning that the device data will not be encrypted with password or PIN if
         choosing a secure lock and there is an enabled accessibility service. [CHAR LIMIT=NONE] -->
    <string name="secure_lock_encryption_warning">Because you\u2019ve turned on an accessibility service,
        your device won’t use your screen lock to enhance data encryption.</string>

    <!-- Message to the user to enter his pattern before enabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_pattern_reason">Because turning on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> affects data encryption, you need to confirm your pattern.
    </string>

    <!-- Message to the user to enter his PIN before enabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_pin_reason">Because turning on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> affects data encryption, you need to confirm your PIN.
    </string>

    <!-- Message to the user to enter his password before enabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="enable_service_password_reason">Because turning on <xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> affects data encryption, you need to confirm your password.
    </string>

    <!-- Title for the capability of an accessibility service to receive events and keys. -->
    <string name="capability_title_receiveAccessibilityEvents">Observe your actions</string>
    <!-- Description for the capability of an accessibility service to receive events and keys. -->
    <string name="capability_desc_receiveAccessibilityEvents">Receive notifications when you\u2019re
        interacting with an app.</string>

    <!-- Title for a warning about disabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="disable_service_title">Stop <xliff:g id="service" example="TalkBack">%1$s</xliff:g>?</string>
    <!-- Message for a warning about disabling accessibility service. [CHAR LIMIT=NONE] -->
    <string name="disable_service_message">Tapping OK will
        stop <xliff:g id="service" example="TalkBack">%1$s</xliff:g>.</string>

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

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

    <!-- Default description for an accessibility service if the latter doesn't provide one. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_default_description">No description provided.</string>

    <!-- Accessibility settings: button for lauching settings for an accessibility service -->
    <string name="settings_button">Settings</string>

    <!-- Printing settings -->
    <skip />

    <!-- Title in main settings screen for printing settings [CHAR LIMIT=15] -->
    <string name="print_settings">Printing</string>

    <!-- Print setting summary in settings screen [CHAR LIMIT=50] -->
    <string name="print_settings_summary_no_service">Off</string>

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

    <!-- Print setting summary in settings screenm indicating how many print jobs are active [CHAR LIMIT=None] -->
    <plurals name="print_jobs_summary">
        <item quantity="one">1 print job</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> print jobs</item>
    </plurals>

    <!-- Title for print service settings screen [CHAR LIMIT=25] -->
    <string name="print_settings_title">Print services</string>

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

    <!-- Title for the prompt shown as a placeholder if no printers are found while searching. [CHAR LIMIT=50] -->
    <string name="print_no_printers_found">No printers found</string>

    <!-- Title for print menu item to launch a settings activity. [CHAR LIMIT=25] -->
    <string name="print_menu_item_settings">Settings</string>

    <!-- Title for print menu item to launch the add printers activity. [CHAR LIMIT=25] -->
    <string name="print_menu_item_add_printers">Add printers</string>

    <!-- Summary for the enabled state of a print feature. [CHAR LIMIT=10] -->
    <string name="print_feature_state_on">On</string>
    <!-- Summary for the disabled state of a print feature. [CHAR LIMIT=10] -->
    <string name="print_feature_state_off">Off</string>

    <!-- Title of the action bar button to got to Play Store to download a print service. [CHAR LIMIT=25] -->
    <string name="print_menu_item_add_service">Add service</string>

    <!-- Title of the action bar button to got to add a printer. [CHAR LIMIT=25] -->
    <string name="print_menu_item_add_printer">Add printer</string>

    <!-- Title for the search action bar menu item. [CHAR LIMIT=20] -->
    <string name="print_menu_item_search">Search</string>

    <!-- Title for the prompt if no printers are available and the system is searching for such. [CHAR LIMIT=50] -->
    <string name="print_searching_for_printers">Searching for printers</string>

    <!-- Title for the prompt if no printers are available because the print service is disabled. [CHAR LIMIT=50] -->
    <string name="print_service_disabled">Service disabled</string>

    <!-- Title for the menu item to open the print jobs screen. [CHAR LIMIT=25] -->
    <string name="print_print_jobs">Print jobs</string>

    <!-- Title for the print job settings screen. [CHAR LIMIT=25] -->
    <string name="print_print_job">Print job</string>

    <!-- Title for the button to restart a print job. [CHAR LIMIT=25] -->
    <string name="print_restart">Restart</string>

    <!-- Title for the button to cancel a print job. [CHAR LIMIT=25] -->
    <string name="print_cancel">Cancel</string>

    <!-- Template for the summary of a print job. [CHAR LIMIT=25] -->
    <string name="print_job_summary"><xliff:g id="printer">%1$s</xliff:g>\n<xliff:g id="time">%2$s</xliff:g></string>

    <!-- Template for the label for a configuring print job (i.e. the user is currently selecting the paper size and printer to use). [CHAR LIMIT=25] -->
    <string name="print_configuring_state_title_template" >Configuring <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label of the state for a ongoing print job. [CHAR LIMIT=25] -->
    <string name="print_printing_state_title_template">Printing <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label for a cancelling print job. [CHAR LIMIT=25] -->
    <string name="print_cancelling_state_title_template" >Cancelling <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label of the state for a failed print job. [CHAR LIMIT=25] -->
    <string name="print_failed_state_title_template">Printer error <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Template for the label of the state for a blocked print job. [CHAR LIMIT=25] -->
    <string name="print_blocked_state_title_template">Printer blocked <xliff:g id="print_job_name" example="foo.jpg">%1$s</xliff:g></string>

    <!-- Utterance to announce that the search box is shown. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <string name="print_search_box_shown_utterance">Search box shown</string>

    <!-- Utterance to announce that the search box is hidden. This is spoken to a blind user. [CHAR LIMIT=none] -->
    <string name="print_search_box_hidden_utterance">Search box hidden</string>

    <!-- Description of printer info icon. [CHAR LIMIT=50] -->
    <string name="printer_info_desc">More information about this printer</string>

    <!-- App Fuel Gauge strings -->
    <skip />

    <!-- Activity title for App Fuel Gauge summary -->
    <string name="power_usage_summary_title">Battery</string>
    <!-- Activity title summary for App Fuel Gauge summary -->
    <string name="power_usage_summary">What has been using the battery</string>
    <!-- Message to show when battery usage data is not available [CHAR LIMIT=30] -->
    <string name="power_usage_not_available">Battery usage data isn\u2019t available.</string>
    <!-- Display the battery level and status [CHAR_LIMIT=60] -->
    <string name="power_usage_level_and_status"><xliff:g id="level">%1$s</xliff:g>
            - <xliff:g id="status">%2$s</xliff:g></string>
    <!-- Display time remaining until battery is discharged [CHAR_LIMIT=60] -->
    <string name="power_discharge_remaining"><xliff:g id="remain">%1$s</xliff:g> remaining</string>
    <!-- Display time remaining until battery is charged [CHAR_LIMIT=60] -->
    <string name="power_charge_remaining"><xliff:g id="until_charged">%1$s</xliff:g> to charge</string>

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

    <!-- Title for the screen usage in power use UI [CHAR_LIMIT=60] -->
    <string name="device_screen_usage">Screen usage since full charge</string>
    <!-- Title for the screen consumption in power use UI(i.e. Screen consumption: 30% of battery usage) [CHAR_LIMIT=40] -->
    <string name="device_screen_consumption">Screen consumption</string>
    <!-- Title for the cellular network in power use UI(i.e. Mobile network scanning: 30% of battery usage) [CHAR_LIMIT=40] -->
    <string name="device_cellular_network">Mobile network scanning</string>

    <!-- Label for list of apps using battery in power use UI. Note: ^1 should be used in all translations[CHAR_LIMIT=120] -->
    <string name="power_usage_list_summary">Battery usage since full charge</string>
    <!-- Temp string used to debug new battery estimates [DO NOT TRANSLATE] -->
    <string name="power_usage_enhanced_debug" translatable="false"><xliff:g id="time">%1$s</xliff:g> left (New ML est)</string>
    <!-- Temp string used to debug old battery estimates [DO NOT TRANSLATE] -->
    <string name="power_usage_old_debug" translatable="false"><xliff:g id="time">%1$s</xliff:g> left (Old est)</string>
    <!-- Description for the screen usage item [CHAR_LIMIT=120] -->
    <string name="screen_usage_summary">Amount of time screen has been on since full charge</string>
    <!-- Label for list of different types using battery in power use UI [CHAR_LIMIT=60] -->
    <string name="device_usage_list_summary">Device usage since full charge</string>
    <!-- Battery usage since unplugged -->
    <string name="battery_since_unplugged">Battery use since unplugged</string>
    <!-- Battery usage since user reset the stats -->
    <string name="battery_since_reset">Battery use since reset</string>
    <!-- Battery usage on battery duration -->
    <string name="battery_stats_on_battery"><xliff:g id="time">%1$s</xliff:g> on battery</string>
    <!-- Battery usage duration -->
    <string name="battery_stats_duration"><xliff:g id="time">%1$s</xliff:g> since unplugged</string>
    <!-- [CHAR LIMIT=25] Label for battery stats charging state graph -->
    <string name="battery_stats_charging_label">Charging</string>
    <!-- [CHAR LIMIT=25] Label for battery stats screen on state graph -->
    <string name="battery_stats_screen_on_label">Screen on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats gps on state graph -->
    <string name="battery_stats_gps_on_label">GPS on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats camera on state graph -->
    <string name="battery_stats_camera_on_label">Camera on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats flashlight on state graph -->
    <string name="battery_stats_flashlight_on_label">Flashlight on</string>
    <!-- [CHAR LIMIT=25] Label for battery stats wifi running state graph -->
    <string name="battery_stats_wifi_running_label">Wi\u2011Fi</string>
    <!-- [CHAR LIMIT=25] Label for battery stats wake lock state graph -->
    <string name="battery_stats_wake_lock_label">Awake</string>
    <!-- [CHAR LIMIT=25] Label for battery stats phone signal strength graph -->
    <string name="battery_stats_phone_signal_label">Mobile network signal</string>
    <!-- Battery usage during last unplugged period -->
    <string name="battery_stats_last_duration">@string/menu_stats_last_unplugged</string>
    <!-- CPU awake time title -->
    <string name="awake">Device awake time</string>
    <!-- Wifi on time -->
    <string name="wifi_on_time">Wi\u2011Fi on time</string>
    <!-- Bluetooth on time -->
    <string name="bluetooth_on_time">Wi\u2011Fi on time</string>

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

    <!-- Activity title for battery usage details for an app. or power consumer -->
    <string name="battery_details_title">Battery usage</string>
    <!-- Subtitle for application/subsystem details -->
    <string name="details_subtitle">Use details</string>
    <!-- Subtitle for possible options -->
    <string name="controls_subtitle">Adjust power use</string>
    <!-- Subtitle for list of packages -->
    <string name="packages_subtitle">Included packages</string>

    <!-- Activity title for battery abnormal details page [CHAR LIMIT=60] -->
    <string name="battery_abnormal_details_title">Apps draining battery</string>

    <!-- Summary for wakelock anomaly, means device been kept awake [CHAR LIMIT=60] -->
    <string name="battery_abnormal_wakelock_summary">Keeping device awake</string>
    <!-- Summary for wakeup alarm anomaly, meaning device been wakeup in the background [CHAR LIMIT=60] -->
    <string name="battery_abnormal_wakeup_alarm_summary">Waking up device in background</string>
    <!-- Summary for location anomaly, meaning device is requesting location too frequently [CHAR LIMIT=60] -->
    <string name="battery_abnormal_location_summary">Requesting location frequently</string>
    <!-- Summary for anomalies, meaning some apps behaving abnormally  [CHAR LIMIT=80] -->
    <string name="battery_abnormal_apps_summary"><xliff:g id="number">%1$d</xliff:g> apps misbehaving</string>

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- Text for OK button in location dialog [CHAR LIMIT=30] -->
    <string name="dialog_location_ok">Turn off</string>

    <!-- Label for power consumed by the screen -->
    <string name="power_screen">Screen</string>
    <!-- Label for power consumed by the flashlight -->
    <string name="power_flashlight">Flashlight</string>
    <!-- Label for power consumed by the camera -->
    <string name="power_camera">Camera</string>
    <!-- Label for power consumed by Wi-Fi -->
    <string name="power_wifi">Wi\u2011Fi</string>
    <!-- Label for power consumed by Bluetooth -->
    <string name="power_bluetooth">Bluetooth</string>
    <!-- Label for power consumed by Mobile network idle -->
    <string name="power_cell">Mobile network standby</string>
    <!-- Label for power consumed by Calling -->
    <string name="power_phone">Voice calls</string>
    <!-- Label for power consumed when Idle -->
    <string name="power_idle" product="tablet">Tablet idle</string>
    <!-- Label for power consumed when Idle -->
    <string name="power_idle" product="default">Phone idle</string>
    <!-- Label for power that we aren't able to account for -->
    <string name="power_unaccounted">Miscellaneous</string>
    <!-- Label for power that we computed too much for -->
    <string name="power_overcounted">Over-counted</string>

    <!-- Label for CPU usage time -->
    <string name="usage_type_cpu">CPU total</string>
    <!-- Label for CPU usage in foreground -->
    <string name="usage_type_cpu_foreground">CPU foreground</string>
    <!-- [CHAR LIMIT=25] Label for keeping device from sleeping -->
    <string name="usage_type_wake_lock">Keep awake</string>
    <!-- Label for GPS usage time -->
    <string name="usage_type_gps">GPS</string>
    <!-- [CHAR LIMIT=25] Label for WIFI usage time -->
    <string name="usage_type_wifi_running">Wi\u2011Fi running</string>
    <!-- Label for Phone usage time -->
    <string name="usage_type_phone" product="tablet">Tablet</string>
    <!-- Label for Phone usage time -->
    <string name="usage_type_phone" product="default">Phone</string>
    <!-- Label for mobile network data sent [CHAR LIMIT=32] -->
    <string name="usage_type_data_send">Mobile packets sent</string>
    <!-- Label for mobile network data received [CHAR LIMIT=32] -->
    <string name="usage_type_data_recv">Mobile packets received</string>
    <!-- Label for mobile network radio active time [CHAR LIMIT=32] -->
    <string name="usage_type_radio_active">Mobile radio active</string>
    <!-- Label for Wi-Fi network data sent [CHAR LIMIT=32] -->
    <string name="usage_type_data_wifi_send">Wi\u2011Fi packets sent</string>
    <!-- Label for Wi-Fi network data received [CHAR LIMIT=32] -->
    <string name="usage_type_data_wifi_recv">Wi\u2011Fi packets received</string>
    <!-- Label for Audio usage time -->
    <string name="usage_type_audio">Audio</string>
    <!-- Label for Video usage time -->
    <string name="usage_type_video">Video</string>
    <!-- Label for Camera usage time -->
    <string name="usage_type_camera">Camera</string>
    <!-- Label for Flashlight usage time -->
    <string name="usage_type_flashlight">Flashlight</string>
    <!-- Label for time that a feature has been on -->
    <string name="usage_type_on_time">Time on</string>
    <!-- Label for time that there was no cell coverage -->
    <string name="usage_type_no_coverage">Time without a signal</string>
    <!-- Label for the total power capacity of the device's battery -->
    <string name="usage_type_total_battery_capacity">Total battery capacity</string>
    <!-- [CHAR_LIMIT=NONE] Label for amount of power use that was computed -->
    <string name="usage_type_computed_power">Computed power use</string>
    <!-- [CHAR_LIMIT=NONE] Label for amount of power use that was actually observed (though
         the change in battery level) -->
    <string name="usage_type_actual_power">Observed power use</string>
    <!-- Label for force stop action -->
    <string name="battery_action_stop">Force stop</string>
    <!-- Label for app details action -->
    <string name="battery_action_app_details">App info</string>
    <!-- Label for app settings action -->
    <string name="battery_action_app_settings">App settings</string>
    <!-- Label for display settings -->
    <string name="battery_action_display">Screen settings</string>
    <!-- Label for wifi settings -->
    <string name="battery_action_wifi">Wi\u2011Fi settings</string>
    <!-- Label for bluetooth settings -->
    <string name="battery_action_bluetooth">Bluetooth settings</string>

    <!-- Description for voice call detail -->
    <string name="battery_desc_voice">Battery used by voice calls</string>

    <!-- Description for standby detail -->
    <string name="battery_desc_standby" product="tablet">Battery used when tablet is idle</string>
    <!-- Description for standby detail -->
    <string name="battery_desc_standby" product="default">Battery used when phone is idle</string>

    <!-- Description for cell radio detail -->
    <string name="battery_desc_radio">Battery used by cell radio</string>
    <!-- Suggestion to switch to airplane mode to save power -->
    <string name="battery_sugg_radio">Switch to airplane mode to save power in areas with no cell coverage</string>

    <!-- [CHAR_LIMIT=NONE] Description for power consumed by the flashlight -->
    <string name="battery_desc_flashlight">Battery used by the flashlight</string>

    <!-- [CHAR_LIMIT=NONE] Description for power consumed by the camera -->
    <string name="battery_desc_camera">Battery used by the camera</string>

    <!-- Description for power consumed by display -->
    <string name="battery_desc_display">Battery used by the display and backlight</string>
    <!-- Suggestion for reducing display power -->
    <string name="battery_sugg_display">Reduce the screen brightness and/or screen timeout</string>

    <!-- Description for wifi connectivity -->
    <string name="battery_desc_wifi">Battery used by Wi\u2011Fi</string>
    <!-- Suggestion for wifi connectivity power drain -->
    <string name="battery_sugg_wifi">Turn off Wi\u2011Fi when not using it or when it isn\u2019t available</string>

    <!-- Description for bluetooth power consumption detail -->
    <string name="battery_desc_bluetooth">Battery used by Bluetooth</string>
    <!-- Suggestion for bluetooth -->
    <string name="battery_sugg_bluetooth_basic">Turn off Bluetooth when you aren\u2019t using it</string>
    <!-- Suggestion for bluetooth headset -->
    <string name="battery_sugg_bluetooth_headset">Try connecting to a different Bluetooth device</string>

    <!-- [CHAR LIMIT=50] Description for power consumed by applications -->
    <string name="battery_desc_apps">Battery used by app</string>
    <!-- Suggestion for exploring application info to stop or uninstall -->
    <string name="battery_sugg_apps_info">Stop or uninstall the app</string>
    <!-- [CHAR LIMIT=100] Suggestion for getting apps to consume less power due to GPS-->
    <string name="battery_sugg_apps_gps">Select battery-saving mode</string>
    <!-- Suggestion for getting apps to consume less power -->
    <string name="battery_sugg_apps_settings">The app may offer settings to reduce battery use</string>

    <!-- [CHAR LIMIT=50] Description for power consumed by users -->
    <string name="battery_desc_users">Battery used by user</string>

    <!-- [CHAR LIMIT=50] Description for unaccounted power use -->
    <string name="battery_desc_unaccounted">Miscellaneous power use</string>
    <!-- [CHAR LIMIT=NONE] Description for unaccounted power use -->
    <string name="battery_msg_unaccounted">Battery use is an approximation of power
        use and does not include every source of battery drain.  Miscellaneous is the difference
        between the computed approximate power use and the actual drain observed on the
        battery.</string>
    <!-- [CHAR LIMIT=50] Description for over-counted power use -->
    <string name="battery_desc_overcounted">Over-counted power use</string>
    <!-- Representation of a mAh value. [CHAR LIMIT=NONE] -->
    <string name="mah"><xliff:g id="number" example="30">%d</xliff:g> mAh</string>

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

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

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

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

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

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

    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Label for kernel threads in battery usage -->
    <string name="process_kernel_label">Android OS</string>
    <!-- Label for mediaserver process in battery usage -->
    <string name="process_mediaserver_label">Mediaserver</string>
    <!-- Label for dex2oat process in battery usage used for the optimization of one or more apps -->
    <string name="process_dex2oat_label">App optimization</string>

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

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

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

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

    <!-- Used in the Battery Saver settings screen to control turning on/off the feature entirely -->
    <string name="battery_saver_master_switch_title">Use Battery Saver</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Title for automatic entry option -->
    <string name="battery_saver_turn_on_automatically_title">Turn on automatically</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Value for automatic entry option: Never -->
    <string name="battery_saver_turn_on_automatically_never">Never</string>

    <!-- [CHAR_LIMIT=40] Battery saver: Value for automatic entry option: pct% battery -->
    <string name="battery_saver_turn_on_automatically_pct">at <xliff:g id="percent">%1$s</xliff:g> battery</string>

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

    <!-- Process Stats strings -->
    <skip />

    <!-- [CHAR LIMIT=NONE] Activity title for Process Stats summary -->
    <string name="process_stats_summary_title">Process Stats</string>
    <!-- [CHAR LIMIT=NONE] Activity title summary for Process Stats summary -->
    <string name="process_stats_summary">Geeky stats about running processes</string>
    <!-- [CHAR LIMIT=NONE] Label for amount of memory use -->
    <string name="app_memory_use">Memory use</string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, duration of time the stats are over;
         timeDuration is a duration such as "1h 30m" -->
    <string name="process_stats_total_duration"><xliff:g id="usedRam">%1$s</xliff:g>
        of <xliff:g id="totalRam">%2$s</xliff:g> used over last
        <xliff:g id="timeDuration">%3$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, duration of time the stats are over;
         timeDuration is a duration such as "1h 30m" -->
    <string name="process_stats_total_duration_percentage"><xliff:g id="percent" example="50%">%1$s</xliff:g>
        of RAM used over
        <xliff:g id="timeDuration">%2$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, text for stats type -->
    <string name="process_stats_type_background">Background</string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, text for stats type -->
    <string name="process_stats_type_foreground">Foreground</string>
    <!-- [CHAR LIMIT=NONE] Label for process stats, text for stats type -->
    <string name="process_stats_type_cached">Cached</string>
    <!-- [CHAR LIMIT=NONE] Label OS "process" app -->
    <string name="process_stats_os_label">Android OS</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for all native processes -->
    <string name="process_stats_os_native">Native</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for all kernel memory -->
    <string name="process_stats_os_kernel">Kernel</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for all zram memory -->
    <string name="process_stats_os_zram">Z-Ram</string>
    <!-- [CHAR LIMIT=NONE] Name of OS "process" for base memory needed for caches -->
    <string name="process_stats_os_cache">Caches</string>
    <!-- [CHAR LIMIT=NONE] Label for item showing details of average RAM use -->
    <string name="process_stats_ram_use">RAM use</string>
    <!-- [CHAR LIMIT=NONE] Label for item showing details of average RAM use -->
    <string name="process_stats_bg_ram_use">RAM use (background)</string>
    <!-- [CHAR LIMIT=NONE] Label for item showing percent of time spent running -->
    <string name="process_stats_run_time">Run time</string>
    <!-- [CHAR LIMIT=NONE] Subtitle for process stats processes list -->
    <string name="processes_subtitle">Processes</string>
    <!-- [CHAR LIMIT=NONE] Subtitle for process stats services list -->
    <string name="services_subtitle">Services</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to select duration of stats to show -->
    <string name="menu_proc_stats_duration">Duration</string>
    <!-- [CHAR LIMIT=NONE] Activity title for process stats details on overall memory state -->
    <string name="mem_details_title">Memory details</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_3h">3 hours</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_6h">6 hours</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_12h">12 hours</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show 3 hours of data -->
    <string name="menu_duration_1d">1 day</string>
    <!-- [CHAR LIMIT=NONE] Menu for manage apps to control whether system processes are shown -->
    <string name="menu_show_system">Show system</string>
    <!-- [CHAR LIMIT=NONE] Menu for manage apps to control whether system processes are hidden -->
    <string name="menu_hide_system">Hide system</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to control whether stats are shown
         as percentages-->
    <string name="menu_show_percentage">Show percentages</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to control whether computation should be based
        on Uss (Unique Set Size) instead of Pss (Proportional Set Size) -->
    <string name="menu_use_uss">Use Uss</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to select which type of stats to show -->
    <string name="menu_proc_stats_type">Stats type</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show information on background processes -->
    <string name="menu_proc_stats_type_background">Background</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show information on foreground processes -->
    <string name="menu_proc_stats_type_foreground">Foreground</string>
    <!-- [CHAR LIMIT=NONE] Menu for process stats to show information on cached processes -->
    <string name="menu_proc_stats_type_cached">Cached</string>

    <!-- Voice input/output settings --><skip />
    <!-- Title of setting on main settings screen. This item will take the user to the screen to tweak settings related to speech functionality -->
    <string name="voice_input_output_settings">Voice input &amp; output</string>
    <!-- Main voice input/output settings screen title -->
    <string name="voice_input_output_settings_title">Voice input &amp; output settings</string>
    <!-- Title of voice search settings list item within voice input/output settings -->
    <string name="voice_search_settings_title">Voice search</string>
    <!-- Title of keyboard settings list item within voice input/output settings -->
    <string name="keyboard_settings_title">Android keyboard</string>

    <!-- Voice input settings --><skip />
    <!-- [CHAR_LIMIT=NONE] Name of the settings item to open the voice input settings. -->
    <string name="voice_input_settings">Voice input settings</string>
    <!-- [CHAR_LIMIT=NONE] Title of the screen of the voice input settings -->
    <string name="voice_input_settings_title">Voice input</string>
    <!-- [CHAR LIMIT=50] The text for the settings section in which users select
         a voice interaction or recognition service to use. -->
    <string name="voice_service_preference_section_title">Voice input services</string>
    <!-- [CHAR LIMIT=NONE] The summary text for the voice service preference that is
         a full voice interaction service.  This is something that provides interactive
         voice control of applications; for example you can tell it commands to have it
         launch and let you interact with applications through your voice. -->
    <string name="voice_interactor_preference_summary">Full hotword and interaction</string>
    <!-- [CHAR LIMIT=NONE] The summary text for the voice service preference that is
         a simple voice recognition service.  This is something that only provides simple
         speech to text conversions that applications can use when they want to allow you
         to provide text to them through your voice (instead of with a keyboard). -->
    <string name="voice_recognizer_preference_summary">Simple speech to text</string>
    <!-- [CHAR_LIMIT=NONE] Warning message about security implications of enabling a
         voice interaction service, displayed as a dialog
         message when the user selects to enable a service. -->
    <string name="voice_interaction_security_warning">This voice input service will be able to
        perform always-on voice monitoring and control voice enabled applications on your
        behalf.  It comes from the <xliff:g id="voice_input_service_app_name">%s</xliff:g>
        application.  Enable the use of this service?</string>

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

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

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

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

    <!-- Name for buttont hat plays a sample of the currently selected text-to-speech engine. -->
    <string name="tts_play">Play</string>

    <!-- Power Control Widget -->
    <string name="gadget_title">Power control</string>
    <string name="gadget_toggle_wifi">Updating Wi\u2011Fi setting</string>
    <string name="gadget_toggle_bluetooth">Updating Bluetooth setting</string>
    <!-- Template for gadget toggle button description. Populated examples are "Wi-Fi off" or "Wi-Fi turning on". -->
    <string name="gadget_state_template"><xliff:g name="feature" example="Wi\u2011Fi">%1$s</xliff:g> <xliff:g name="state" example="off">%2$s</xliff:g></string>
    <!-- Gadget value used to describe on state. -->
    <string name="gadget_state_on">on</string>
    <!-- Gadget value used to describe off state. -->
    <string name="gadget_state_off">off</string>
    <!-- Gadget value used to describe turning on state. -->
    <string name="gadget_state_turning_on">turning on</string>
    <!-- Gadget value used to describe turning off state. -->
    <string name="gadget_state_turning_off">turning off</string>
    <!-- Spoken description for the Wi-Fi power control gadget. -->
    <string name="gadget_wifi">Wi\u2011Fi</string>
    <!-- Spoken description for the Bluetooth power control gadget. -->
    <string name="gadget_bluetooth">Bluetooth</string>
    <!-- Spoken description for the Location power control gadget. -->
    <string name="gadget_location">Location</string>
    <!-- Spoken description for the data synchronization gadget. -->
    <string name="gadget_sync">Sync</string>
    <!-- Template for brightness gadget toggle button description. -->
    <string name="gadget_brightness_template">Brightness <xliff:g name="state" example="half">%1$s</xliff:g></string>
    <!-- Brightness gadget value used to describe automatic brightness state. -->
    <string name="gadget_brightness_state_auto">auto</string>
    <!-- Brightness gadget value used to describe maximum brightness state. -->
    <string name="gadget_brightness_state_full">full</string>
    <!-- Brightness gadget value used to describe half brightness state. -->
    <string name="gadget_brightness_state_half">half</string>
    <!-- Brightness gadget value used to describe minimum brightness state. -->
    <string name="gadget_brightness_state_off">off</string>

    <!-- Title of preference to enter the VPN settings activity -->
    <string name="vpn_settings_title">VPN</string>

    <!-- Title of preference group for credential storage settings [CHAR LIMIT=30] -->
    <string name="credentials_title">Credential storage</string>
    <!-- Title of preference to install certificates from SD card [CHAR LIMIT=30] -->
    <string name="credentials_install" product="nosdcard">Install from storage</string>
    <!-- Title of preference to install certificates from SD card [CHAR LIMIT=30] -->
    <string name="credentials_install" product="default">Install from SD card</string>
    <!-- Summary of preference to install certificates from SD card [CHAR LIMIT=NONE] -->
    <string name="credentials_install_summary" product="nosdcard">Install certificates from storage</string>
    <!-- Summary of preference to install certificates from SD card [CHAR LIMIT=NONE] -->
    <string name="credentials_install_summary" product="default">Install certificates from SD card</string>
    <!-- Title of preference to reset credential storage [CHAR LIMIT=30] -->
    <string name="credentials_reset">Clear credentials</string>
    <!-- Summary of preference to reset credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_summary">Remove all certificates</string>
    <!-- Title of preference to display trusted credentials (aka CA certificates) [CHAR LIMIT=30] -->
    <string name="trusted_credentials">Trusted credentials</string>
    <!-- Summary of preference to display trusted credentials (aka CA certificates) [CHAR LIMIT=NONE] -->
    <string name="trusted_credentials_summary">Display trusted CA certificates</string>
    <!-- Title of preference to display user credentials and keys [CHAR LIMIT=30] -->
    <string name="user_credentials">User credentials</string>
    <!-- Summary of preference to display user credentials and keys [CHAR LIMIT=NONE] -->
    <string name="user_credentials_summary">View and modify stored credentials</string>
    <!-- Title of preference group for advance security settings [CHAR LIMIT=30] -->
    <string name="advanced_security_title">Advanced</string>
    <!-- Title of preference of what type of credential storage this device has: hardware or software [CHAR LIMIT=30] -->
    <string name="credential_storage_type">Storage type</string>
    <!-- Summary text for preference showing what type of credential storage this device has when it is stored in a hardware-backed storage (as opposed to "software only") [CHAR LIMIT=NONE] -->
    <string name="credential_storage_type_hardware">Hardware-backed</string>
    <!-- Summary text for preference showing what type of credential storage this device has when it is stored in software only (as opposed to "hardware-backed") [CHAR LIMIT=NONE] -->
    <string name="credential_storage_type_software">Software only</string>
    <!-- Error message for users that aren't allowed to see or modify credentials [CHAR LIMIT=none] -->
    <string name="credentials_settings_not_available">Credentials are not available for this user</string>
    <!-- Sub-heading for a user credential installed to be used by apps and as part of VPN configurations. [CHAR LIMIT=NONE] -->
    <string name="credential_for_vpn_and_apps">Installed for VPN and apps</string>
    <!-- Sub-heading for a user credential installed to be used as part of a Wi-Fi configuration. [CHAR LIMIT=NONE]. -->
    <string name="credential_for_wifi">Installed for Wi-Fi</string>

    <!-- Title of dialog to enable credential storage [CHAR LIMIT=30] -->
    <string name="credentials_unlock"></string>
    <!-- Description of dialog to enable credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_unlock_hint">Type the password for credential storage.</string>
    <!-- Description of the input box for the old password [CHAR LIMIT=30] -->
    <string name="credentials_old_password">Current password:</string>
    <!-- Description of dialog to reset credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_hint">Remove all the contents?</string>
    <!-- Error message [CHAR LIMIT=NONE] -->
    <string name="credentials_wrong_password">Incorrect password.</string>
    <!-- Error message [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_warning">Incorrect password. You have one more chance before credential storage is erased.</string>
    <!-- Error message [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_warning_plural">Incorrect password. You have <xliff:g id="number" example="5">%1$d</xliff:g> more chances before credential storage is erased.</string>
    <!-- Toast message [CHAR LIMIT=30] -->
    <string name="credentials_erased">Credential storage is erased.</string>
    <!-- Toast message [CHAR LIMIT=30] when credential storage containing private keys and certificates could not be erased (opposite of string credentials_erased) -->
    <string name="credentials_not_erased">Credential storage couldn\u2019t be erased.</string>
    <!-- Toast message [CHAR LIMIT=30] -->
    <string name="credentials_enabled">Credential storage is enabled.</string>
    <!-- This string is in a dialog, and the dialog shows up on a device that's managed by a user's company. It lets the user know that they need to have a secure lock screen (PIN, password, or pattern) before they can use credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_configure_lock_screen_hint">Before you can use credential storage, your device need to have a secure lock screen</string>
    <!-- This string is for the content of the button that leads user to lock screen settings  [CHAR LIMIT=20] -->
    <string name="credentials_configure_lock_screen_button">SET LOCK</string>
    <!-- Title of Usage Access preference item [CHAR LIMIT=30] -->
    <string name="usage_access_title">Apps with usage access</string>

    <!-- Sound settings screen, setting check box label -->
    <string name="emergency_tone_title">Emergency dialing signal</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="emergency_tone_summary">Set behavior when an emergency call is placed</string>

    <!-- Backup and reset Settings screen --><skip />
    <!-- Backup and reset settings menu and activity title -->
    <string name="privacy_settings_title">Backup</string>
    <!-- Backup section title -->
    <string name="backup_section_title">Backup &amp; restore</string>
    <!-- Personal data section title -->
    <string name="personal_data_section_title">Personal data</string>
    <!-- Backup data menu title -->
    <string name="backup_data_title">Back up my data</string>
    <!-- Summary text of the "back up data" setting -->
    <string name="backup_data_summary">Back up app data, Wi\u2011Fi passwords, and other settings to Google servers</string>
    <!-- Configure backup account options menu title [CHAR LIMIT=25]-->
    <string name="backup_configure_account_title">Backup account</string>
    <!-- Auto-restore menu title [CHAR LIMIT=30] -->
    <string name="include_app_data_title">Include app data</string>
    <!-- Auto-restore menu title -->
    <string name="auto_restore_title">Automatic restore</string>
    <!-- Summary text of the "automatic restore" setting -->
    <string name="auto_restore_summary">When reinstalling an app, restore backed up settings and data</string>
    <!-- Title of the preference informing the user about the backup service being inactive [CHAR LIMIT=50]-->
    <string name="backup_inactive_title">Backup service isn\'t active</string>
    <!-- Default summary text of the "Configure backup account" setting [CHAR LIMIT=80]-->
    <string name="backup_configure_account_default_summary">No account is currently storing backed up data</string>

    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_title"></string>
    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_message">Stop backing up your Wi\u2011Fi passwords, bookmarks, other settings, and app data, plus erase all copies on Google servers?</string>
    <!-- Dialog title for confirmation to erase full backup data from server -->
    <string name="fullbackup_erase_dialog_message">Stop backing up device data (such as Wi-Fi passwords and call history) and app data (such as settings and files stored by apps), plus erase all copies on remote servers?</string>
    <!-- Summary for explanation of what full app data backup means. Manufacturers may wish to overlay this resource with their own text  -->
    <string name="fullbackup_data_summary">Automatically back up device data (such as Wi-Fi passwords and call history) and app data (such as settings and files stored by apps) remotely.\n\nWhen you turn on automatic backup, device and app data is periodically saved remotely. App data can be any data that an app has saved (based on developer settings), including potentially sensitive data such as contacts, messages, and photos.</string>
    <!-- Device admin app settings screen --><skip />
    <!-- Device admin app settings activity title -->
    <string name="device_admin_settings_title">Device admin settings</string>
    <!-- Label for screen showing the active device admin apps -->
    <string name="active_device_admin_msg">Device admin app</string>
    <!-- Label for button to remove the active device admin app [CHAR LIMIT=80] -->
    <string name="remove_device_admin">Deactivate this device admin app</string>
    <!-- Label for button to uninstall the device admin app [CHAR LIMIT=80] -->
    <string name="uninstall_device_admin">Uninstall app</string>
    <!-- Label for button to deactivate and uninstall the device admin app [CHAR_LIMIT=50]-->
    <string name="remove_and_uninstall_device_admin">Deactivate &amp; uninstall</string>
    <!-- Label for screen showing to select device admin apps -->
    <string name="select_device_admin_msg">Device admin apps</string>
    <!-- Message when there are no available device admin apps to display -->
    <string name="no_device_admins">No device admin apps available</string>
    <!-- Title for personal device admin apps on the list [CHAR_LIMIT=25] -->
    <string name="personal_device_admin_title">Personal</string>
    <!-- Title for managed device admin apps on the list [CHAR_LIMIT=25] -->
    <string name="managed_device_admin_title">Work</string>

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

    <!-- Title for screen to add a device admin app [CHAR LIMIT=40] -->
    <string name="add_device_admin_msg">Activate device admin app?</string>
    <!-- Label for button to set the active device admin [CHAR_LIMIT=80] -->
    <string name="add_device_admin">Activate this device admin app</string>
    <!-- Device admin add activity title -->
    <string name="device_admin_add_title">Device admin</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_warning">Activating this admin app will allow
        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_status">This admin app is active and allows
        the app <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>

    <!-- Title for screen to set a profile owner [CHAR LIMIT=40] -->
    <string name="profile_owner_add_title">Activate Profile Manager?</string>
    <!-- Warning when trying to add a profile owner admin after setup has completed. [CHAR LIMIT=none] -->
    <string name="adding_profile_owner_warning">By proceeding, your user will be managed by your
        admin which may also be able to store associated data, in addition to your personal
        data.\n\nYour admin has the ability to monitor and manage settings, access, apps,
        and data associated with this user, including network activity and your device\'s location
        information.</string>

    <!-- Message displayed to let the user know that some of the options are disabled by admin. [CHAR LIMIT=NONE] -->
    <string name="admin_disabled_other_options">Other options are disabled by your admin</string>
    <string name="admin_more_details">More details</string>

    <string name="sound_category_sound_title">General</string>
    <string name="notification_log_title">Notification log</string>

    <!-- Category title for phone call's ringtone and vibration settings in the Sound Setting.
         [CHAR LIMIT=40] -->
    <string name="sound_category_call_ringtone_vibrate_title">Call ringtone &amp; vibrate</string>

    <!-- Category title for system-wide notification and feedback settings in the Sound Setting.
         [CHAR LIMIT=40] -->
    <string name="sound_category_system_title">System</string>

    <!-- Wifi Setup For Setup Wizard with XL screen -->
    <!-- Title shown in Wifi Setup Wizard with XL screen -->
    <string name="wifi_setup_title">Wi\u2011Fi setup</string>
    <!-- Title shown in Wifi Setup Wizard with XL screen when
         a user is configuring password for a network.
         The argument should be the name of the network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_editing_network">Connect to Wi\u2011Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
    <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
         the device is connecting a network the user specified.
         The argument should be the name of the network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_connecting_network">Connecting to Wi\u2011Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g>\u2026</string>
    <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
         the device successfully connected to a network the user specified.
         The argument should be the name of the network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_connected_network">Connected to Wi\u2011Fi network <xliff:g id="network_name" example="Happy Mobile">%s</xliff:g></string>
    <!-- Title shown in Wifi Setup For Setup Wizard with XL screen when
         a user is adding a network.
         [CHAR LIMIT=50] -->
    <string name="wifi_setup_title_add_network">Add a network</string>
    <!-- Text message shown when Wifi is not connected.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_not_connected">Not connected</string>
    <!-- Button message shown on the button adding manual setting.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_add_network">Add network</string>
    <!-- Button message shown on the button refreshing a list of network.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_refresh_list">Refresh list</string>
    <!-- Button message shown on the button enabling users skip Wifi Setup.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=10] -->
    <string name="wifi_setup_skip">Skip</string>
    <!-- Button message shown on the button enabling users go the next step.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=10] -->
    <string name="wifi_setup_next">Next</string>
    <!-- Button label to go back to previous screen. Used in SetupWizard for
      XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_back">Back</string>
    <!-- Button label to show detailed dialog for a selected Wi-Fi settings.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=20] -->
    <string name="wifi_setup_detail">Network details</string>
    <!-- Button label to connect to a Wi-Fi network.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_connect">Connect</string>
    <!-- Button label to delete a Wi-Fi network.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_forget">Forget</string>
    <!-- Button label to save a Wi-Fi network configuration.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_save">Save</string>
    <!-- Button label to dismiss the dialog.
         Used in SetupWizard for XLarge screen [CHAR LIMIT=10] -->
    <string name="wifi_setup_cancel">Cancel</string>

    <!-- The message shown above available networks when the device is scanning
         available networks [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_scanning">Scanning networks\u2026</string>
    <!-- Message shown above available network when there's no connected network.
         Used in Wifi Setup For Setup Wizard with XL screen. -->
    <string name="wifi_setup_status_select_network">Tap a network to connect to it</string>
    <!-- Message shown above available networks when a user clicked one of available
         networks and the UI is showing one possible existing network.
         Used in Wifi Setup. -->
    <string name="wifi_setup_status_existing_network">Connect to existing network</string>
    <!-- Message shown above available networks when a user clicked one of available
         networks and the network doesn't require configuration (e.g. password)
         Used in Wifi Setup with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_unsecured_network">Connect to unsecured network</string>
    <!-- Message shown above available networks when a user clicked one of available
         networks and the UI is prompting the user to edit the network configuration
         if needed. Used in Wifi Setup with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_edit_network">Type network configuration</string>
    <!-- The message shown above available networks when a user clicked "Add network"
         button. Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_new_network">Connect to new network</string>
    <!-- The message shown above available networks when a user clicked one of available
         networks or created another profile and he/she is waiting for the connection
         is established.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_connecting">Connecting\u2026</string>
    <!-- The message shown above available networks when connection is established,
         letting a user to proceed to the next step of the SetupWizard.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_proceed_to_next">Go to the next step</string>
    <!-- The message shown above available networks when a user clicked a network secured by
         EAP. We don't allow the user to connect it.
         Used in Wifi Setup For Setup Wizard with XL screen. [CHAR LIMIT=35] -->
    <string name="wifi_setup_status_eap_not_supported">EAP isn\u2019t supported.</string>
    <!-- Message shown when users select EAP in Wi-Fi settings for SetupWizard,
         saying EAP can't be configured in SetupWizard flow.
         [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_eap_not_supported">You can\u2019t configure an EAP Wi\u2011Fi connection during setup. After setup, you can do that in Settings &gt; Wireless &amp; networks.</string>
    <!-- Message shown when the device is connecting a network [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_description_connecting">Connecting can take a few minutes\u2026</string>
    <!-- Message shown when the device is connected to a network [CHAR LIMIT=NONE] -->
    <string name="wifi_setup_description_connected">Tap <b>Next</b> to continue with setup.\n\nTap <b>Back</b> to connect to a different Wi\u2011Fi network.</string>

    <!-- Do not translate. This is a stub which will be removed soon. -->
    <string name="time_zone_auto_stub" translatable="false">Select Time Zone</string>

    <!-- Content description of the enabled sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_enabled">Sync enabled</string>
    <!-- Content description of the disabled sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_disabled">Sync disabled</string>
    <!-- Content description of the in progress sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_in_progress">Syncing now</string>
    <!-- Content description of the disabled sync icon for accessibility. [CHAR LIMIT=NONE] -->
    <string name="accessibility_sync_error">Sync error.</string>
    <!-- Image description for the sync failed icon. -->
    <string name="sync_failed">Sync failed</string>
    <!-- Animation description for the sync active icon. -->
    <string name="sync_active">Sync active</string>

    <!-- Account specific sync settings title [CHAR LIMIT=35] -->
    <string name="account_sync_settings_title">Sync</string>
    <!-- Message when sync is currently failing [CHAR LIMIT=100] -->
    <string name="sync_is_failing">Sync is currently experiencing problems. It will be back shortly.</string>
    <!-- Button label to add an account [CHAR LIMIT=20] -->
    <string name="add_account_label">Add account</string>
    <!-- Label for the state of the work profile [CHAR LIMIT=80] -->
    <string name="managed_profile_not_available_label">Work profile isn\u2019t available yet</string>
    <!-- This string is the title of a setting. If a user taps the setting, they can turn their work profile on or off. The work profile is a section of their phone that's managed by their employer. "Work" is an adjective. -->
    <string name="work_mode_label">Work profile</string>
    <!-- This string is located under a setting and describes what the setting does. It's letting a user know whether their work profile is on or off, and they can use the setting to turn it on or off. The work profile is a section of their phone that's managed by their employer. "Work" is an adjective.-->
    <string name="work_mode_on_summary">Managed by your organization</string>
    <!-- This string is located under a setting and describes what the setting does. It's letting a user know whether their work profile is on or off, and they can use the setting to turn it on or off. The work profile is a section of their phone that's managed by their employer. "Work" is an adjective.-->
    <string name="work_mode_off_summary">Apps and notifications are off</string>
    <!-- Button label to remove the work profile [CHAR LIMIT=35] -->
    <string name="remove_managed_profile_label">Remove work profile</string>
    <!-- Data synchronization settings screen, title of setting that controls whether background data should be used [CHAR LIMIT=30] -->
    <string name="background_data">Background data</string>
    <!-- Data synchronization settings screen, summary of setting that controls whether background data should be used [CHAR LIMIT=60] -->
    <string name="background_data_summary">Apps can sync, send, and receive data at any time</string>
    <!-- Data synchronization settings screen, title of dialog that confirms the user's unchecking of background data [CHAR LIMIT=20] -->
    <string name="background_data_dialog_title">Disable background data?</string>
    <!-- Data synchronization settings screen, message of dialog that confirms the user's unchecking of background data [CHAR LIMIT=200] -->
    <string name="background_data_dialog_message">Disabling background data extends battery life and lowers data use. Some apps may still use the background data connection.</string>
    <!-- Title for a checkbox that enables data synchronization in the account and sync screen [CHAR LIMIT=35] -->
    <string name="sync_automatically">Auto-sync app data</string>

    <!-- Sync status messages on Accounts & Synchronization settings --><skip />
    <!-- Sync status shown when sync is enabled [CHAR LIMIT=25] -->
    <string name="sync_enabled">Sync is ON</string>
    <!-- Sync status shown when sync is disabled [CHAR LIMIT=25] -->
    <string name="sync_disabled">Sync is OFF</string>
    <!-- Sync status shown when last sync resulted in an error [CHAR LIMIT=25] -->
    <string name="sync_error">Sync error</string>
    <!-- Last synced date/time for accounts that synced [CHAR LIMIT=none] -->
    <string name="last_synced">Last synced <xliff:g id="last_sync_time">%1$s</xliff:g></string>
    <!-- Sync status shown when sync is disabled [CHAR LIMIT=30] -->
    <string name="sync_in_progress">Syncing now\u2026</string>

    <!-- Data synchronization settings screen, setting option name -->
    <string name="settings_backup">Back up settings</string>
    <!-- Data synchronization settings screen, setting option summary text when check box is selected -->
    <string name="settings_backup_summary">Back up my settings</string>
    <!-- Data synchronization settings screen, menu option -->
    <string name="sync_menu_sync_now">Sync now</string>
    <!-- Data synchronization settings screen, menu option -->
    <string name="sync_menu_sync_cancel">Cancel sync</string>
    <!-- Data synchronization settings screen, summary of a sync provider (for example, Gmail) when autosync is off and the user wants to do a one-time sync. -->
    <string name="sync_one_time_sync">Tap to sync now<xliff:g id="last_sync_time">\n%1$s</xliff:g></string>
    <!-- Data synchronization settings screen, checkbox setting option name. Controls whether Gmail should be synced.  Should use "Gmail" to refer to this app.-->
    <string name="sync_gmail">Gmail</string>
    <!-- Data synchronization settings screen, checkbox setting option name. Controls whether Calendar shoudl be synced. -->
    <string name="sync_calendar">Calendar</string>
    <!-- Data synchronization settings screen, checkbox setting option name -->
    <string name="sync_contacts">Contacts</string>
    <!-- Message introducing the user to Google Sync. -->
    <string name="sync_plug"><font fgcolor="#ffffffff">Welcome to Google sync!</font>
    \nA Google approach to syncing data to allow access to your contacts, appointments, and more from wherever you are.
    </string>

    <!-- Header title for those settings relating to application syncing. -->
    <string name="header_application_sync_settings">App sync settings</string>

    <!-- Header for data and synchronization -->
    <string name="header_data_and_synchronization">Data &amp; synchronization</string>
    <!-- Preference item that lets the user change password -->
    <string name="preference_change_password_title">Change password</string>
    <!-- Header that appears at the top of Account Settings screen -->
    <string name="header_account_settings">Account settings</string>
    <!-- Button label to remove current account -->
    <string name="remove_account_label">Remove account</string>
    <!-- Title shown in AddAccount -->
    <string name="header_add_an_account">Add an account</string>
    <!-- Button shown when this activity is run from SetupWizard -->
    <string name="finish_button_label">Finish</string>
    <!-- Title of remove message for remove account dialog -->
    <string name="really_remove_account_title">Remove account?</string>
    <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
    <string name="really_remove_account_message" product="tablet">Removing this account will delete all of its messages, contacts, and other data from the tablet!</string>
    <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
    <string name="really_remove_account_message" product="default">Removing this account will delete all of its messages, contacts, and other data from the phone!</string>
    <!-- Remove account message in dialog [CHAR LIMIT=NONE] -->
    <string name="really_remove_account_message" product="device">Removing this account will delete all of its messages, contacts, and other data from the device!</string>
    <!-- This is shown if the autheticator for a given account fails to remove it. [CHAR LIMIT=NONE] -->
    <string name="remove_account_failed">This change isn\'t allowed by your admin</string>
    <!-- Title of dialog shown when you can't manually sync an item because it's disabled -->
    <string name="cant_sync_dialog_title">Can\u2019t manually sync</string>
    <!-- Messaage shown in dialog when you can't manually sync -->
    <string name="cant_sync_dialog_message">Sync for this item is currently disabled. To change this setting, temporarily turn on background data and automatic sync.</string>

    <!-- This is displayed to the user when the device needs to be decrypted -->
    <string name="enter_password">To start Android, enter your password</string>
    <!-- Informational text on the pin entry screen prompting the user for their pin -->
    <string name="enter_pin">To start Android, enter your PIN</string>
    <!-- Informational text on the pattern entry screen prompting the user for their pattern -->
    <string name="enter_pattern">To start Android, draw your pattern</string>

    <!-- Message shown when user enters wrong pattern -->
    <string name="cryptkeeper_wrong_pattern">Wrong Pattern</string>
    <!-- Message shown when user enters wrong password -->
    <string name="cryptkeeper_wrong_password">Wrong Password</string>
    <!-- Message shown when user enters wrong PIN -->
    <string name="cryptkeeper_wrong_pin">Wrong PIN</string>

    <!-- Shown when a password has been entered, and we're checking it -->
    <string name="checking_decryption">Checking\u2026</string>
    <!-- Shown when password is correct, and we're starting Android -->
    <string name="starting_android">Starting Android\u2026</string>


    <!-- the following are for Settings Storage screen -->
    <!-- Menu item/button 'delete' -->
    <string name="delete">Delete</string>
    <!-- Misc files [CHAR LIMIT=25] -->
    <string name="misc_files">Misc files</string>
    <!-- number of misc files selected [CHAR LIMIT=40] -->
    <string name="misc_files_selected_count">selected <xliff:g id="number" example="3">%1$d</xliff:g> out of <xliff:g id="total" example="15">%2$d</xliff:g></string>
    <!-- number of bytes represented by the selected misc files [CHAR LIMIT=40] -->
    <string name="misc_files_selected_count_bytes"><xliff:g id="number" example="3.25MB">%1$s</xliff:g> out of <xliff:g id="total" example="15.25MB">%2$s</xliff:g></string>
    <!--  action to select all [CHAR LIMIT=30] -->
    <string name="select_all">Select all</string>

    <!-- Activity title for network data usage summary. [CHAR LIMIT=25] -->
    <string name="data_usage_summary_title">Data usage</string>
    <!-- Activity title for Appk data usage summary. [CHAR LIMIT=25] -->
    <string name="data_usage_app_summary_title">App data usage</string>
    <!-- Message about carrier data accounting.  [CHAR LIMIT=100] -->
    <string name="data_usage_accounting">Carrier data accounting may differ from your device.</string>
    <!-- Title for app usage. [CHAR LIMIT=40] -->
    <string name="data_usage_app">App usage</string>
    <!-- Title for app usage. [CHAR LIMIT=40] -->
    <string name="data_usage_app_info_label">APP INFO</string>
    <!-- Title for cellular data usage. [CHAR LIMIT=40] -->
    <string name="data_usage_cellular_data">Mobile data</string>
    <!-- Title for setting data limit. [CHAR LIMIT=40] -->
    <string name="data_usage_data_limit">Set data limit</string>
    <!-- Title for option to pick visible time range from a list available usage periods. [CHAR LIMIT=25] -->
    <string name="data_usage_cycle">Data usage cycle</string>
    <!-- Title for application data usage separator in data usage list. [CHAR LIMIT=25] -->
    <string name="data_usage_app_items_header_text">App usage</string>
    <!-- Title for menu option to enable mobile data when roaming. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_roaming">Data roaming</string>
    <!-- Title for menu option to restrict background data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_restrict_background">Restrict background data</string>
    <!-- Title for menu option to allow background data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_allow_background">Allow background data</string>
    <!-- Title for menu option to show 4G mobile data usage separate from other mobile data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_split_4g">Separate 4G usage</string>
    <!-- Title for menu option to show Wi-Fi data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_show_wifi">Show Wi\u2011Fi</string>
    <!-- Title for menu option to hide Wi-Fi data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_hide_wifi">Hide Wi\u2011Fi</string>
    <!-- Title for menu option to show Ethernet data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_show_ethernet">Show Ethernet usage</string>
    <!-- Title for menu option to hide Ethernet data usage. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_hide_ethernet">Hide Ethernet usage</string>
    <!-- Title for menu option to configure metered networks. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_metered">Network restrictions</string>
    <!-- Title for menu option to enable global auto-sync of account data -->
    <string name="data_usage_menu_auto_sync">Auto-sync data</string>
    <!-- Title for menu option to show details for all SIM cards. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_sim_cards">SIM cards</string>
    <!-- Title for menu option to show details for all cellular networks. [CHAR LIMIT=26] -->
    <string name="data_usage_menu_cellular_networks">Mobile networks</string>
    <!-- Summary String for Cellular data enable toggle. [CHAR LIMIT=33] -->
    <string name="data_usage_cellular_data_summary">Paused at limit</string>

    <!--  Title for menu option to enable global auto-sync of personal account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync">Auto-sync data</string>
    <!--  Title for menu option to enable global auto-sync of personal account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync_personal">Auto-sync personal data</string>
    <!--  Title for menu option to enable global auto-sync of work account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync_work">Auto-sync work data</string>

    <!-- Title for option to change data usage cycle day. [CHAR LIMIT=32] -->
    <string name="data_usage_change_cycle">Change cycle\u2026</string>
    <!-- Body of dialog prompting user to change numerical day of month that data usage cycle should reset. [CHAR LIMIT=64] -->
    <string name="data_usage_pick_cycle_day">Day of month to reset data usage cycle:</string>
    <!-- Label shown when no applications used data during selected time period. [CHAR LIMIT=48] -->
    <string name="data_usage_empty">No apps used data during this period.</string>
    <!-- Label for data usage occuring while application in foreground. [CHAR LIMIT=48] -->
    <string name="data_usage_label_foreground">Foreground</string>
    <!-- Label for data usage occuring while application in background. [CHAR LIMIT=48] -->
    <string name="data_usage_label_background">Background</string>

    <!-- Label for application which has its data usage restricted. [CHAR LIMIT=16] -->
    <string name="data_usage_app_restricted">restricted</string>

    <!-- Body of dialog shown to request confirmation that mobile data will be disabled. [CHAR LIMIT=NONE] -->
    <string name="data_usage_disable_mobile">Turn off mobile data?</string>
    <!-- Checkbox label that will disable mobile network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_mobile_limit">Set mobile data limit</string>
    <!-- Checkbox label that will disable 4G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_4g_limit">Set 4G data limit</string>
    <!-- Checkbox label that will disable 2G-3G network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_3g_limit">Set 2G-3G data limit</string>
    <!-- Checkbox label that will disable Wi-Fi network data connection when user-defined limit is reached. [CHAR LIMIT=26] -->
    <string name="data_usage_disable_wifi_limit">Set Wi\u2011Fi data limit</string>

    <!-- Tab title for showing Wi-Fi data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_wifi">Wi\u2011Fi</string>
    <!-- Tab title for showing Ethernet data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_ethernet">Ethernet</string>
    <!-- Tab title for showing combined mobile data usage. [CHAR LIMIT=20] -->
    <string name="data_usage_tab_mobile">Mobile</string>
    <!-- Tab title for showing 4G data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_4g">4G</string>
    <!-- Tab title for showing 2G and 3G data usage. [CHAR LIMIT=10] -->
    <string name="data_usage_tab_3g">2G-3G</string>

    <!-- Title shown when current operation applies to mobile networks. [CHAR LIMIT=20] -->
    <string name="data_usage_list_mobile">Mobile</string>
    <!-- Title shown when current operation applies to no networks. [CHAR LIMIT=20] -->
    <string name="data_usage_list_none">None</string>

    <!-- Toggle switch title for enabling all mobile data network connections. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_mobile">Mobile data</string>
    <!-- Toggle switch title for enabling 2G and 3G data network connections. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_3g">2G-3G data</string>
    <!-- Toggle switch title for enabling 4G data network connection. [CHAR LIMIT=32] -->
    <string name="data_usage_enable_4g">4G data</string>
    <!-- Toggle switch title for enabling roaming on the primary data SIM card. [CHAR LIMIT=32] -->
    <string name="data_roaming_enable_mobile">Roaming</string>

    <!-- Data Usage Foreground label.  [CHAR LIMIT=40] -->
    <string name="data_usage_forground_label">Foreground:</string>
    <!-- Data Usage Background label.  [CHAR LIMIT=40] -->
    <string name="data_usage_background_label">Background:</string>
    <!-- Button title for launching application-specific data usage settings. [CHAR LIMIT=32] -->
    <string name="data_usage_app_settings">App settings</string>
    <!-- Checkbox label that restricts background data usage of a specific application. [CHAR LIMIT=40] -->
    <string name="data_usage_app_restrict_background">Background data</string>
    <!-- Summary message for checkbox that restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_app_restrict_background_summary">Enable usage of mobile data in the background</string>
    <!-- Summary message for checkbox that restricts background data usage of a specific application when no networks have been limited. [CHAR LIMIT=84] -->
    <string name="data_usage_app_restrict_background_summary_disabled">To restrict background data for this app, first set a mobile data limit.</string>
    <!-- Title of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=48] -->
    <string name="data_usage_app_restrict_dialog_title">Restrict background data?</string>
    <!-- Body of dialog shown when user restricts background data usage of a specific application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_app_restrict_dialog">This feature may cause an app that depends on background data to stop working when only mobile networks are available.\n\nYou can find more appropriate data usage controls in the settings available within the app.</string>
    <!-- Body of dialog shown when user attempts to restrict background data before a network data limit has been set. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_denied_dialog">Restricting background data is possible only when you\u2019ve set a mobile data limit.</string>
    <!--  Title of dialog shown when user enables global auto sync [CHAR LIMIT=32] -->
    <string name="data_usage_auto_sync_on_dialog_title">Turn auto-sync data on?</string>
    <!--  Body of dialog shown when user enables global auto sync, for tablet [CHAR LIMIT=none] -->
    <string name="data_usage_auto_sync_on_dialog" product="tablet">Any changes you make to your accounts on the web will be automatically copied to your tablet.\n\nSome accounts may also automatically copy any changes you make on the tablet to the web. A Google Account works this way.</string>
    <!--  Body of dialog shown when user enables global auto sync [CHAR LIMIT=none] -->
    <string name="data_usage_auto_sync_on_dialog" product="default">Any changes you make to your accounts on the web will be automatically copied to your phone.\n\nSome accounts may also automatically copy any changes you make on the phone to the web. A Google Account works this way.</string>
    <!--  Title of dialog shown when user disables global auto sync [CHAR LIMIT=32] -->
    <string name="data_usage_auto_sync_off_dialog_title">Turn auto-sync data off?</string>
    <!--  Body of dialog shown when user disables global auto sync [CHAR LIMIT=none] -->
    <string name="data_usage_auto_sync_off_dialog">This will conserve data and battery usage, but you\u2019ll need to sync each account manually to collect recent information. And you won\u2019t receive notifications when updates occur.</string>

    <!-- Title of dialog for editing data usage cycle reset date. [CHAR LIMIT=48] -->
    <string name="data_usage_cycle_editor_title">Usage cycle reset date</string>
    <!-- Subtitle of dialog for editing data usage cycle reset date. [CHAR LIMIT=32] -->
    <string name="data_usage_cycle_editor_subtitle">Date of each month:</string>
    <!-- Positive button title for data usage cycle editor, confirming that changes should be saved. [CHAR LIMIT=32] -->
    <string name="data_usage_cycle_editor_positive">Set</string>

    <!-- Title of dialog for editing data usage warning in bytes. [CHAR LIMIT=48] -->
    <string name="data_usage_warning_editor_title">Set data usage warning</string>
    <!-- Title of dialog for editing data usage limit in bytes. [CHAR LIMIT=48] -->
    <string name="data_usage_limit_editor_title">Set data usage limit</string>

    <!-- Title of dialog shown before user limits data usage. [CHAR LIMIT=48] -->
    <string name="data_usage_limit_dialog_title">Limiting data usage</string>
    <!-- Body of dialog shown before user limits mobile data usage. [CHAR LIMIT=NONE] -->
    <string name="data_usage_limit_dialog_mobile" product="tablet">Your tablet will turn off mobile data once it reaches the limit you set.\n\nSince data usage is measured by your tablet, and your carrier may account for usage differently, consider setting a conservative limit.</string>
    <!-- Body of dialog shown before user limits mobile data usage. [CHAR LIMIT=NONE] -->
    <string name="data_usage_limit_dialog_mobile" product="default">Your phone will turn off mobile data once it reaches the limit you set.\n\nSince data usage is measured by your phone, and your carrier may account for usage differently, consider setting a conservative limit.</string>

    <!-- Title of dialog shown before user restricts background data usage. [CHAR LIMIT=48] -->
    <string name="data_usage_restrict_background_title">Restrict background data?</string>
    <!-- Body of dialog shown before user restricts background data usage. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background">If you restrict background mobile data, some apps and services won\u2019t work unless you\u2019re connected to Wi\u2011Fi.</string>
    <!-- Body of dialog shown before user restricts background data usage. This is for multiuser tablets. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background_multiuser" product="tablet">If you restrict background mobile data, some apps and services won\u2019t work unless you\u2019re connected to Wi\u2011Fi.\n\nThis setting affects all users on this tablet.</string>
    <!-- Body of dialog shown before user restricts background data usage. This is for multiuser phones. [CHAR LIMIT=NONE] -->
    <string name="data_usage_restrict_background_multiuser" product="default">If you restrict background mobile data, some apps and services won\u2019t work unless you\u2019re connected to Wi\u2011Fi.\n\nThis setting affects all users on this phone.</string>

    <!-- Label displaying current network data usage warning threshold. [CHAR LIMIT=18] -->
    <string name="data_usage_sweep_warning"><font size="18"><xliff:g id="number" example="128">^1</xliff:g></font> <font size="9"><xliff:g id="unit" example="KB">^2</xliff:g></font>\n<font size="12">warning</font></string>
    <!-- Label displaying current network data usage limit threshold. [CHAR LIMIT=18] -->
    <string name="data_usage_sweep_limit"><font size="18"><xliff:g id="number" example="128">^1</xliff:g></font> <font size="9"><xliff:g id="unit" example="KB">^2</xliff:g></font>\n<font size="12">limit</font></string>

    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title of data usage item that represents all uninstalled applications. [CHAR LIMIT=48] -->
    <string name="data_usage_uninstalled_apps">Removed apps</string>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title of data usage item that represents all uninstalled applications or removed users. [CHAR LIMIT=48] -->
    <string name="data_usage_uninstalled_apps_users">Removed apps and users</string>
    <!-- Combination of total network bytes sent and received by an application. [CHAR LIMIT=NONE] -->
    <string name="data_usage_received_sent"><xliff:g id="received" example="128KB">%1$s</xliff:g> received, <xliff:g id="sent" example="1.3GB">%2$s</xliff:g> sent</string>
    <!-- Label displaying total network data transferred during a specific time period. [CHAR LIMIT=64] -->
    <string name="data_usage_total_during_range"><xliff:g id="range" example="Jul 1 - Jul 31">%2$s</xliff:g>: about <xliff:g id="total" example="128KB">%1$s</xliff:g> used.</string>

    <!-- Label displaying total network data transferred during a specific time period, including a disclaimer that contrasts device versus carrier reporting. [CHAR LIMIT=80] -->
    <string name="data_usage_total_during_range_mobile" product="tablet"><xliff:g id="range" example="Jul 1 - Jul 31">%2$s</xliff:g>: about <xliff:g id="total" example="128KB">%1$s</xliff:g> used, as measured by your tablet. Your carrier\u2019s data usage accounting may differ.</string>
    <!-- Label displaying total network data transferred during a specific time period, including a disclaimer that contrasts device versus carrier reporting. [CHAR LIMIT=80] -->
    <string name="data_usage_total_during_range_mobile" product="default"><xliff:g id="range" example="Jul 1 - Jul 31">%2$s</xliff:g>: about <xliff:g id="total" example="128KB">%1$s</xliff:g> used, as measured by your phone. Your carrier\u2019s data usage accounting may differ.</string>

    <!-- Dialog title for selecting metered networks. [CHAR LIMIT=25] -->
    <string name="data_usage_metered_title">Network restrictions</string>
    <!-- Dialog body for selecting paid networks. [CHAR LIMIT=NONE] -->
    <string name="data_usage_metered_body">Metered networks are treated like mobile networks when background data is restricted. Apps may warn before using these networks for large downloads.</string>
    <!-- Header for list of mobile networks. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_mobile">Mobile networks</string>
    <!-- Header for list of Wi-Fi networks. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_wifi">Metered Wi\u2011Fi networks</string>
    <!-- Body text prompting user to enable Wi-Fi to configure metered networks. [CHAR LIMIT=64] -->
    <string name="data_usage_metered_wifi_disabled">To select metered networks, turn Wi\u2011Fi on.</string>

    <!-- Option for indicating that a network being metered (expensive) should be determined automatically. [CHAR LIMIT=32] -->
    <string name="data_usage_metered_auto">Automatic</string>
    <!-- Option for indicating that a network is metered (expensive). [CHAR LIMIT=32] -->
    <string name="data_usage_metered_yes">Metered</string>
    <!-- Option for indicating that a network is not metered (inexpensive). [CHAR LIMIT=32] -->
    <string name="data_usage_metered_no">Not metered</string>

    <!-- Disclaimer string for data usage measured by device. [CHAR LIMIT=80] -->
    <string name="data_usage_disclaimer">Carrier data accounting may differ from your device.</string>

    <!-- Button at the bottom of the CryptKeeper screen to make an emergency call. -->
    <string name="cryptkeeper_emergency_call">Emergency call</string>
    <!-- Button at the bottom of the CryptKeeper screen that lets the user return to a call -->
    <string name="cryptkeeper_return_to_call">Return to call</string>

    <!-- Input label for the name of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_name">Name</string>
    <!-- Input label for the type of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_type">Type</string>
    <!-- Input label for the server address of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_server">Server address</string>
    <!-- Checkbox label to enable PPP encryption for a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_mppe">PPP encryption (MPPE)</string>
    <!-- Input label for the L2TP secret of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_l2tp_secret">L2TP secret</string>
    <!-- Input label for the IPSec identifier of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_identifier">IPSec identifier</string>
    <!-- Input label for the IPSec pre-shared key of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_secret">IPSec pre-shared key</string>
    <!-- Selection label for the IPSec user certificate of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_user_cert">IPSec user certificate</string>
    <!-- Selection label for the IPSec CA certificate of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_ca_cert">IPSec CA certificate</string>
    <!-- Selection label for the IPSec server certificate of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_ipsec_server_cert">IPSec server certificate</string>
    <!-- Checkbox label to show advanced options of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_show_options">Show advanced options</string>
    <!-- Input label for the DNS search domains of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_search_domains">DNS search domains</string>
    <!-- Input label for the DNS servers of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_dns_servers">DNS servers (e.g. 8.8.8.8)</string>
    <!-- Input label for the forwarding routes of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_routes">Forwarding routes (e.g. 10.0.0.0/8)</string>
    <!-- Input label for the username of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_username">Username</string>
    <!-- Input label for the password of a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_password">Password</string>
    <!-- Checkbox label to save the username and the password in a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_save_login">Save account information</string>
    <!-- Hint for not using an optional feature in a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_not_used">(not used)</string>
    <!-- Option to not use a CA certificate to verify the VPN server. [CHAR LIMIT=40] -->
    <string name="vpn_no_ca_cert">(don\u2019t verify server)</string>
    <!-- Option to use the server certificate received from the VPN server. [CHAR LIMIT=40] -->
    <string name="vpn_no_server_cert">(received from server)</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        the selected VPN type doesn't support always-on. [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_type">This VPN type can\'t stay connected at all
        times</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        the server address is not in numeric form (e.g. 8.8.8.8). [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_server">Always-on VPN only supports numeric server
        addresses</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        no DNS is found. [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_no_dns">A DNS server must be specified for always-on
        VPN</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        DNS server addresses are not in numeric form (e.g. 8.8.8.8). [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_dns">DNS server addresses must be numeric for
        always-on VPN</string>
    <!-- Error message displayed below the always-on VPN checkbox when the checkbox is disabled:
        generic error. [CHAR LIMIT=120] -->
    <string name="vpn_always_on_invalid_reason_other">The information entered doesn\'t support
        always-on VPN</string>

    <!-- Button label to cancel changing a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_cancel">Cancel</string>
    <!-- Button label to finish editing a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_done">Dismiss</string>
    <!-- Button label to save a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_save">Save</string>
    <!-- Button label to connect to a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_connect">Connect</string>
    <!-- Button label to connect a VPN profile, replacing the current one. [CHAR LIMIT=40] -->
    <string name="vpn_replace">Replace</string>
    <!-- Dialog title to edit a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_edit">Edit VPN profile</string>
    <!-- Button label to forget a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_forget">Forget</string>
    <!-- Dialog title to connect to a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_connect_to">Connect to <xliff:g id="profile" example="School">%s</xliff:g></string>
    <!-- Dialog message body to disconnect from a VPN profile. -->
    <string name="vpn_disconnect_confirm">Disconnect this VPN?</string>
    <!-- Button label to disconnect from a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_disconnect">Disconnect</string>
    <!-- Field label to show the version number for a VPN app. [CHAR LIMIT=40] -->
    <string name="vpn_version">Version <xliff:g id="version" example="3.3.0">%s</xliff:g></string>
    <!-- Button label to forget a VPN profile [CHAR LIMIT=40] -->
    <string name="vpn_forget_long">Forget VPN</string>
    <!-- Dialog message title to set another VPN app to be always-on [CHAR LIMIT=40] -->
    <string name="vpn_replace_vpn_title">Replace existing VPN?</string>
    <!-- Dialog message title to set always-on VPN when another app was not already set. -->
    <string name="vpn_set_vpn_title">Set always-on VPN?</string>
    <!-- Dialog message body to explain that always-on VPN will disable network traffic while the VPN is connecting. -->
    <string name="vpn_first_always_on_vpn_message">When this setting is on, you won\'t have an internet connection until the VPN successfully connects</string>
    <!-- Dialog message body to explain that always-on VPN will disable network traffic while the VPN is connecting, and that this will replace the current VPN. -->
    <string name="vpn_replace_always_on_vpn_enable_message">Your existing VPN will be replaced, and you won\'t have an internet connection until the VPN successfully connects</string>
    <!-- Dialog message body to connect a VPN app, replacing another VPN app that is already always-on [CHAR LIMIT=NONE] -->
    <string name="vpn_replace_always_on_vpn_disable_message">You\'re already connected to an always-on VPN. If you connect to a different one, your existing VPN will be replaced, and always-on mode will turn off.</string>
    <!-- Dialog message body to set another VPN app to be always-on [CHAR LIMIT=NONE] -->
    <string name="vpn_replace_vpn_message">You\'re already connected to a VPN. If you connect to a different one, your existing VPN will be replaced.</string>
    <!-- Dialog action button to turn on a VPN. -->
    <string name="vpn_turn_on">Turn on</string>
    <!-- Dialog mesage title when the user can't connect an always-on vpn [CHAR LIMIT=NONE] -->
    <string name="vpn_cant_connect_title"><xliff:g id="vpn_name" example="OpenVPN">%1$s</xliff:g> can\'t connect</string>
    <!-- Dialog message subtitle when the user can't connect an always-on vpn [CHAR LIMIT=NONE] -->
    <string name="vpn_cant_connect_message">This app doesn\'t support always-on VPN</string>
    <!-- Preference title for VPN settings. [CHAR LIMIT=40] -->
    <string name="vpn_title">VPN</string>
    <!-- Preference title to create a new VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_create">Add VPN profile</string>
    <!-- Menu item to edit a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_menu_edit">Edit profile</string>
    <!-- Menu item to delete a VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_menu_delete">Delete profile</string>
    <!-- Menu item to select always-on VPN profile. [CHAR LIMIT=40] -->
    <string name="vpn_menu_lockdown">Always-on VPN</string>
    <!-- Placeholder when VPN settings is open but no VPNs have been created. [CHAR LIMIT=100] -->
    <string name="vpn_no_vpns_added">No VPNs added</string>
    <!-- Preference summary for always-on VPN checkbox. [CHAR LIMIT=40] -->
    <string name="vpn_always_on_summary">Stay connected to VPN at all times</string>
    <!-- Preference summary for app not supporting always-on VPN [CHAR LIMIT=40] -->
    <string name="vpn_always_on_summary_not_supported">Not supported by this app</string>
    <!-- Preference summary for a VPN app that is set to be always-on. [CHAR LIMIT=40]  -->
    <string name="vpn_always_on_summary_active">Always-on active</string>
    <!-- Preference title for the toggle that controls whether to force all network connections to
        go through VPN. [CHAR LIMIT=40] -->
    <string name="vpn_require_connection">Block connections without VPN</string>
    <!-- Dialog message title to confirm forcing all network connections to go through VPN.
        [CHAR LIMIT=40] -->
    <string name="vpn_require_connection_title">Require VPN connection?</string>

    <!-- Summary describing the always-on VPN feature. [CHAR LIMIT=NONE] -->
    <string name="vpn_lockdown_summary">Select a VPN profile to always remain connected to. Network traffic will only be allowed when connected to this VPN.</string>
    <!-- List item indicating that no always-on VPN is selected. [CHAR LIMIT=64] -->
    <string name="vpn_lockdown_none">None</string>
    <!-- Error indicating that the selected VPN doesn't meet requirements. [CHAR LIMIT=NONE] -->
    <string name="vpn_lockdown_config_error">Always-on VPN requires an IP address for both server and DNS.</string>

    <!-- Toast message when there is no network connection to start VPN. [CHAR LIMIT=100] -->
    <string name="vpn_no_network">There is no network connection. Please try again later.</string>
    <!-- Toast message when VPN has disconnected automatically due to Clear credentials. [CHAR LIMIT=NONE] -->
    <string name="vpn_disconnected">Disconnected from VPN</string>
    <!-- Seting subtext indicating the device is not currently connected to any VPN [CHAR LIMIT=40]-->
    <string name="vpn_disconnected_summary">None</string>
    <!-- Toast message when a certificate is missing. [CHAR LIMIT=100] -->
    <string name="vpn_missing_cert">A certificate is missing. Try editing the profile.</string>

    <!-- Tab label for built-in system CA certificates. -->
    <string name="trusted_credentials_system_tab">System</string>
    <!-- Tab label for user added CA certificates. -->
    <string name="trusted_credentials_user_tab">User</string>
    <!-- Button label for disabling a system CA certificate. -->
    <string name="trusted_credentials_disable_label">Disable</string>
    <!-- Button label for enabling a system CA certificate. -->
    <string name="trusted_credentials_enable_label">Enable</string>
    <!-- Button label for removing a user CA certificate. -->
    <string name="trusted_credentials_remove_label">Remove</string>
    <!-- Button label for trusting a user CA certificate. -->
    <string name="trusted_credentials_trust_label">Trust</string>
    <!-- Alert dialog confirmation when enabling a system CA certificate. -->
    <string name="trusted_credentials_enable_confirmation">Enable the system CA certificate?</string>
    <!-- Alert dialog confirmation when disabling a system CA certificate. -->
    <string name="trusted_credentials_disable_confirmation">Disable the system CA certificate?</string>
    <!-- Alert dialog confirmation when removing a user CA certificate. -->
    <string name="trusted_credentials_remove_confirmation">Permanently remove the user CA certificate?</string>

    <!-- Header for a list of items that a credential entry contains. For example, one private key and one certificate. [CHAR LIMIT=NONE] -->
    <string name="credential_contains">This entry contains:</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_userkey">one user key</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_usercrt">one user certificate</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_cacrt">one CA certificate</string>
    <!-- Item found in thee PKCS12 keystore being investigated [CHAR LIMIT=NONE]-->
    <string name="n_cacrts">%d CA certificates</string>
    <!-- Alert dialog when viewing a set of user credentials. -->
    <string name="user_credential_title">Credential details</string>
    <!-- Announcement to confirm a user credential being removed. [CHAR LIMIT=NONE] -->
    <string name="user_credential_removed">Removed credential: <xliff:g id="credential_name" example="signing key">%s</xliff:g></string>
    <!-- Placeholder for the list of installed user credentials (private keys) when the list is empty. [CHAR LIMIT=120] -->
    <string name="user_credential_none_installed">No user credentials installed</string>

    <!--  Title for spell checker settings -->
    <string name="spellcheckers_settings_title">Spell checker</string>

    <!-- Prompt for the user to enter their current full-backup password -->
    <string name="current_backup_pw_prompt">Type your current full backup password here</string>
    <!-- Prompt for the user to enter a new full-backup password -->
    <string name="new_backup_pw_prompt">Type a new password for full backups here</string>
    <!-- Prompt for the user to confirm the new full-backup password by re-entering it -->
    <string name="confirm_new_backup_pw_prompt">Retype your new full backup password here</string>

    <!-- Button label for setting the user's new full-backup password -->
    <string name="backup_pw_set_button_text">Set backup password</string>
    <!-- Button label for cancelling the new-password operation and retaining the user's previous full-backup password -->
    <string name="backup_pw_cancel_button_text">Cancel</string>

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

    <!-- Notification of installed CA Certs --> <skip/>

    <!-- Shows up when there is a user SSL CA Cert installed on the
         device.  Indicates to the user that SSL traffic can be intercepted.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_warning">Network may be monitored</string>
    <!-- Button to close the SSL CA cert warning dialog box, meaning the user is done reading.  [CHAR LIMIT=NONE] -->
    <string name="done_button">Done</string>
    <!-- Title of Dialog warning users of SSL monitoring. [CHAR LIMIT=NONE] -->
    <plurals name="ssl_ca_cert_dialog_title">
        <item quantity="one">Trust or remove certificate</item>
        <item quantity="other">Trust or remove certificates</item>
    </plurals>
    <!-- Text of message to show to device owner user whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <plurals name="ssl_ca_cert_info_message_device_owner">
        <item quantity="one"><xliff:g id="managing_domain">%s</xliff:g> has installed a certificate authority on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin.</item>
        <item quantity="other"><xliff:g id="managing_domain">%s</xliff:g> has installed certificate authorities on your device, which may allow them to monitor your device network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin.</item>
    </plurals>
    <!-- Text of message to show to work profile users whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <plurals name="ssl_ca_cert_info_message">
        <item quantity="one"><xliff:g id="managing_domain">%s</xliff:g> has installed a certificate authority for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about this certificate, contact your admin.</item>
        <item quantity="other"><xliff:g id="managing_domain">%s</xliff:g> has installed certificate authorities for your work profile, which may allow them to monitor work network activity, including emails, apps, and secure websites.\n\nFor more information about these certificates, contact your admin.</item>
    </plurals>
    <!-- Text of warning to show to users that have a SSL CA Cert installed.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_warning_message">A third party is capable of monitoring your network activity, including emails, apps, and secure websites.\n\nA trusted credential installed on your device is making this possible.</string>
    <!-- Label on button that will take the user to the Trusted Credentials settings page.  [CHAR LIMIT=NONE]-->
    <plurals name="ssl_ca_cert_settings_button">
        <item quantity="one">Check certificate</item>
        <item quantity="other">Check certificates</item>
    </plurals>

    <!-- User settings -->
    <skip/>

    <!-- User settings screen title [CHAR LIMIT=40] -->
    <string name="user_settings_title">Multiple users</string>
    <!-- User settings header for list of users and profiles [CHAR LIMIT=40] -->
    <string name="user_list_title">Users &amp; profiles</string>
    <!-- User settings add user or restricted profile menu [CHAR LIMIT=35] -->
    <string name="user_add_user_or_profile_menu">Add user or profile</string>
    <!-- User settings add user menu [CHAR LIMIT=35] -->
    <string name="user_add_user_menu">Add user</string>
    <!-- User settings summary for a restricted profile [CHAR LIMIT=50] -->
    <string name="user_summary_restricted_profile">Restricted profile</string>
    <!-- User settings warning that restricted profile needs a screen lock [CHAR LIMIT=NONE] -->
    <string name="user_need_lock_message">Before you can create a restricted profile, you\u2019ll need to set up a screen lock to protect your apps and personal data.</string>
    <!-- User settings dialog button to set screen lock [CHAR LIMIT=25] -->
    <string name="user_set_lock_button">Set lock</string>
    <!-- User summary to indicate that user is currently not set up [CHAR LIMIT=100] -->
    <string name="user_summary_not_set_up">Not set up</string>
    <!-- User summary to indicate that restricted profile is currently not set up [CHAR LIMIT=100] -->
    <string name="user_summary_restricted_not_set_up">Not set up - Restricted profile</string>
    <!-- User summary to indicate that a work profile is currently not set up [CHAR LIMIT=100] -->
    <string name="user_summary_managed_profile_not_set_up">Not set up - Work profile</string>
    <!-- User information string to represent the owner of the device [CHAR LIMIT=25] -->
    <string name="user_admin">Admin</string>
    <!-- User settings title for current user entry "You" user. [CHAR LIMIT=30] -->
    <string name="user_you">You (<xliff:g id="name" example="Name">%s</xliff:g>)</string>
    <!-- Title for the preference to enter the nickname of the userto display in the user switcher [CHAR LIMIT=25]-->
    <string name="user_nickname">Nickname</string>
    <!-- Title for add user type dialog [CHAR LIMIT=45] -->
    <string name="user_add_user_type_title">Add</string>
    <!-- Summary for add user action, when it's disabled [CHAR LIMIT=100] -->
    <string name="user_add_max_count">You can add up to <xliff:g id="user_count">%1$d</xliff:g> users</string>
    <!-- Summary for add user entry in the choice dialog [CHAR LIMIT=none] -->
    <string name="user_add_user_item_summary">Users have their own apps and content</string>
    <!-- Summary for add restricted profile entry in the choice dialog [CHAR LIMIT=none] -->
    <string name="user_add_profile_item_summary">You can restrict access to apps and content from your account</string>
    <!-- Button text for adding a regular user [CHAR LIMIT=25] -->
    <string name="user_add_user_item_title">User</string>
    <!-- Button text for adding a restricted profile [CHAR LIMIT=25] -->
    <string name="user_add_profile_item_title">Restricted profile</string>
    <!-- Title for add user confirmation dialog [CHAR LIMIT=30] -->
    <string name="user_add_user_title">Add new user?</string>
    <!-- Message for add user confirmation dialog - long version. [CHAR LIMIT=none] -->
    <string name="user_add_user_message_long">You can share this device with other people by creating additional users. Each user has their own space, which they can customize with apps, wallpaper, and so on. Users can also adjust device settings like Wi\u2011Fi that affect everyone.\n\nWhen you add a new user, that person needs to set up their space.\n\nAny user can update apps for all other users. Accessibility settings and services may not transfer to the new user.</string>
    <!-- Message for add user confirmation dialog - short version. [CHAR LIMIT=none] -->
    <string name="user_add_user_message_short">When you add a new user, that person needs to set up their space.\n\nAny user can update apps for all other users. </string>
    <!-- Title of dialog to setup a new user [CHAR LIMIT=30] -->
    <string name="user_setup_dialog_title">Set up user now?</string>
    <!-- Message in dialog to setup a new user after creation [CHAR LIMIT=none] -->
    <string name="user_setup_dialog_message">Make sure the person is available to take the device and set up their space</string>
    <!-- Message in dialog to setup a new restricted profile after creation [CHAR LIMIT=none] -->
    <string name="user_setup_profile_dialog_message">Set up profile now?</string>
    <!-- Button text to setup the new user now [CHAR LIMIT=25] -->
    <string name="user_setup_button_setup_now">Set up now</string>
    <!-- Button text to setup the new user later [CHAR LIMIT=25] -->
    <string name="user_setup_button_setup_later">Not now</string>
    <!-- Message to secondary users that only owner can manage users [CHAR LIMIT=none] -->
    <string name="user_cannot_manage_message" product="tablet">Only the tablet\u2019s owner can manage users.</string>
    <!-- Message to secondary users that only owner can manage users [CHAR LIMIT=none] -->
    <string name="user_cannot_manage_message" product="default">Only the phone\u2019s owner can manage users.</string>
    <!-- Message to limited users that they cannot add accounts [CHAR LIMIT=100] -->
    <string name="user_cannot_add_accounts_message">Restricted profiles cannot add accounts</string>

    <!-- User details remove user menu [CHAR LIMIT=20] -->
    <string name="user_remove_user_menu">Delete <xliff:g id="user_name">%1$s</xliff:g> from this device</string>
    <!-- User lock screen settings header[CHAR LIMIT=40] -->
    <string name="user_lockscreen_settings">Lock screen settings</string>
    <!-- User settings item to allow creating new users from locks screen [CHAR LIMIT=50] -->
    <string name="user_add_on_lockscreen_menu">Add users from lock screen</string>
    <!-- User details new user name [CHAR LIMIT=30] -->
    <string name="user_new_user_name">New user</string>
    <!-- User details new restricted profile name [CHAR LIMIT=30] -->
    <string name="user_new_profile_name">New profile</string>
    <!-- User (self) removal confirmation title [CHAR LIMIT=30] -->
    <string name="user_confirm_remove_self_title">Delete yourself?</string>
    <!-- User removal confirmation title [CHAR LIMIT=25] -->
    <string name="user_confirm_remove_title">Remove this user?</string>
    <!-- Profile removal confirmation title [CHAR LIMIT=25] -->
    <string name="user_profile_confirm_remove_title">Remove this profile?</string>
    <!-- Work profile removal confirmation title [CHAR LIMIT=25] -->
    <string name="work_profile_confirm_remove_title">Remove work profile?</string>
    <!-- User (self) removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_self_message" product="tablet">You will lose your space and data on this tablet. You can\u2019t undo this action.</string>
    <!-- User (self) removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_self_message" product="default">You will lose your space and data on this phone. You can\u2019t undo this action.</string>
    <!-- User removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_confirm_remove_message">All apps and data will be deleted.</string>
    <!-- Work profile removal confirmation message [CHAR LIMIT=none] -->
    <string name="work_profile_confirm_remove_message">All apps and data in this profile will be deleted if you continue.</string>
    <!-- User profile removal confirmation message [CHAR LIMIT=none] -->
    <string name="user_profile_confirm_remove_message">All apps and data will be deleted.</string>
    <!-- Setting label to show that a new user is being added [CHAR LIMIT=30] -->
    <string name="user_adding_new_user">Adding new user\u2026</string>
    <!-- Spoken content description for delete icon beside a user [CHAR LIMIT=none] -->
    <string name="user_delete_user_description">Delete user</string>
    <!-- Delete button text [CHAR LIMIT=25] -->
    <string name="user_delete_button">Delete</string>
    <!-- TODO: Remove it once the same entry in SettingsLib is translated. -->
    <!-- Title for Guest user [CHAR LIMIT=35] -->
    <string name="user_guest">Guest</string>
    <!-- Label for item to exit guest mode [CHAR LIMIT=35] -->
    <string name="user_exit_guest_title">Remove guest</string>
    <!-- Title of dialog to user to confirm exiting guest. [CHAR LIMIT=50] -->
    <string name="user_exit_guest_confirm_title">Remove guest?</string>
    <!-- Message to user to confirm exiting guest. [CHAR LIMIT=none] -->
    <string name="user_exit_guest_confirm_message">All apps and data in this session will be deleted.</string>
    <!-- Label for button in confirmation dialog when exiting guest session [CHAR LIMIT=35] -->
    <string name="user_exit_guest_dialog_remove">Remove</string>

    <!-- Title of preference to enable calling[CHAR LIMIT=40] -->
    <string name="user_enable_calling">Turn on phone calls</string>
    <!-- Title of preference to enable calling and SMS [CHAR LIMIT=45] -->
    <string name="user_enable_calling_sms">Turn on phone calls &amp; SMS</string>
    <!-- Title of preference to remove the user [CHAR LIMIT=35] -->
    <string name="user_remove_user">Remove user</string>
    <!-- Title for confirmation of turning on calls [CHAR LIMIT=40] -->
    <string name="user_enable_calling_confirm_title">Turn on phone calls?</string>
    <!-- Message for confirmation of turning on calls [CHAR LIMIT=none] -->
    <string name="user_enable_calling_confirm_message">Call history will be shared with this user.</string>
    <!-- Title for confirmation of turning on calls and SMS [CHAR LIMIT=45] -->
    <string name="user_enable_calling_and_sms_confirm_title">Turn on phone calls &amp; SMS?</string>
    <!-- Message for confirmation of turning on calls and SMS [CHAR LIMIT=none] -->
    <string name="user_enable_calling_and_sms_confirm_message">Call and SMS history will be shared with this user.</string>
    <!-- Title for the emergency info preference [CHAR LIMIT=40] -->
    <string name="emergency_info_title">Emergency information</string>
    <!-- Summary for the emergency info preference [CHAR LIMIT=40] -->
    <string name="emergency_info_summary">Info &amp; contacts for <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>

    <!-- Application Restrictions screen title [CHAR LIMIT=45] -->
    <string name="application_restrictions">Allow apps and content</string>
    <!-- Applications with restrictions header [CHAR LIMIT=45] -->
    <string name="apps_with_restrictions_header">Applications with restrictions</string>
    <!-- Applicaitons with restrictions - settings button [CHAR LIMIT=30] -->
    <string name="apps_with_restrictions_settings_button">Expand settings for application</string>

    <!-- NFC payment settings --><skip/>
    <string name="nfc_payment_settings_title">Tap &amp; pay</string>
    <!-- Caption for button linking to a page explaining how Tap and Pay works-->
    <string name="nfc_payment_how_it_works">How it works</string>
    <!-- String shown when there are no NFC payment applications installed -->
    <string name="nfc_payment_no_apps">Pay with your phone in stores</string>
    <!-- Header text that can be clicked on to change the default payment app -->
    <string name="nfc_payment_default">Payment default</string>
    <!-- Summary text that is shown when no default app is set -->
    <string name="nfc_payment_default_not_set">Not set</string>
    <!-- String indicating the label of the default payment app and a description of its state; eg Google Wallet - MasterCard 1234 -->
    <string name="nfc_payment_app_and_desc"><xliff:g id="app">%1$s</xliff:g> - <xliff:g id="description">%2$s</xliff:g></string>
    <!-- Header for what to do when the open app supports TapPay: use the default set app, or the open app -->
    <string name="nfc_payment_use_default">Use default</string>
    <!-- Always use the default app (independent of what app is open) -->
    <string name="nfc_payment_favor_default">Always</string>
    <!-- If open app supports TapPay, use that app instead of the default -->
    <string name="nfc_payment_favor_open">Except when another payment app is open</string>
    <!-- Header for a dialog asking the user which payment app to use -->
    <string name="nfc_payment_pay_with">At a Tap &amp; pay terminal, pay with:</string>
    <!-- Header for text explaning how to pay at a payment terminal in a store -->
    <string name="nfc_how_it_works_title">Paying at the terminal</string>
    <!-- Content for text explaning how to pay at a payment terminal in a store -->
    <string name="nfc_how_it_works_content">Set up a payment app. Then just hold the back of your phone up to any terminal with the contactless symbol.</string>
    <!-- Button the user can click to indicate he understood and dismiss the screen -->
    <string name="nfc_how_it_works_got_it">Got it</string>
    <!-- NFC More... title.  [CHAR LIMIT=40] -->
    <string name="nfc_more_title">More...</string>
    <!-- Label for the dialog that is shown when the user is asked to set a
         preferred payment application -->
    <string name="nfc_payment_set_default_label">Set as your preference?</string>
    <string name="nfc_payment_set_default">Always use <xliff:g id="app">%1$s</xliff:g> when you Tap &amp; pay?</string>
    <string name="nfc_payment_set_default_instead_of">Always use <xliff:g id="app">%1$s</xliff:g> instead of <xliff:g id="app">%2$s</xliff:g> when you Tap &amp; pay?</string>
    <!-- Restrictions settings --><skip/>

    <!-- Restriction settings title [CHAR LIMIT=35] -->
    <string name="restriction_settings_title">Restrictions</string>
    <!-- Restrictions screen - reset menu to reset to unrestricted [CHAR LIMIT=25] -->
    <string name="restriction_menu_reset">Remove restrictions</string>
    <!-- Restrictions screen - menu label to change restrictions pin [CHAR LIMIT=25] -->
    <string name="restriction_menu_change_pin">Change PIN</string>

    <!-- Label for are-notifications-enabled checkbox in app details [CHAR LIMIT=20] -->
    <string name="app_notifications_switch_label">Show notifications</string>

    <!--  Help URLs for some screens. Not specified here. Specified in product overlays --><skip/>
    <!-- Help menu label [CHAR LIMIT=20] -->
    <string name="help_label">Help &amp; feedback</string>

    <!-- Summary text for support setting tile [CHAR LIMIT=None] -->
    <string name="support_summary">Help articles, phone &amp; chat, getting started</string>

    <!-- Help URI, Default [DO NOT TRANSLATE] -->
    <string name="help_uri_default" translatable="false"></string>
    <!-- Help URI, Android beam [DO NOT TRANSLATE] -->
    <string name="help_uri_beam" translatable="false"></string>
    <!-- Help URI, Display [DO NOT TRANSLATE] -->
    <string name="help_uri_display" translatable="false"></string>
    <!-- Help URI, Wallpaper [DO NOT TRANSLATE] -->
    <string name="help_uri_wallpaper" translatable="false"></string>
    <!-- Help URI, Interruptions [DO NOT TRANSLATE] -->
    <string name="help_uri_interruptions" translatable="false"></string>
    <!-- Help URI, Other sounds [DO NOT TRANSLATE] -->
    <string name="help_uri_other_sounds" translatable="false"></string>
    <!-- Help URI, Notifications [DO NOT TRANSLATE] -->
    <string name="help_uri_notifications" translatable="false"></string>
    <!-- Help URI, Apps [DO NOT TRANSLATE] -->
    <string name="help_uri_apps" translatable="false"></string>
    <!-- Help URI, Storage [DO NOT TRANSLATE] -->
    <string name="help_uri_storage" translatable="false"></string>
    <!-- Help URI, Accessibility [DO NOT TRANSLATE] -->
    <string name="help_uri_accessibility" translatable="false"></string>
    <!-- Help URI, Printing [DO NOT TRANSLATE] -->
    <string name="help_uri_printing" translatable="false"></string>
    <!-- Help URI, About phone [DO NOT TRANSLATE] -->
    <string name="help_uri_about" translatable="false"></string>

    <!-- Help URL, WiFi [DO NOT TRANSLATE] -->
    <string name="help_url_wifi" translatable="false"></string>
    <!-- Help URL, WiFi Direct [DO NOT TRANSLATE] -->
    <string name="help_url_wifi_p2p" translatable="false"></string>
    <!-- Help URL, Bluetooth [DO NOT TRANSLATE] -->
    <string name="help_url_bluetooth" translatable="false"></string>
    <!-- Help URL, Data usage [DO NOT TRANSLATE] -->
    <string name="help_url_data_usage" translatable="false"></string>
    <!-- Help URL, Data Saver [DO NOT TRANSLATE] -->
    <string name="help_url_data_saver" translatable="false"></string>
    <!-- Help URL, Unrestricted data access [DO NOT TRANSLATE] -->
    <string name="help_url_unrestricted_data_access" translatable="false"></string>
    <!-- Help URL, More [DO NOT TRANSLATE] -->
    <string name="help_url_more_networks" translatable="false"></string>
    <!-- Help URL, Vpn [DO NOT TRANSLATE] -->
    <string name="help_url_vpn" translatable="false"></string>
    <!-- Help URL, Sound [DO NOT TRANSLATE] -->
    <string name="help_url_sound" translatable="false"></string>
    <!-- Help URL, Battery [DO NOT TRANSLATE] -->
    <string name="help_url_battery" translatable="false"></string>
    <!-- Help URL, Accounts [DO NOT TRANSLATE] -->
    <string name="help_url_accounts" translatable="false"></string>
    <!-- Help URL, Choose lockscreen [DO NOT TRANSLATE] -->
    <string name="help_url_choose_lockscreen" translatable="false"></string>
    <!-- Help URL, Backup & reset [DO NOT TRANSLATE] -->
    <string name="help_url_backup_reset" translatable="false"></string>
    <!-- Help URL, Tethering [DO NOT TRANSLATE] -->
    <string name="help_url_tether" translatable="false"></string>
    <!-- Help URL, Dreams [DO NOT TRANSLATE] -->
    <string name="help_url_dreams" translatable="false"></string>
    <!-- Help URL, User settings [DO NOT TRANSLATE] -->
    <string name="help_url_users" translatable="false"></string>
    <!-- Help URL, Location access [DO NOT TRANSLATE] -->
    <string name="help_url_location_access" translatable="false"></string>
    <!-- Help URL, Security settings [DO NOT TRANSLATE] -->
    <string name="help_url_security" translatable="false"></string>
    <!-- Help URL, Encryption settings [DO NOT TRANSLATE] -->
    <string name="help_url_encryption" translatable="false"></string>
    <!-- Help URL, Tap & pay [DO NOT TRANSLATE] -->
    <string name="help_url_nfc_payment" translatable="false"></string>
    <!-- Help URL, Remote display [DO NOT TRANSLATE] -->
    <string name="help_url_remote_display" translatable="false"></string>
    <!-- Help URL, Fingerprint [DO NOT TRANSLATE] -->
    <string name="help_url_fingerprint" translatable="false"></string>
    <!-- Help URL, Gesture settings -->
    <string name="help_url_gestures" translatable="false"></string>
    <!-- Help URL, Manage Storage [DO NOT TRANSLATE]-->
    <string name="help_url_manage_storage" translatable="false"></string>
    <!-- Help URL, Android is upgrading [DO NOT TRANSLATE] -->
    <string name="help_url_upgrading" translatable="false"></string>
    <!-- Help URL, Font size [DO NOT TRANSLATE] -->
    <string name="help_url_font_size" translatable="false"></string>
    <!-- Help URL, Display size [DO NOT TRANSLATE] -->
    <string name="help_url_display_size" translatable="false"></string>
    <!-- Help URL, Previously connected bluetooth devices [DO NOT TRANSLATE] -->
    <string name="help_url_previously_connected_devices" translatable="false"></string>
    <!-- Help URL, Auto brightness [DO NOT TRANSLATE] -->
    <string name="help_url_auto_brightness" translatable="false" />

    <string name="help_url_network_dashboard" translatable="false"></string>
    <string name="help_url_connected_devices" translatable="false"></string>
    <string name="help_url_apps_and_notifications" translatable="false"></string>
    <string name="help_url_night_display" translatable="false"></string>
    <string name="help_url_screen_saver" translatable="false"></string>
    <string name="help_url_pickup_gesture" translatable="false"></string>
    <string name="help_url_storage_dashboard" translatable="false"></string>
    <string name="help_url_lockscreen" translatable="false"></string>
    <string name="help_url_trust_agent" translatable="false"></string>
    <string name="help_url_usage_access" translatable="false"></string>
    <string name="help_url_screen_pinning" translatable="false"></string>
    <string name="help_url_user_and_account_dashboard" translatable="false"></string>
    <string name="help_url_accessibility_shortcut" translatable="false"></string>
    <string name="help_url_magnification" translatable="false"></string>
    <string name="help_url_color_correction" translatable="false"></string>
    <string name="help_url_autoclick" translatable="false"></string>
    <string name="help_url_system_dashboard" translatable="false"></string>
    <string name="help_url_double_tap_screen" translatable="false"></string>
    <string name="help_url_account_detail" translatable="false"></string>
    <string name="help_url_icc_lock" translatable="false"></string>
    <string name="help_uri_process_stats_summary" translatable="false"></string>
    <string name="help_uri_process_stats_apps" translatable="false"></string>
    <string name="help_uri_private_dns" translatable="false"></string>
    <string name="help_uri_about_phone_v2" translatable="false"></string>
    <string name="help_uri_wifi_calling" translatable="false"></string>
    <!-- url for the wifi scanning required dialog help page -->
    <string name="help_uri_wifi_scanning_required" translatable="false"></string>
    <!-- url for the bluetooth toggle required dialog help page -->
    <string name="help_uri_bluetooth_screen" translatable="false"></string>

    <!-- User account title [CHAR LIMIT=30] -->
    <string name="user_account_title">Account for content</string>
    <!-- User picture title [CHAR LIMIT=30] -->
    <string name="user_picture_title">Photo ID</string>

    <!-- Extreme threats title.  [CHAR LIMIT=30] -->
    <string name="extreme_threats_title">Extreme threats</string>
    <!-- Extreme threats summary.  [CHAR LIMIT=62] -->
    <string name="extreme_threats_summary">Receive alerts for extreme threats to life and property</string>
    <!-- Severe threats title.  [CHAR LIMIT=30] -->
    <string name="severe_threats_title">Severe threats</string>
    <!-- Extreme threats summary.  [CHAR LIMIT=60] -->
    <string name="severe_threats_summary">Receive alerts for severe threats to life and property</string>
    <!-- Amber alerts title.  [CHAR LIMIT=30] -->
    <string name="amber_alerts_title">AMBER alerts</string>
    <!-- Amber alerts summary.  [CHAR LIMIT=60] -->
    <string name="amber_alerts_summary">Receive bulletins about child abductions</string>
    <!-- repeat title.  Allows the user to set how oftem to repeat alert reminders.
         For example, they may have alerts just once or every 2 or 15 minutes.  [CHAR LIMIT=30] -->
    <string name="repeat_title">Repeat</string>

    <!-- Call Manager enable settings title.  [CHAR LIMIT=50] -->
    <string name="call_manager_enable_title">Enable Call Manager</string>
    <!-- Call Manager enable settings summary.  [CHAR LIMIT=80] -->
    <string name="call_manager_enable_summary">Allow this service to manage how your calls are made.</string>
    <!-- Call Manager settings title.  [CHAR LIMIT=50] -->
    <string name="call_manager_title">Call Manager</string>
    <!-- Call Manager settings summary.  [CHAR LIMIT=50] -->
    <string name="call_manager_summary"><xliff:g id="app">%1$s</xliff:g></string>
    <!-- Cell Broadcast settings title.  [CHAR LIMIT=50] -->
    <string name="cell_broadcast_settings">Emergency alerts</string>
    <!-- Network operators settings title.  [CHAR LIMIT=50] -->
    <string name="network_operators_settings">Network operators</string>
    <!-- Access point names title.  [CHAR LIMIT=50] -->
    <string name="access_point_names">Access point names</string>
    <!-- Enhaced 4G LTE Mode title.  [CHAR LIMIT=50] -->
    <string name="enhanced_4g_lte_mode_title">Enhanced 4G LTE Mode</string>
    <!-- Enhaced 4G LTE Mode summary.  [CHAR LIMIT=100] -->
    <string name="enhanced_4g_lte_mode_summary">Use LTE data to enhance voice and communications (Recommended)</string>
    <!-- Preferred network type title.  [CHAR LIMIT=50] -->
    <string name="preferred_network_type_title">Preferred network type</string>
    <!-- Preferred network type summary.  [CHAR LIMIT=100] -->
    <string name="preferred_network_type_summary">LTE (recommended)</string>
    <!-- Work SIM title.  [CHAR LIMIT=50] -->
    <string name="work_sim_title">Work SIM</string>

    <!-- User app limits screen title [CHAR LIMIT=35] -->
    <string name="user_restrictions_title">App &amp; content access</string>
    <!-- User limits screen, user name rename text [CHAR LIMIT=15] -->
    <string name="user_rename">RENAME</string>
    <!-- Preference label for custom restrictions [CHAR LIMIT=35] -->
    <string name="app_restrictions_custom_label">Set app restrictions</string>
    <!-- Summary for app entries that are controlled by another entry [CHAR LIMIT=none] -->
    <string name="user_restrictions_controlled_by">Controlled by <xliff:g id="app">%1$s</xliff:g></string>
    <!-- Summary text for apps that are allowed to access accounts from the primary user [CHAR LIMIT=none] -->
    <string name="app_sees_restricted_accounts">This app can access your accounts</string>
    <!-- Summary for a case when app entries that are controlled by another entry and app can access user accounts [CHAR LIMIT=none] -->
    <string name="app_sees_restricted_accounts_and_controlled_by">This app can access your accounts. Controlled by <xliff:g id="app">%1$s</xliff:g></string>

    <!-- Restrictions title for configuring wifi and mobile [CHAR LIMIT=35] -->
    <string name="restriction_wifi_config_title">Wi\u2011Fi and Mobile</string>
    <!-- Restrictions summary for configuring wifi and mobile [CHAR LIMIT=100] -->
    <string name="restriction_wifi_config_summary">Allow modification of Wi\u2011Fi and Mobile settings</string>
    <!-- Restrictions title for changing bluetooth configuration [CHAR LIMIT=35] -->
    <string name="restriction_bluetooth_config_title">Bluetooth</string>
    <!-- Restrictions summary for changing bluetooth configuration [CHAR LIMIT=100] -->
    <string name="restriction_bluetooth_config_summary">Allow modification of Bluetooth pairings and settings</string>
    <!-- Restrictions title for allowing NFC transfers [CHAR LIMIT=35] -->
    <string name="restriction_nfc_enable_title">NFC</string>
    <!-- Restrictions summary for allowing NFC transfers (tablet) [CHAR LIMIT=100] -->
    <string name="restriction_nfc_enable_summary_config">Allow data exchange when this <xliff:g id="device_name">%1$s</xliff:g> touches another NFC device</string>
    <!-- Restrictions summary for allowing NFC transfers (tablet) [CHAR LIMIT=100] -->
    <string name="restriction_nfc_enable_summary" product="tablet">Allow data exchange when the tablet touches another device</string>
    <!-- Restrictions summary for allowing NFC transfers (phone) [CHAR LIMIT=100] -->
    <string name="restriction_nfc_enable_summary" product="default">Allow data exchange when the phone touches another device</string>
    <!-- Restrictions title for allowing location sharing [CHAR LIMIT=35] -->
    <string name="restriction_location_enable_title">Location</string>
    <!-- Restrictions summary for allowing location sharing [CHAR LIMIT=100] -->
    <string name="restriction_location_enable_summary" >Let apps use your location information</string>

    <!-- Wizard back button label [CHAR LIMIT=25] -->
    <string name="wizard_back">Back</string>
    <!-- Wizard next button label [CHAR LIMIT=25] -->
    <string name="wizard_next">Next</string>
    <!-- Wizard next button label [CHAR LIMIT=25] -->
    <string name="wizard_finish">Finish</string>

    <!-- An option in a photo selection dialog, if there is no photo yet [CHAR LIMIT=50] -->
    <string name="user_image_take_photo" msgid="7496128293167402354">Take photo</string>
    <!-- An option in a photo selection dialog, if there is no photo yet [CHAR LIMIT=50] -->
    <string name="user_image_choose_photo" msgid="3746334626214970837">Choose photo from Gallery</string>
    <!-- Accessibility message for the photo selector which is a button/popup with the current photo [CHAR LIMIT=50] -->
    <string name="user_image_photo_selector">Select photo</string>

    <!-- Text to display in regulatory info screen (from device overlay). -->
    <string name="regulatory_info_text"></string>

    <!-- Title for SIM card settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_setup_wizard_title">SIM cards</string>
    <!-- Title for SIM settings title settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_settings_title">SIM cards</string>
    <!-- Summary for SIM settings title settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_settings_summary"><xliff:g id="sim_name">%1$s</xliff:g> - <xliff:g id="sim_number">%2$s</xliff:g></string>
    <!-- Message that SIM cards have changed.  [CHAR LIMIT=40] -->
    <string name="sim_cards_changed_message">SIM cards have changed</string>
    <!-- Message smmary that SIM cards have changed.  [CHAR LIMIT=60] -->
    <string name="sim_cards_changed_message_summary">Tap to set activities</string>
    <!-- Message that Cellular data is unavailable.  [CHAR LIMIT=40] -->
    <string name="sim_cellular_data_unavailable">Mobile data is unavailable</string>
    <!-- Message summary that Cellular data is unavailable.  [CHAR LIMIT=60] -->
    <string name="sim_cellular_data_unavailable_summary">Tap to select a data SIM</string>
    <!-- Checkbox to always use for calls.  [CHAR LIMIT=40] -->
    <string name="sim_calls_always_use">Always use this for calls</string>
    <!-- Message for selecting sim for data in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_data">Select a SIM for data</string>
    <!-- Message for switching data SIM; switching takes a while -->
    <string name="data_switch_started">Switching data SIM, this may take up to a minute...</string>
    <!-- Message for selecting sim for call in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_calls">Call with</string>
    <!-- Title for selecting a SIM card.  [CHAR LIMIT=40] -->
    <string name="sim_select_card">Select a SIM card</string>
    <!-- Label for a numbered SIM card.  [CHAR LIMIT=40] -->
    <string name="sim_card_number_title">SIM <xliff:g id="card_number">%1$d</xliff:g></string>
    <!-- Name label of Sim card that is empty.  [CHAR LIMIT=40] -->
    <string name="sim_slot_empty">SIM empty</string>
    <!-- Name label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_name">SIM name</string>
    <!-- Hint for SIM name in sim name editor dialog.  [CHAR LIMIT=40] -->
    <string name="sim_name_hint">Enter SIM name</string>
    <!-- Title label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_title">SIM slot %1$d</string>
    <!-- Carrier label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_carrier">Carrier</string>
    <!-- Number label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_number">Number</string>
    <!-- Color label of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_editor_color">SIM color</string>
    <!-- Select label Title of Sim Editor.  [CHAR LIMIT=40] -->
    <string name="sim_card_select_title">Select SIM card</string>
    <!-- Orange label.  [CHAR LIMIT=40] -->
    <string name="color_orange">Orange</string>
    <!-- Purple label.  [CHAR LIMIT=40] -->
    <string name="color_purple">Purple</string>
    <!-- Message informing the user that no SIM card is inserted  [CHAR LIMIT=60] -->
    <string name="sim_no_inserted_msg">No SIM cards inserted</string>
    <!-- SIM status title  [CHAR LIMIT=40] -->
    <string name="sim_status_title">SIM status</string>
    <!-- SIM status title  [CHAR LIMIT=40] -->
    <string name="sim_status_title_sim_slot">SIM status (sim slot %1$d)</string>
    <!-- Title for call back. [CHAR LIMIT=60] -->
    <string name="sim_call_back_title">Call back from default SIM</string>
    <!-- Title for outgoing back. [CHAR LIMIT=60] -->
    <string name="sim_outgoing_call_title">SIM for outgoing calls</string>
    <!-- Title for other call settings. [CHAR LIMIT=60] -->
    <string name="sim_other_call_settings">Other call settings</string>
    <!-- Preferred Network offload title.  [CHAR LIMIT=25] -->
    <string name="preferred_network_offload_title">Preferred network Offload</string>
    <!-- Preferred Network offload Header.  [CHAR LIMIT=25] -->
    <string name="preferred_network_offload_header">Disable Network Name Broadcast</string>
    <!-- Preferred Network offload Footer.  [CHAR LIMIT=100] -->
    <string name="preferred_network_offload_footer">Disable Network Name Broadcast protects from third parties getting access to your network information.</string>
    <!-- Preferred Network offload Popup.  [CHAR LIMIT=100] -->
    <string name="preferred_network_offload_popup">Disabling Network Name Broadcast will prevent automatic connection to hidden networks.</string>
    <!-- Summary text describing signal strength to the user.  [CHAR LIMIT=60] -->
    <string name="sim_signal_strength"><xliff:g id="dbm">%1$d</xliff:g> dBm <xliff:g id="asu">%2$d</xliff:g> asu</string>
    <!-- Title for SIM card notification.  [CHAR LIMIT=40] -->
    <string name="sim_notification_title">SIM cards changed.</string>
    <!-- Message under title informing the user to touch to go to SIM Cards in Settings.  [CHAR LIMIT=40] -->
    <string name="sim_notification_summary">Tap to set up</string>

    <!-- This is a divider in the SIM cards preferences that is the header of various settings where the user chooses which SIM to use for phone calls, data, and SMS messages [CHAR LIMIT=50] -->
    <string name="sim_pref_divider">Preferred SIM for</string>
    <!-- When a user chooses this "Ask first" preference for the SIM to use for phone calls, they'll be prompted to choose a SIM every time they initiate a call [CHAR LIMIT=50] -->
    <string name="sim_calls_ask_first_prefs_title">Ask every time</string>
    <!-- When a SIM preference hasn't been selected yet, this string is displayed as the pref summary until the user chooses a SIM subscription from the preference list [CHAR LIMIT=50] -->
    <string name="sim_selection_required_pref">Selection required</string>
    <!-- Title for SIM selection notification channel -->
    <string name="sim_selection_channel_title">SIM selection</string>

    <!--Dashboard strings-->
    <!-- Text to describe the dashboard fragment title [CHAR LIMIT=16] -->
    <string name="dashboard_title">Settings</string>
    <!-- Text to describe the items to be expanded as suggested settings [CHAR LIMIT=none] -->
    <plurals name="settings_suggestion_header_summary_hidden_items">
        <item quantity="one">Show %d hidden item</item>
        <item quantity="other">Show %d hidden items</item>
    </plurals>

    <!-- Content description for suggestion footer button. Double tapping will cause suggestion list to collapse [CHAR LIMIT=NONE]-->
    <string name="dashboard_suggestion_condition_footer_content_description">Collapse</string>

    <!-- Title for setting tile leading to network and Internet settings [CHAR LIMIT=40]-->
    <string name="network_dashboard_title">Network &amp; internet</string>
    <!-- Summary for Network and Internet settings, explaining it contains mobile network setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_mobile">mobile</string>
    <!-- Summary for Network and Internet settings, explaining it contains network data usage setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_data_usage">data usage</string>
    <!-- Summary for Network and Internet settings, explaining it contains hotspot (tethering) setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_hotspot">hotspot</string>

    <!-- Title for setting tile leading to Connected devices settings [CHAR LIMIT=40]-->
    <string name="connected_devices_dashboard_title">Connected devices</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_summary">Bluetooth, driving mode, NFC</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_no_nfc_summary">Bluetooth, driving mode</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_no_driving_mode_summary">Bluetooth, NFC</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary">Bluetooth</string>
    <!-- Title for setting tile leading to Apps & Notification settings [CHAR LIMIT=40]-->
    <string name="app_and_notification_dashboard_title">Apps &amp; notifications</string>
    <!-- Summary for Apps & Notification settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="app_and_notification_dashboard_summary">Permissions, default apps</string>
    <!-- Title for setting tile leading to account settings [CHAR LIMIT=40]-->
    <string name="account_dashboard_title">Accounts</string>
    <!-- Summary for account settings tiles when there is no accounts on device [CHAR LIMIT=NONE]-->
    <string name="account_dashboard_default_summary">No accounts added</string>
    <!-- Title for setting tile leading to setting UI which allows user set default app to
    handle actions such as open web page, making phone calls, default SMS apps [CHAR  LIMIT=40]-->
    <string name="app_default_dashboard_title">Default apps</string>
    <!-- Summary text for system preference tile, showing important setting items under system setting [CHAR LIMIT=NONE]-->
    <string name="system_dashboard_summary">Languages, time, backup, updates</string>

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

    <!--Search Keywords [CHAR LIMIT=NONE]-->
    <string name="keywords_wifi">wifi, wi-fi, network connection, internet, wireless, data, wi fi</string>
    <string name="keywords_change_wifi_state">wifi, wi-fi, toggle, control</string>
    <string name="keywords_more_default_sms_app">text message, texting, messages, messaging, default</string>
    <string name="keywords_more_mobile_networks">cellular, mobile, cell carrier, wireless, data, 4g,3g, 2g, lte</string>
    <string name="keywords_wifi_calling">wifi, wi-fi, call, calling</string>
    <string name="keywords_home">launcher, default, apps</string>
    <string name="keywords_display">screen, touchscreen</string>
    <string name="keywords_display_brightness_level">dim screen, touchscreen, battery, bright</string>
    <string name="keywords_display_auto_brightness">dim screen, touchscreen, battery</string>
    <string name="keywords_display_night_display">dim screen, night, tint, night shift, brightness, screen color, colour, color</string>
    <string name="keywords_display_wallpaper">background, personalize, customize display</string>
    <string name="keywords_display_font_size">text size</string>
    <string name="keywords_display_cast_screen">project, cast</string>
    <string name="keywords_storage">space, disk, hard drive, device usage</string>
    <string name="keywords_battery">power usage, charge</string>
    <string name="keywords_spell_checker">spelling, dictionary, spellcheck, auto-correct</string>
    <string name="keywords_voice_input">recognizer, input, speech, speak, language, hands-free, hand free, recognition, offensive, word, audio, history, bluetooth headset</string>
    <string name="keywords_text_to_speech_output">rate, language, default, speak, speaking, tts, accessibility, screen reader, blind</string>
    <string name="keywords_date_and_time">clock, military</string>
    <string name="keywords_network_reset">reset, restore, factory</string>
    <string name="keywords_factory_data_reset">wipe, delete, restore, clear, remove, factory reset</string>
    <string name="keywords_printing">printer</string>
    <string name="keywords_sounds">speaker beep, speaker, volume, mute, silence, audio, music</string>
    <string name="keywords_sounds_and_notifications_interruptions">dont don\u2019t disturb, interrupt, interruption, break</string>
    <string name="keywords_app">RAM</string>
    <string name="keywords_location">nearby, location, history, reporting</string>
    <string name="keywords_accounts">account</string>
    <string name="keywords_users">restriction, restrict, restricted</string>
    <string name="keywords_keyboard_and_ime">text correction, correct, sound, vibrate, auto, language, gesture, suggest, suggestion, theme, offensive, word, type, emoji, international</string>
    <string name="keywords_reset_apps">reset, preferences, default</string>
    <string name="keywords_emergency_app">emergency, ice, app, default</string>
    <string name="keywords_default_phone_app">phone, dialer, default</string>
    <string name="keywords_all_apps">apps, download, applications, system</string>
    <string name="keywords_app_permissions">apps, permissions, security</string>
    <string name="keywords_default_apps">apps, default</string>
    <string name="keywords_ignore_optimizations">ignore optimizations, doze, app standby</string>
    <string name="keywords_color_mode">vibrant, RGB, sRGB, color, natural, standard</string>
    <string name="keywords_color_temperature">color, temperature, D65, D73, white, yellow, blue, warm, cool</string>
    <string name="keywords_lockscreen">slide to unlock, password, pattern, PIN</string>
    <string name="keywords_profile_challenge">work challenge, work, profile</string>
    <string name="keywords_unification">work profile, managed profile, unify, unification, work, profile</string>
    <string name="keywords_gesture">gestures</string>
    <string name="keywords_payment_settings">pay, tap, payments</string>
    <string name="keywords_backup">backup, back up</string>
    <string name="keywords_assist_gesture_launch">gesture</string>
    <string name="keywords_imei_info">imei, meid, min, prl version, imei sv</string>
    <string name="keywords_sim_status">network, mobile network state, service state, signal strength, mobile network type, roaming, iccid</string>
    <string name="keywords_model_and_hardware">serial number, hardware version</string>
    <string name="keywords_android_version">android security patch level, baseband version, kernel version</string>
    <!-- Search keyword for Ambient display settings screen. -->
    <string name="keywords_ambient_display_screen">Ambient display, Lock screen display</string>
    <!-- Search keyword for fingerprint settings. -->
    <string name="keywords_fingerprint_settings">fingerprint</string>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- List of synonyms for ring and notification vibration setting (changes whether your phone vibrates when it rings), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_ring_vibration">haptics, vibrate, phone, call, sensitivity</string>

    <!-- NFC Wi-Fi pairing/setup strings-->

    <!-- Write NFC tag for Wi-Fi pairing/setup title [CHAR_LIMIT=30]-->
    <string name="setup_wifi_nfc_tag">Set up Wi-Fi NFC Tag</string>
    <!-- Text for button to confirm writing tag -->
    <string name="write_tag">Write</string>
    <!-- Text to inform the user to tap a tag to complete the setup process -->
    <string name="status_awaiting_tap">Tap a tag to write...</string>
    <!-- Text to inform the user that the network key entered was incorrect -->
    <string name="status_invalid_password">Invalid password, try again.</string>
    <!-- Text displayed when tag successfully writen -->
    <string name="status_write_success">Success!</string>
    <!-- Text displayed in error cases (failure to write to tag) -->
    <string name="status_failed_to_write">Unable to write data to NFC tag. If the problem persists, try a different tag</string>
    <!-- Text displayed when tag is not writable -->
    <string name="status_tag_not_writable">NFC tag is not writable. Please use a different tag.</string>

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

    <!-- Wifi Picker defaults-->
    <!-- The minimum kbps threshold needed to use badge; value is a map with key corresponding to
    the badge enum in ScoredNetworks (SD, HD etc) and value throughput in kbps -->
    <string name="wifi_badging_thresholds_default" translatable="false">10:3000,20:5000,30:25000</string>

    <!-- Sounds and Notification -->
    <!-- Sound: Dashboard summary indicating the volume of ringtone. example: Ring volume at 20%.
    [CHAR LIMIT=100] -->
    <string name="sound_settings_summary">Ring volume at <xliff:g id="percentage" example="2%">%1$s</xliff:g></string>

    <!-- Summary for sound settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="sound_dashboard_summary">Volume, vibration, Do Not Disturb</string>

    <!-- Sound: Dashboard summary indicating the volume of ringtone when at 0% with vibrate enabled. [CHAR LIMIT=100] -->
    <string name="sound_settings_summary_vibrate">Ringer set to vibrate</string>

    <!-- Sound: Dashboard summary indicating the volume of ringtone when at 0% with vibrate disabled [CHAR LIMIT=100] -->
    <string name="sound_settings_summary_silent">Ringer set to silent</string>

    <!-- Sound: Dashboard summary example used in Setup Wizard preview screen. [CHAR LIMIT=100] -->
    <string name="sound_settings_example_summary">Ring volume at 80%</string>

    <!-- Sound: Title for the option managing media volume. [CHAR LIMIT=30] -->
    <string name="media_volume_option_title">Media volume</string>

    <!-- Sound: Title for the option managing call volume. [CHAR LIMIT=30] -->
    <string name="call_volume_option_title">Call volume</string>

    <!-- Sound: Title for the option managing alarm volume. [CHAR LIMIT=30] -->
    <string name="alarm_volume_option_title">Alarm volume</string>

    <!-- Sound: Title for the option managing ring volume. [CHAR LIMIT=30] -->
    <string name="ring_volume_option_title">Ring volume</string>

    <!-- Sound: Title for the option managing notification volume. [CHAR LIMIT=30] -->
    <string name="notification_volume_option_title">Notification volume</string>

    <!-- Sound: Title for the option defining the phone ringtone. [CHAR LIMIT=30] -->
    <string name="ringtone_title">Phone ringtone</string>

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

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

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

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

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

    <!-- Sound: Title for the other sounds option and associated settings page. [CHAR LIMIT=30] -->
    <string name="other_sound_settings">Other sounds</string>

    <!-- Sound: Other sounds: Title for the option enabling touch sounds for dial pad tones. [CHAR LIMIT=30] -->
    <string name="dial_pad_tones_title">Dial pad tones</string>

    <!-- Sound: Other sounds: Title for the option enabling touch sounds for screen locking sounds. [CHAR LIMIT=30] -->
    <string name="screen_locking_sounds_title">Screen locking sounds</string>

    <!-- Sound: Other sounds: Title for the option enabling charging sounds. [CHAR LIMIT=30] -->
    <string name="charging_sounds_title">Charging sounds</string>

    <!-- Sound: Other sounds: Title for the option enabling docking sounds. [CHAR LIMIT=30] -->
    <string name="docking_sounds_title">Docking sounds</string>

    <!-- Sound: Other sounds: Title for the option enabling touch sounds. [CHAR LIMIT=30] -->
    <string name="touch_sounds_title">Touch sounds</string>

    <!-- Sound: Other sounds: Title for the option enabling haptic feedback on touch. [CHAR LIMIT=30] -->
    <string name="vibrate_on_touch_title">Touch vibration</string>

    <!-- Sound: Other sounds: Preference summary to the option enabling haptic feedback on touch. -->
    <string name="vibrate_on_touch_summary">Haptic feedback for tap, keyboard, and more</string>

    <!-- Sound: Other sounds: Title for the option enabling dock audio media. [CHAR LIMIT=50] -->
    <string name="dock_audio_media_title">Dock speaker plays</string>

    <!-- Sound: Other sounds: Value for the dock audio media with value 0: disabled. [CHAR LIMIT=30] -->
    <string name="dock_audio_media_disabled">All audio</string>

    <!-- Sound: Other sounds: Value for the dock audio media with value 1: enabled. [CHAR LIMIT=30] -->
    <string name="dock_audio_media_enabled">Media audio only</string>

    <!-- Sound: Other sounds: Value for the emergency dialing signal option with value 0: silence. [CHAR LIMIT=30] -->
    <string name="emergency_tone_silent">Silence</string>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!--  Do not disturb: Zen mode option: Important interruptions [CHAR LIMIT=60] -->
    <string name="zen_mode_option_important_interruptions">Priority only</string>

    <!--  Do not disturb: Zen mode option: Alarms only [CHAR LIMIT=60] -->
    <string name="zen_mode_option_alarms">Alarms only</string>

    <!--  Do not disturb: Zen mode option: No interruptions [CHAR LIMIT=60] -->
    <string name="zen_mode_option_no_interruptions">Total silence</string>

    <!--  Do not disturb: Zen mode combined summary + condition line [CHAR LIMIT=60] -->
    <string name="zen_mode_summary_combination"><xliff:g id="mode" example="Priority only">%1$s</xliff:g>: <xliff:g id="exit condition" example="Until you turn this off">%2$s</xliff:g></string>

    <!--  Do not disturb: Title for the Visual interruptions option and associated settings page. [CHAR LIMIT=30] -->
    <string name="zen_mode_visual_interruptions_settings_title">Block visual disturbances</string>

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

    <!-- Do not disturb: zen settings screens category title [CHAR LIMIT=100] -->
    <string name="zen_mode_settings_category">When Do Not Disturb is turned on</string>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- Do not disturb settings, category header [CHAR LIMIT=100]-->
    <string name="zen_category_behavior">Behavior</string>
    <!-- Do not disturb settings, category header [CHAR LIMIT=100]-->
    <string name="zen_category_exceptions">Exceptions</string>
    <!-- Do not disturb settings, category header [CHAR LIMIT=100]-->
    <string name="zen_category_schedule">Schedule</string>

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

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

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

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

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

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

    <!-- Work Sounds: Work sound settings section header.  [CHAR LIMIT=50] -->
    <string name="sound_work_settings">Work profile sounds</string>

    <!-- Work Sounds: Title for the switch that enables syncing of personal ringtones to work profile. [CHAR LIMIT=60] -->
    <string name="work_use_personal_sounds_title">Use personal profile sounds</string>

    <!--  Work Sound: Summary for the switch that enables syncing of personal ringtones to work profile. [CHAR LIMIT=160] -->
    <string name="work_use_personal_sounds_summary">Sounds are the same for work and personal profiles</string>

    <!-- Work Sounds: Title for the option defining the work phone ringtone. [CHAR LIMIT=60] -->
    <string name="work_ringtone_title">Work phone ringtone</string>

    <!-- Work Sounds: Title for the option defining the default work notification ringtone. [CHAR LIMIT=60] -->
    <string name="work_notification_ringtone_title">Default work notification sound</string>

    <!-- Work Sound: Title for the option defining the default work alarm ringtone. [CHAR LIMIT=60] -->
    <string name="work_alarm_ringtone_title">Default work alarm sound</string>

    <!--  Work Sound: Summary for sounds when sync with personal sounds is active [CHAR LIMIT=60] -->
    <string name="work_sound_same_as_personal">Same as personal profile</string>

    <!-- Work Sound: Title for dialog shown when enabling sync with personal sounds. [CHAR LIMIT=60] -->
    <string name="work_sync_dialog_title">Replace sounds?</string>

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

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

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

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

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

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

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

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

    <!-- Preference title for showing all apps on device [CHAR_LIMIT=50]-->
    <string name="recent_notifications_see_all_title">See all from last 7 days</string>

    <!-- Configure Notifications: Advanced section header [CHAR LIMIT=30] -->
    <string name="advanced_section_header">Advanced</string>

    <!-- Configure Notifications: Work profile section header [CHAR LIMIT=30] -->
    <string name="profile_section_header">Work notifications</string>

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

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

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

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

    <!-- Configure Notifications: Value for lockscreen notifications:  all information will be
         shown in notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_show">Show all notification content</string>

    <!-- Configure Notifications: Value for lockscreen notifications: sensitive information will be
         hidden or redacted from notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_hide">Hide sensitive content</string>

    <!-- Configure Notifications: Value for lockscreen notifications: notifications will not appear on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_disable">Don\u2019t show notifications at all</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Message asking the user how they want their notifications to appear when the device is locked [CHAR LIMIT=NONE] -->
    <string name="lock_screen_notifications_interstitial_message">When your device is locked, how do you want notifications to show?</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Title for the screen asking the user how they want their notifications to appear when the device is locked [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_interstitial_title">Notifications</string>

    <!-- Configure Notifications: Value for lockscreen notifications:  all information will be
         shown in work notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_show_profile">Show all work notification content</string>

    <!-- Configure Notifications: Value for lockscreen notifications: sensitive information will be
         hidden or redacted from work notifications shown on a secure lock screen
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_hide_profile">Hide sensitive work content</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Message asking the user how they want their profile notifications to appear when the device is locked [CHAR LIMIT=NONE] -->
    <string name="lock_screen_notifications_interstitial_message_profile">When your device is locked, how do you want profile notifications to show?</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Title for the screen asking the user how they want their profile notifications to appear when the device is locked [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_interstitial_title_profile">Profile notifications</string>

    <!-- Notification Settings: Title for an individual app's notification settings. [CHAR LIMIT=30] -->
    <string name="notifications_title">Notifications</string>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- [CHAR LIMIT=100] Notification Importance title: high importance level title -->
    <string name="notification_channel_summary_high">Urgent importance</string>

    <!-- [CHAR LIMIT=100] Label for on/off toggle -->
    <string name="notification_switch_label">Show notifications</string>

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

    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <string name="notifications_sent_daily">~<xliff:g id="number">%1$s</xliff:g> per day</string>
    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <string name="notifications_sent_weekly">~<xliff:g id="number">%1$s</xliff:g> per week</string>
    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <string name="notifications_sent_never">Never</string>

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

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

    <!-- Summary of preference to manage notification listeners, when none are enabled -->
    <string name="manage_notification_access_summary_zero">Apps cannot read notifications</string>

    <!-- Summary of preference to manage notification listeners, when one or more are enabled
         and are therefore able to read the user's notifications -->
    <plurals name="manage_notification_access_summary_nonzero">
        <item quantity="one">%d app can read notifications</item>
        <item quantity="other">%d apps can read notifications</item>
    </plurals>

    <!-- String to show in the list of notification listeners, when none is installed -->
    <string name="no_notification_listeners">No installed apps have requested notification access.</string>

    <!-- Title for a warning message about security implications of enabling a notification
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="notification_listener_security_warning_title">Allow notification access for
         <xliff:g id="service" example="NotificationReader">%1$s</xliff:g>?</string>
    <!-- Summary for a warning message about security implications of enabling a notification
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="notification_listener_security_warning_summary">
        <xliff:g id="notification_listener_name">%1$s</xliff:g> will be able to read all notifications,
        including personal information such as contact names and the text of messages you receive.
        It will also be able to dismiss notifications or trigger action buttons they contain.
        \n\nThis will also give the app the ability to turn Do Not Disturb on or off and change related settings.
    </string>
    <string name="notification_listener_disable_warning_summary">
        If you turn off notification access for <xliff:g id="notification_listener_name">%1$s</xliff:g>, Do Not Disturb access may also be turned off.
    </string>
    <string name="notification_listener_disable_warning_confirm">Turn off</string>
    <string name="notification_listener_disable_warning_cancel">Cancel</string>

    <!-- Title for managing VR (virtual reality) helper services. [CHAR LIMIT=50] -->
    <string name="vr_listeners_title">VR helper services</string>

    <!-- String to show in the list of vr listeners, when none is installed -->
    <string name="no_vr_listeners">No installed apps have requested to be run as VR helper services.</string>

    <!-- Title for a warning message about security implications of enabling a VR
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="vr_listener_security_warning_title">Allow VR service access for
         <xliff:g id="service" example="VrCore">%1$s</xliff:g>?</string>
    <!-- Summary for a warning message about security implications of enabling a VR
          listener, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="vr_listener_security_warning_summary">
        <xliff:g id="vr_listener_name">%1$s</xliff:g> will be able to run when you are using
        applications in virtual reality mode.
    </string>

    <!-- Title for what display preferences are applied when device is in VR mode -->
    <string name="display_vr_pref_title">When device is in VR</string>

    <!-- [CHAR LIMIT=70] Put display into low-persistence mode, this decreases motion blur. -->
    <string name="display_vr_pref_low_persistence">Reduce blur (recommended)</string>

    <!-- [CHAR LIMIT=70] Do not change default display settings, this may reduce perceived screen
         flicker while in VR mode. -->
    <string name="display_vr_pref_off">Reduce flicker</string>

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

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

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

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

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

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

    <!-- Sound & notification > Advanced section: Title for managing Do Not Disturb access option. [CHAR LIMIT=40] -->
    <string name="manage_zen_access_title">Do Not Disturb access</string>

    <!-- Sound & notification > Do Not Disturb access > Text to display when the list is empty. [CHAR LIMIT=NONE] -->
    <string name="zen_access_empty_text">No installed apps have requested Do Not Disturb access</string>

    <!-- [CHAR LIMIT=NONE] Text when loading app list in notification settings -->
    <string name="loading_notification_apps">Loading apps...</string>

    <!-- [CHAR LIMIT=NONE] Text appearing when app notifications are off -->
    <string name="app_notifications_off_desc">At your request, Android is blocking this app\'s notifications from appearing on this device</string>

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

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

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

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

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

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

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

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

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

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

    <!-- [CHAR LIMIT=NONE] App notification settings: notifications disabled-->
    <string name="notification_toggle_off">Off</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Block option title -->
    <string name="app_notification_block_title">Block all</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Block option description-->
    <string name="app_notification_block_summary">Never show these notifications</string>

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

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

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

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

    <!-- [CHAR LIMIT=NONE] App notification settings: Override DND option title -->
    <string name="app_notification_override_dnd_title">Override Do Not Disturb</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Override DND option description-->
    <string name="app_notification_override_dnd_summary">Let these notifications continue to interrupt when Do Not Disturb is on</string>

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

    <!-- [CHAR LIMIT=20] Notification settings: App notifications row summary when allowed -->
    <string name="app_notification_row_banned">Blocked</string>

    <!-- [CHAR LIMIT=40] Notification settings: App notifications row summary when high priority -->
    <string name="app_notification_row_priority">Priority</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications row summary when sensitive -->
    <string name="app_notification_row_sensitive">Sensitive</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications dialog dismiss button caption -->
    <string name="app_notifications_dialog_done">Done</string>

    <!-- [CHAR LIMIT=150] App notification settings: App notifications Importance title -->
    <string name="app_notification_importance_title">Importance</string>

    <!-- [CHAR LIMIT=180] Notification settings: lights -->
    <string name="notification_show_lights_title">Blink light</string>

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

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

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

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

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

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

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

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

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

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

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

    <!-- [CHAR LIMIT=60] Zen mode settings: Choose rule type dialog title -->
    <string name="zen_mode_choose_rule_type">Choose rule type</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Delete rule dialog confirmation message -->
    <string name="zen_mode_delete_rule_confirmation">Delete \u201c<xliff:g id="rule" example="Weekends">%1$s</xliff:g>\u201d rule?</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Delete rule dialog button caption -->
    <string name="zen_mode_delete_rule_button">Delete</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: External rule type name if unknown -->
    <string name="zen_mode_rule_type_unknown">Unknown</string>

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

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

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

    <!-- [CHAR LIMIT=40] Zen mode settings: Schedule rule type name -->
    <string name="zen_schedule_rule_type_name">Time</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Schedule rule toast hint when enabled -->
    <string name="zen_schedule_rule_enabled_toast">Automatic rule set to turn on Do Not Disturb during specified times</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event rule type name -->
    <string name="zen_event_rule_type_name">Event</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Event rule toast hint when enabled -->
    <string name="zen_event_rule_enabled_toast">Automatic rule set to turn on Do Not Disturb during specified events</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule calendar option title -->
    <string name="zen_mode_event_rule_calendar">During events for</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule summary fragment: During events for -->
    <string name="zen_mode_event_rule_summary_calendar_template">During events for <xliff:g id="calendar" example="any calendar">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule summary fragment: any calendar -->
    <string name="zen_mode_event_rule_summary_any_calendar">any calendar</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule summary fragment: Where reply is -->
    <string name="zen_mode_event_rule_summary_reply_template">Where reply is <xliff:g id="reply" example="Yes, Maybe, or Not replied">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule calendar option value for any calendar -->
    <string name="zen_mode_event_rule_calendar_any">Any calendar</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option title -->
    <string name="zen_mode_event_rule_reply">Where reply is</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option value: Yes, Maybe, or Not replied -->
    <string name="zen_mode_event_rule_reply_any_except_no">Yes, Maybe, or Not replied</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option value: Yes or Maybe -->
    <string name="zen_mode_event_rule_reply_yes_or_maybe">Yes or Maybe</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Event-based rule reply option value: Yes -->
    <string name="zen_mode_event_rule_reply_yes">Yes</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Text to display if rule isn't found -->
    <string name="zen_mode_rule_not_found_text">Rule not found.</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule summary template (when enabled) -->
    <string name="zen_mode_rule_summary_enabled_combination">On / <xliff:g id="mode" example="Alarms only">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Third party Rule summary template -->
    <string name="zen_mode_rule_summary_provider_combination"><xliff:g id="package" example="Condition Provider App">%1$s</xliff:g>\n<xliff:g id="summary" example="On / Alarms only">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Time-based rule days option title -->
    <string name="zen_mode_schedule_rule_days">Days</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Downtime days option value, no days set -->
    <string name="zen_mode_schedule_rule_days_none">None</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Downtime days option value, all days set -->
    <string name="zen_mode_schedule_rule_days_all">Every day</string>

    <!-- [CHAR LIMIT=60] Zen mode settings: Downtime rule setting -->
    <string name="zen_mode_schedule_alarm_title">Alarm can override end time</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Downtime rule setting -->
    <string name="zen_mode_schedule_alarm_summary">Stop at the end time or next alarm, whichever comes first</string>

    <!-- [CHAR LIMIT=40] General divider text when concatenating multiple items in a text summary -->
    <string name="summary_divider_text">,\u0020</string>

    <!-- [CHAR LIMIT=40] General template for a symbolic start - end range in a text summary -->
    <string name="summary_range_symbol_combination"><xliff:g id="start" example="Sun">%1$s</xliff:g> - <xliff:g id="end" example="Thu">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=40] General template for a verbal start to end range in a text summary -->
    <string name="summary_range_verbal_combination"><xliff:g id="start" example="Sun">%1$s</xliff:g> to <xliff:g id="end" example="Thu">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=20] Zen mode settings: Calls option -->
    <string name="zen_mode_calls">Calls</string>

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

    <!-- [CHAR LIMIT=20] Zen mode settings: Calls screen footer -->
    <string name="zen_mode_calls_footer">When Do Not Disturb is on, incoming calls are blocked. You can adjust settings to allow your friends, family, or other contacts to reach you.</string>

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

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

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

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

    <!-- [CHAR LIMIT=50] Zen mode settings: All messages summary -->
    <string name="zen_mode_all_messages">Messages</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Selected messages summary -->
    <string name="zen_mode_selected_messages">Some messages</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From anyone -->
    <string name="zen_mode_from_anyone">From anyone</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From contacts only -->
    <string name="zen_mode_from_contacts">From contacts only</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From starred contacts only -->
    <string name="zen_mode_from_starred">From starred contacts only</string>

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

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

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

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

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

    <!-- [CHAR LIMIT=50] Zen mode settings: Media option -->
    <string name="zen_mode_media">Media</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: System option which includes sounds such as touch sounds -->
    <string name="zen_mode_system">Touch sounds</string>

    <!-- [CHAR LIMIT=50] Zen mode settings: Reminders option -->
    <string name="zen_mode_reminders">Reminders</string>

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

    <!-- [CHAR LIMIT=50] Zen mode settings: Events option -->
    <string name="zen_mode_events">Events</string>

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

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

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

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

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

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

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

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

    <!-- [CHAR LIMIT=200] Zen mode settings: Repeat callers option summary -->
    <string name="zen_mode_repeat_callers_summary">If the same person calls a second time within a <xliff:g id="minutes">%d</xliff:g> minute period</string>

    <!-- [CHAR LIMIT=50] Zen mode settings dnd beahvior description: when a user has chosen custom sounds to bypass DND -->
    <string name="zen_mode_behavior_summary_custom">Custom</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option -->
    <string name="zen_mode_when">Automatically turn on</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option value: Never -->
    <string name="zen_mode_when_never">Never</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option value: Every night -->
    <string name="zen_mode_when_every_night">Every night</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: When option value: Weeknights -->
    <string name="zen_mode_when_weeknights">Weeknights</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: Start time option -->
    <string name="zen_mode_start_time">Start time</string>

    <!-- [CHAR LIMIT=20] Zen mode settings: End time option -->
    <string name="zen_mode_end_time">End time</string>

    <!-- [CHAR LIMIT=60] Zen mode settings: End time option: Summary text value format when end time = next day -->
    <string name="zen_mode_end_time_next_day_summary_format"><xliff:g id="formatted_time" example="7:00 AM">%s</xliff:g> next day</string>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only forever. -->
    <string name="zen_mode_summary_alarms_only_indefinite">Change to alarms only indefinitely</string>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only for < 60 minutes. -->
    <plurals name="zen_mode_summary_alarms_only_by_minute">
        <item quantity="one">Change to alarms only for one minute until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g></item>
        <item quantity="other">Change to alarms only for <xliff:g id="duration" example="2">%1$d</xliff:g> minutes (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only for N hours. -->
    <plurals name="zen_mode_summary_alarms_only_by_hour">
        <item quantity="one">Change to alarms only for one hour until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g></item>
        <item quantity="other">Change to alarms only for <xliff:g id="duration" example="2">%1$d</xliff:g> hours until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g></item>
    </plurals>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only until a specific time. -->
    <string name="zen_mode_summary_alarms_only_by_time">Change to alarms only until <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g></string>

    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: Turn on all notifications. -->
    <string name="zen_mode_summary_always">Change to always interrupt</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: visual signals: screen is on: title -->
    <string name="zen_mode_screen_on">When the screen is on</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual signals: screen is on: summary -->
    <string name="zen_mode_screen_on_summary">Let notifications silenced by Do Not Disturb pop on screen and show a status bar icon</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: visual signals: screen is off: title -->
    <string name="zen_mode_screen_off">When the screen is off</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is off: summary -->
    <string name="zen_mode_screen_off_summary">Let notifications silenced by Do Not Disturb turn on the screen and blink the light</string>
    <!-- [CHAR LIMIT=130] Zen mode settings:  visual interruptions: screen is off: summary -->
    <string name="zen_mode_screen_off_summary_no_led">Let notifications silenced by Do Not Disturb turn on the screen</string>

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

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

    <!-- [CHAR LIMIT=35] Feedback on the device -->
    <string name="device_feedback">Send feedback about this device</string>

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

    <!-- PIN entry dialog title for entering the administrator PIN [CHAR LIMIT=none] -->
    <string name="restr_pin_enter_admin_pin">Enter admin PIN</string>

    <!-- Switch On/Off  -->
    <string name="switch_on_text">On</string>
    <string name="switch_off_text">Off</string>

    <!-- [CHAR LIMIT=28] Screen pinning title -->
    <string name="screen_pinning_title">Screen pinning</string>
    <!-- [CHAR LIMIT=300] Screen pinning description -->
    <string name="screen_pinning_description">When this setting is turned on, you can use screen pinning to keep the current screen in view until you unpin.\n\nTo use screen pinning:\n\n1. Make sure screen pinning is turned on\n\n2. Open Overview\n\n3. Tap the app icon at the top of the screen, then tap Pin</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_pattern">Ask for unlock pattern before unpinning</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_pin">Ask for PIN before unpinning</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_password">Ask for password before unpinning</string>
    <!-- [CHAR LIMIT=60] Unlock setting for screen pinning -->
    <string name="screen_pinning_unlock_none">Lock device when unpinning</string>

    <!-- Opening string on the dialog that prompts the user to confirm that they really want to delete their existing work profile. The administration app icon and name appear after the final colon. [CHAR LIMIT=NONE] -->
    <string name="opening_paragraph_delete_profile_unknown_company">This work profile is managed by:</string>
    <!-- Summary for work profile accounts group. [CHAR LIMIT=25] -->
    <string name="managing_admin">Managed by <xliff:g id="admin_app_label">%s</xliff:g></string>

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

    <!-- Encryption interstitial title. This screen asks the user whether the device will ask for a PIN / pattern / password before the device starts up. [CHAR LIMIT=30] -->
    <string name="encryption_interstitial_header">Secure start-up</string>

    <!-- Encryption interstitial button to continue with the shown setting.  Appears on screen that asks the user to opt in/out of encrypting device with a pin/pattern/password. [CHAR LIMIT=NONE] -->
    <string name="encryption_continue_button">Continue</string>

    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a PIN to encrypt the device. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pin">
   You can further protect this device by requiring your PIN before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.
   \n\nThis helps protect data on lost or stolen devices. Require PIN to start your device?
   </string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a pattern to encrypt the device. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pattern">
   You can further protect this device by requiring your pattern before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.
   \n\nThis helps protect data on lost or stolen devices. Require pattern to start your device?
   </string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a password to encrypt the device. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_password">
   You can further protect this device by requiring your password before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.
   \n\nThis helps protect data on lost or stolen devices. Require password to start your device?
   </string>

    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a PIN to encrypt the device while setting up fingerprint unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pin_for_fingerprint">In addition to using your fingerprint to unlock your device, you can further protect this device by requiring your PIN before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.\n\nThis helps protect data on lost or stolen devices. Require PIN to start your device?</string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a pattern to encrypt the device while setting up fingerprint unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_pattern_for_fingerprint">In addition to using your fingerprint to unlock your device, you can further protect this device by requiring your pattern before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.\n\nThis helps protect data on lost or stolen devices. Require pattern to start your device?</string>
    <!-- Message shown on encryption interstitial to ask the user whether or not they want to use a password to encrypt the device while setting up fingerprint unlock. [CHAR LIMIT=NONE] -->
    <string name="encryption_interstitial_message_password_for_fingerprint">In addition to using your fingerprint to unlock your device, you can further protect this device by requiring your password before it starts up. Until the device starts up, it can\u2019t receive calls, messages, or notifications, including alarms.\n\nThis helps protect data on lost or stolen devices. Require password to start your device?</string>

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

    <!-- Label to say yes to the question of whether app is restricted. [CHAR LIMIT=20] -->
    <string name="restricted_true_label">Restricted</string>
    <!-- Label to say no to the question of whether app is restricted. [CHAR LIMIT=20] -->
    <string name="restricted_false_label">App can use battery in background</string>

    <!-- Title for encryption dialog that disables TalkBack. [CHAR_LIMIT=25] -->
    <string name="encrypt_talkback_dialog_require_pin">Require PIN?</string>

    <!-- Title for encryption dialog that disables TalkBack. [CHAR_LIMIT=25] -->
    <string name="encrypt_talkback_dialog_require_pattern">Require pattern?</string>

    <!-- Title for encryption dialog that disables TalkBack. [CHAR_LIMIT=25] -->
    <string name="encrypt_talkback_dialog_require_password">Require password?</string>

    <!-- Message for encryption dialog telling the user that Talkback and other accessibility services will be disabled. -->
    <string name="encrypt_talkback_dialog_message_pin">When you enter your PIN to start this device, accessibility services like <xliff:g id="service" example="TalkBack">%1$s</xliff:g> won\u2019t yet be available.</string>

    <!-- Message for encryption dialog telling the user that Talkback and other accessibility services will be disabled. -->
    <string name="encrypt_talkback_dialog_message_pattern">When you enter your pattern to start this device, accessibility services like <xliff:g id="service" example="TalkBack">%1$s</xliff:g> won\u2019t yet be available.</string>

    <!-- Message for encryption dialog telling the user that Talkback and other accessibility services will be disabled. -->
    <string name="encrypt_talkback_dialog_message_password">When you enter your password to start this device, accessibility services like <xliff:g id="service" example="TalkBack">%1$s</xliff:g> won\u2019t yet be available.</string>

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

    <!-- Title and summary for SIM Status -->
    <string name="imei_information_title">IMEI information</string>
    <string name="imei_information_summary">IMEI relative information</string>
    <string name="slot_number">(Slot<xliff:g id="slot_num">%1$d</xliff:g>)</string>

    <!-- New strings needed for App Info 2 -->
    <!-- Preference label for app default launch settings [CHAR LIMIT=35]-->
    <string name="launch_by_default">Open by default</string>

    <!-- Category name for App Launch -->
    <string name="app_launch_domain_links_title">Opening links</string>
    <string name="app_launch_open_domain_urls_title">Open supported links</string>
    <string name="app_launch_open_domain_urls_summary">Open without asking</string>
    <string name="app_launch_supported_domain_urls_title">Supported links</string>
    <string name="app_launch_other_defaults_title">Other defaults</string>

    <!-- Summary for app storage preference -->
    <string name="storage_summary_format"><xliff:g id="size" example="30.00MB">%1$s</xliff:g> used in <xliff:g id="storage_type" example="internal memory">%2$s</xliff:g></string>
    <!-- Summary describing internal storage for applications [CHAR LIMIT=25] -->
    <string name="storage_type_internal">Internal storage</string>
    <!-- Summary describing external storage for applications [CHAR LIMIT=25] -->
    <string name="storage_type_external">External storage</string>

    <!-- Title for data usage screen when entered from app info [CHAR LIMIT=30] -->
    <string name="app_data_usage">App data usage</string>
    <!-- Summary for data usage preference [CHAR LIMIT=15] -->
    <string name="data_summary_format"><xliff:g id="size" example="30.00MB">%1$s</xliff:g> used since <xliff:g id="date" example="Jan 12">%2$s</xliff:g></string>

    <!-- Title of storage preference to control where app is stored -->
    <string name="storage_used">Storage used</string>

    <!-- Title of button to change storage [CHAR LIMIT=25] -->
    <string name="change">Change</string>

    <!-- Title of dialog to change storage [CHAR LIMIT=25] -->
    <string name="change_storage">Change storage</string>

    <!-- Label for notification settings for an specific app [CHAR LIMIT=40] -->
    <string name="notifications_label">Notifications</string>
    <!-- App notification summary with notifications enabled [CHAR LIMIT=40] -->
    <string name="notifications_enabled">On</string>
    <!-- App notification summary with notifications enabled [CHAR LIMIT=40] -->
    <string name="notifications_enabled_with_info">On / <xliff:g id="notifications_categories_off" example="3 categories turned off">%1$s</xliff:g> </string>
    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="notifications_disabled">Off</string>
    <!-- Label for showing apps with some blocked notifications in list [CHAR LIMIT=30] -->
    <string name="notifications_partly_blocked"><xliff:g id="count" example="1">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$d</xliff:g> categories turned off</string>
    <!-- App notification summary with notifications silenced [CHAR LIMIT=40] -->
    <string name="notifications_silenced">Silenced</string>
    <!-- App notification summary with notifications redacted [CHAR LIMIT=70] -->
    <string name="notifications_redacted">Sensitive content not on lock screen</string>
    <!-- App notification summary with notifications hidden [CHAR LIMIT=40] -->
    <string name="notifications_hidden">Not on lock screen</string>
    <!-- App notification summary with notifications bypassing DND [CHAR LIMIT=40] -->
    <string name="notifications_priority">Do Not Disturb overridden</string>
    <!-- App notification summary divider [CHAR LIMIT=40] -->
    <string name="notifications_summary_divider">\u00A0/\u00A0</string>
    <!-- App notification summary for advanced controls -->
    <string name="notification_summary_level">Level %d</string>
    <!-- App notification summary channel divider-->
    <string name="notification_summary_channel"><xliff:g id="channel_name">%1$s</xliff:g> \u2022 <xliff:g id="group_name">%2$s</xliff:g></string>

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

    <!-- Permissions preference summary [CHAR LIMIT=40] -->
    <plurals name="permissions_summary">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> permission granted</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> permissions granted</item>
    </plurals>

    <!-- Runtime permissions preference summary [CHAR LIMIT=40] -->
    <plurals name="runtime_permissions_summary">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> of <xliff:g id="count" example="1">%d</xliff:g> permission granted</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> of <xliff:g id="count" example="10">%d</xliff:g> permissions granted</item>
    </plurals>

    <!-- Runtime permissions preference summary.  Number of additional permissions granted. [CHAR LIMIT=40] -->
    <plurals name="runtime_permissions_additional_count">
        <item quantity="one"><xliff:g id="count" example="1">%d</xliff:g> additional permission</item>
        <item quantity="other"><xliff:g id="count" example="10">%d</xliff:g> additional permissions</item>
    </plurals>

    <!-- Runtime permissions preference summary, shown when the app has no permissions granted. [CHAR LIMIT=40] -->
    <string name="runtime_permissions_summary_no_permissions_granted">No permissions granted</string>

    <!-- Runtime permissions preference summary, shown when the app requests no permissions. [CHAR LIMIT=40] -->
    <string name="runtime_permissions_summary_no_permissions_requested">No permissions requested</string>

    <!-- Label for showing all apps in list [CHAR LIMIT=30] -->
    <string name="filter_all_apps">All apps</string>
    <!-- Label for showing enabled apps in list [CHAR LIMIT=30] -->
    <string name="filter_enabled_apps">Installed apps</string>
    <!-- Label for showing instant apps in list [CHAR LIMIT=40] -->
    <string name="filter_instant_apps">Instant apps</string>
    <!-- Label for showing personal apps in list [CHAR LIMIT=30] -->
    <string name="filter_personal_apps">Personal</string>
    <!-- Label for showing work apps in list [CHAR LIMIT=30] -->
    <string name="filter_work_apps">Work</string>

    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_all_apps">Apps: All</string>
    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_blocked_apps">Apps: Turned off</string>
    <!-- Label for showing categories with urgent notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_urgent_channels">Categories: Urgent importance</string>
    <!-- Label for showing categories with low importance notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_low_channels">Categories: Low importance</string>
    <!-- Label for showing categories with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_blocked_channels">Categories: Turned off</string>
    <!-- Label for showing categories with notifications that override dnd in list [CHAR LIMIT=30] -->
    <string name="filter_notif_dnd_channels">Categories: Overrides Do Not Disturb</string>

    <!-- Title for advanced application management settings [CHAR LIMIT=30] -->
    <string name="advanced_apps">Advanced</string>

    <!-- Title for application configuration settings [CHAR LIMIT=30] -->
    <string name="configure_apps">Configure apps</string>

    <!-- Warning toast shown when data usage screen can't find specified app -->
    <string name="unknown_app">Unknown app</string>

    <!-- Label for list that shows all permissions -->
    <string name="app_permissions">App permissions</string>
    <!-- Summary of permissions currently granted to apps [CHAR LIMIT=60] -->
    <string name="app_permissions_summary">Apps using <xliff:g id="apps" example="location">%1$s</xliff:g></string>

    <!-- Label for tap to wake setting [CHAR LIMIT=30] -->
    <string name="tap_to_wake">Tap to wake</string>

    <!-- Summary for take to wake setting [CHAR LIMIT=90] -->
    <string name="tap_to_wake_summary">Double-tap anywhere on the screen to wake device</string>

    <!-- Title of a preference item that will show the user's preferences for this app's priority for opening links to websites that it claims to support [CHAR LIMIT=30] -->
    <string name="domain_urls_title">Opening links</string>

    <!-- Summary for an app that doesn't open any domain URLs [CHAR LIMIT=45] -->
    <string name="domain_urls_summary_none">Don\u2019t open supported links</string>

    <!-- Summary of an app that can open URLs for exactly one domain [CHAR LIMIT=45] -->
    <string name="domain_urls_summary_one">Open <xliff:g id="domain" example="mail.google.com">%s</xliff:g></string>

    <!-- Summary of an app that can open several domain's URLs [CHAR LIMIT=45] -->
    <string name="domain_urls_summary_some">Open <xliff:g id="domain" example="mail.google.com">%s</xliff:g> and other URLs</string>

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

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

    <!-- Explanation that the app that will ALWAYS be launched to open web links to domains that it understands -->
    <string name="app_link_open_always">Open in this app</string>

    <!-- Explanation that the user will be asked whether to launch the app to open web links to domains that it understands -->
    <string name="app_link_open_ask">Ask every time</string>

    <!-- Explanation that the app that will NEVER be launched to open web links to domains that it understands -->
    <string name="app_link_open_never">Don&#8217;t open in this app</string>

    <!-- Fingerprint hint message when finger was not recognized.-->
    <string name="fingerprint_not_recognized">Not recognized</string>

    <!-- Title for Default Apps settings [CHAR LIMIT=30] -->
    <string name="default_apps_title">Default</string>

    <!-- Title for Default Apps settings for work [CHAR LIMIT=30] -->
    <string name="default_for_work">Default for work</string>

    <!-- Title for Assist and voice input settings [CHAR LIMIT=30] -->
    <string name="assist_and_voice_input_title">Assist &amp; voice input</string>

    <!-- Title for Default Assist settings [CHAR LIMIT=30] -->
    <string name="default_assist_title">Assist app</string>

    <!-- [CHAR_LIMIT=45] Title of the security warning dialog for setting an assitant -->
    <string name="assistant_security_warning_title">
        Make <xliff:g id="assistant_app_name">%s</xliff:g> your assistant?
    </string>

    <!-- [CHAR_LIMIT=NONE] Warning message about security implications of setting an assistant,
         displayed as a dialog message when the user selects an assistant. -->
    <string name="assistant_security_warning">The assistant will be able to read information about
        apps in use on your system, including information visible on your screen or accessible
        within the apps.</string>

    <!-- Label for the button to acknowledge assistant security implications. [CHAR LIMIT=30] -->
    <string name="assistant_security_warning_agree">Agree</string>

    <!-- Label for the button to bail out assistant security implications. [CHAR LIMIT=30] -->
    <string name="assistant_security_warning_disagree">Disagree</string>

    <!-- Title for Choose voice input dialog [CHAR LIMIT=30] -->
    <string name="choose_voice_input_title">Choose voice input</string>

    <!-- Title for Default Browser settings [CHAR LIMIT=30] -->
    <string name="default_browser_title">Browser app</string>

    <!-- Summary for No Default Browser settings [CHAR LIMIT=45] -->
    <string name="default_browser_title_none">No default Browser</string>

    <!--  Title for Default Phone app settings [CHAR LIMIT=30] -->
    <string name="default_phone_title">Phone app</string>

    <!-- Label of default app for current setting [CHAR LIMIT=40] -->
    <string name="default_app">(Default)</string>

    <!-- Label of system app for current setting -->
    <string name="system_app">(System)</string>

    <!-- Label of system and default app for current setting -->
    <string name="system_default_app">(System default)</string>

    <!-- Title of app storage screen [CHAR LIMIT=30] -->
    <string name="apps_storage">Apps storage</string>

    <!-- Title of usage access screen [CHAR LIMIT=30] -->
    <string name="usage_access">Usage access</string>

    <!-- Label for setting which controls whether app has usage access [CHAR LIMIT=45] -->
    <string name="permit_usage_access">Permit usage access</string>

    <!-- Link to the apps page for app usage settings [CHAR LIMIT=45] -->
    <string name="app_usage_preference">App usage preferences</string>

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

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

    <!-- Title for screen showing recent memory usage of device [CHAR LIMIT=30]-->
    <string name="memory_settings_title">Memory</string>

    <!-- Title for screen showing recent memory usage of specific app [CHAR LIMIT=30]-->
    <string name="memory_details_title">Memory details</string>

    <!-- Description of app always running [CHAR LIMIT=45] -->
    <string name="always_running">Always running (<xliff:g id="percentage" example="5%">%s</xliff:g>)</string>

    <!-- Description of app sometimes running [CHAR LIMIT=45] -->
    <string name="sometimes_running">Sometimes running (<xliff:g id="percentage" example="5%">%s</xliff:g>)</string>

    <!-- Description of app rarely running [CHAR LIMIT=45] -->
    <string name="rarely_running">Rarely running (<xliff:g id="percentage" example="5%">%s</xliff:g>)</string>

    <!-- Maximum memory usage key [CHAR LIMIT=25] -->
    <string name="memory_max_use">Maximum</string>

    <!-- Average memory usage key [CHAR LIMIT=25] -->
    <string name="memory_avg_use">Average</string>

    <!-- Maximum memory used by an app [CHAR LIMIT=25] -->
    <string name="memory_max_desc">Maximum <xliff:g id="memory" example="30MB">%1$s</xliff:g></string>

    <!-- Average memory used by an app [CHAR LIMIT=25] -->
    <string name="memory_avg_desc">Average <xliff:g id="memory" example="30MB">%1$s</xliff:g></string>

    <!-- Formatting for memory description [CHAR LIMIT=25] -->
    <string name="memory_use_running_format"><xliff:g id="memory" example="30MB">%1$s</xliff:g> / <xliff:g id="running" example="Always running">%2$s</xliff:g></string>

    <!-- Label for process [CHAR LIMIT=25] -->
    <string name="process_format"><xliff:g id="app_name" example="Settings">%1$s</xliff:g> (<xliff:g id="count" example="3">%2$d</xliff:g>)</string>

    <!-- Label for list to control apps that ignore battery saving restrictions [CHAR LIMIT=27]-->
    <string name="high_power_apps">Battery optimization</string>

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

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

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

    <!-- Title for high usage item, which means power high usage [CHAR LIMIT=30] -->
    <string name="power_high_usage_title">High usage</string>

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

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

    <!-- Filter for apps allowed to use a lot of power [CHAR LIMIT=25] -->
    <string name="high_power_filter_on">Not optimized</string>

    <!-- Summary of app allowed to use a lot of power [CHAR LIMIT=60] -->
    <string name="high_power_on">Not optimized</string>

    <!-- Summary of app not allowed to use a lot of power [CHAR LIMIT=60] -->
    <string name="high_power_off">Optimizing battery use</string>

    <!-- Summary of app which doesn't have a battery optimization setting [CHAR LIMIT=60] -->
    <string name="high_power_system">Battery optimization not available</string>

    <!-- Description of high power switch [CHAR LIMIT=NONE] -->
    <string name="high_power_desc">Don\u2019t apply battery optimization. May drain your battery more quickly.</string>

    <!-- Title of prompt dialog app can invoke to turn off optimization [CHAR LIMIT=NONE] -->
    <string name="high_power_prompt_title">Let app always run in background?</string>

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

    <!-- Title of a group of settings that let you manage settings that affect battery life [CHAR LIMIT=60] -->
    <string name="battery_power_management">Power management</string>

    <!-- Summary for app with no battery usage [CHAR LIMIT=NONE] -->
    <string name="no_battery_summary">No battery use since last full charge</string>

    <!-- Link to an apps notification settings [CHAR LIMIT=50] -->
    <string name="app_notification_preferences">App settings</string>

    <!-- Turn on settings for system ui tuner [CHAR LIMIT=40] -->
    <string name="system_ui_settings">Show SystemUI Tuner</string>

    <!-- Label for button that leads to more permissions [CHAR LIMIT=40] -->
    <string name="additional_permissions">Additional permissions</string>

    <!-- Description of how many more permissions to view on next page [CHAR LIMIT=30] -->
    <string name="additional_permissions_more"><xliff:g id="count" example="2">%1$d</xliff:g> more</string>

    <!-- Title of dialog shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator. -->
    <string name="share_remote_bugreport_dialog_title">Share bug report?</string>
    <!-- Message of a dialog shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator. -->
    <string name="share_remote_bugreport_dialog_message_finished">Your IT admin requested a bug report to help troubleshoot this device. Apps and data may be shared.</string>
    <!-- Message of a dialog shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator and it's still being taken. -->
    <string name="share_remote_bugreport_dialog_message">Your IT admin requested a bug report to help troubleshoot this device. Apps and data may be shared, and your device may temporarily slow down.</string>
    <!-- Message of a dialog shown to inform that the remote bugreport that was requested remotely by the IT administrator is still being taken and will be shared when finished. -->
    <string name="sharing_remote_bugreport_dialog_message">This bug report is being shared with your IT admin. Contact them for more details.</string>
    <!-- Acceptance label of dialog shown to ask for user consent for sharing the remote bugreport. -->
    <string name="share_remote_bugreport_action">Share</string>
    <!-- Decline label of dialog shown to ask for user consent for sharing the remote bugreport. -->
    <string name="decline_remote_bugreport_action">Decline</string>

    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for charging only. -->
    <string name="usb_use_charging_only">No data transfer</string>
    <!-- Decription of one of the choices in a dialog (with title defined in usb_use) that lets the
         user select what the USB connection for this device should be used for. This choice
         is for charging only. -->
    <string name="usb_use_charging_only_desc">Just charge this device</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for powering the other device only. -->
    <string name="usb_use_power_only">Charge connected device</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring files via MTP. -->
    <string name="usb_use_file_transfers">File Transfer</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring files via MTP. -->
    <string name="usb_use_file_transfers_desc">Transfer files to another device</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring photos via PTP. -->
    <string name="usb_use_photo_transfers">PTP</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for transferring photos via PTP. -->
    <string name="usb_use_photo_transfers_desc">Transfer photos or files if MTP is not supported (PTP)</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for USB tethering. -->
    <string name="usb_use_tethering">USB tethering</string>
    <!-- Title of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for entering MIDI mode. -->
    <string name="usb_use_MIDI">MIDI</string>
    <!-- Description of one of the choices in a dialog (with title defined in usb_use) that lets the user
         select what the USB connection for this device should be used for. This choice
         is for entering MIDI mode. -->
    <string name="usb_use_MIDI_desc">Use this device as MIDI</string>
    <!-- The title used in a dialog which lets the user select what the USB connection
         for this device should be used for. These options are more commonly used.
         Choices are usb_use_file_transfer.-->
    <string name="usb_use">Use USB for</string>
    <!-- The label that leads to the Default USB configuration window. -->
    <string name="usb_default_label">Default USB configuration</string>
    <!-- Description at the footer of the default USB configuration window that describes how the setting works. -->
    <string name="usb_default_info">When another device is connected and your phone is unlocked, these settings will be applied. Only connect to trusted devices.</string>

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

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

    <!-- Settings item summary for USB preference when set to charging only [CHAR LIMIT=NONE] -->
    <string name="usb_summary_charging_only">Charging this device</string>
    <!-- Settings item summary for USB preference when set to powering the other device only [CHAR LIMIT=NONE] -->
    <string name="usb_summary_power_only">Charging connected device</string>
    <!-- Settings item summary for USB preference when set to transferring files via MTP [CHAR LIMIT=NONE] -->
    <string name="usb_summary_file_transfers">File transfer</string>
    <!-- Settings item summary for USB preference when set to USB tethering [CHAR LIMIT=NONE] -->
    <string name="usb_summary_tether">USB tethering</string>
    <!-- Settings item summary for USB preference when set to transferring photos via PTP [CHAR LIMIT=NONE] -->
    <string name="usb_summary_photo_transfers">PTP</string>
    <!-- Settings item summary for USB preference when set to entering MIDI mode [CHAR LIMIT=NONE] -->
    <string name="usb_summary_MIDI">MIDI</string>
    <!-- Settings item summary for USB preference when set to transferring files via MTP
          and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_file_transfers_power">File transfer and supplying power</string>
    <!-- Settings item summary for USB preference when set to USB tethering
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_tether_power">USB tethering and supplying power</string>
    <!-- Settings item summary for USB preference when set to transferring photos via PTP
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_photo_transfers_power">PTP and supplying power</string>
    <!-- Settings item summary for USB preference when set to entering MIDI mode
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_MIDI_power">MIDI and supplying power</string>

    <!-- Settings item title for background check prefs [CHAR LIMIT=35] -->
    <string name="background_check_pref">Background check</string>

    <!-- Settings screen title for background check prefs [CHAR LIMIT=35] -->
    <string name="background_check_title">Full background access</string>

    <!-- Title for the "context" preference to determine whether assist can access the data currently displayed on-screen [CHAR LIMIT=40] -->
    <string name="assist_access_context_title">Use text from screen</string>

    <!-- Summary for the "context" preference to determine whether assist can access the data currently displayed on-screen [CHAR LIMIT=NONE] -->
    <string name="assist_access_context_summary">Allow the assist app to access the screen contents as text</string>

    <!-- Title for the "screenshot" preference to determine whether assist can access the screenshot of your screen [CHAR LIMIT=40] -->
    <string name="assist_access_screenshot_title">Use screenshot</string>

    <!-- Summary for the "screenshot" preference to determine whether assist can access the screenshot of your screen [CHAR LIMIT=NONE] -->
    <string name="assist_access_screenshot_summary">Allow the assist app to access an image of the screen</string>

    <!-- Title for the "flash" preference to determine whether a flash is shown on screen when an assistant accesses the contents of the screeen. [CHAR LIMIT=40] -->
    <string name="assist_flash_title">Flash screen</string>

    <!-- Summary for the "flash" preference to determine whether a flash is shown on screen when an assistant accesses the contents of the screeen. [CHAR LIMIT=NONE] -->
    <string name="assist_flash_summary">Flash edges of screen when assist app accesses text from screen or screenshot</string>

    <!-- Footer text in the manage assist screen. [CHAR LIMIT=NONE] -->
    <string name="assist_footer">Assist apps can help you based on information from the screen you\u2019re viewing. Some apps support both launcher and voice input services to give you integrated assistance.</string>

    <!-- Label for average memory use section [CHAR LIMIT=30] -->
    <string name="average_memory_use">Average memory use</string>

    <!-- Label for maximum memory use section [CHAR LIMIT=30] -->
    <string name="maximum_memory_use">Maximum memory use</string>

    <!-- Label for app list of memory use [CHAR LIMIT=30] -->
    <string name="memory_usage">Memory usage</string>

    <!-- Label for app list of memory use [CHAR LIMIT=30] -->
    <string name="app_list_memory_use">App usage</string>

    <!-- Label for details about an app's memory use [CHAR LIMIT=30] -->
    <string name="memory_details">Details</string>

    <!-- Summary for how much memory an app has used [CHAR LIMIT=NONE] -->
    <string name="memory_use_summary"><xliff:g id="size" example="30MB">%1$s</xliff:g> avg memory used in last 3 hours</string>

    <!-- Summary for no memory use for an app [CHAR LIMIT=NONE] -->
    <string name="no_memory_use_summary">No memory used in last 3 hours</string>

    <!-- Menu item for Sorting list by average memory use [CHAR LIMIT=NONE]-->
    <string name="sort_avg_use">Sort by avg use</string>

    <!-- Menu item for Sorting list by maximum memory use [CHAR LIMIT=NONE] -->
    <string name="sort_max_use">Sort by max use</string>

    <!-- Label for the current performance of the device [CHAR LIMIT=25] -->
    <string name="memory_performance">Performance</string>

    <!-- Label for total memory of device [CHAR LIMIT=25] -->
    <string name="total_memory">Total memory</string>

    <!-- Label for average memory usage of device [CHAR LIMIT=25] -->
    <string name="average_used">Average used (&#x0025;)</string>

    <!-- Label for free memory of device [CHAR LIMIT=25] -->
    <string name="free_memory">Free</string>

    <!-- Label for button that leads to list of apps and their memory usage [CHAR LIMIT=40]-->
    <string name="memory_usage_apps">Memory used by apps</string>

    <!-- Description of number of apps using memory [CHAR LIMIT=NONE] -->
    <plurals name="memory_usage_apps_summary">
        <item quantity="one">1 app used memory in the last <xliff:g id="duration" example="3 hours">%2$s</xliff:g></item>
        <item quantity="other"><xliff:g id="count" example="10">%1$d</xliff:g> apps used memory in the last <xliff:g id="duration" example="3 hours">%2$s</xliff:g></item>
    </plurals>

    <!-- Label for frequency that the app is runnig (e.g. always, sometimes, etc.) [CHAR LIMIT=25] -->
    <string name="running_frequency">Frequency</string>

    <!-- Label for maximum amount of memory app has used [CHAR LIMIT=25] -->
    <string name="memory_maximum_usage">Maximum usage</string>

    <!-- Summary of data item when no data usage [CHAR LIMIT=40] -->
    <string name="no_data_usage">No data used</string>

    <!-- Zen mode access settings - title for warning dialog when enabling access [CHAR LIMIT=NONE] -->
    <string name="zen_access_warning_dialog_title">Allow access to Do Not Disturb for <xliff:g id="app" example="Tasker">%1$s</xliff:g>?</string>

    <!-- Zen mode access settings - summary for warning dialog when enabling access [CHAR LIMIT=NONE] -->
    <string name="zen_access_warning_dialog_summary">The app will be able to turn on/off Do Not Disturb and make changes to related settings.</string>

    <string name="zen_access_disabled_package_warning">Must stay turned on because notification access is on</string>

    <!-- Zen mode access settings - title for warning dialog when revoking access [CHAR LIMIT=NONE] -->
    <string name="zen_access_revoke_warning_dialog_title">Revoke access to Do Not Disturb for <xliff:g id="app" example="Tasker">%1$s</xliff:g>?</string>

    <!-- Zen mode access settings - summary for warning dialog when revoking access [CHAR LIMIT=NONE] -->
    <string name="zen_access_revoke_warning_dialog_summary">All Do Not Disturb rules created by this app will be removed.</string>

    <!-- Ignore battery optimizations on label [CHAR LIMIT=30] -->
    <string name="ignore_optimizations_on">Don\u2019t optimize</string>

    <!-- Ignore battery optimizations off label [CHAR LIMIT=30] -->
    <string name="ignore_optimizations_off">Optimize</string>

    <!-- Ignore battery optimizations on description [CHAR LIMIT=NONE] -->
    <string name="ignore_optimizations_on_desc">May drain your battery more quickly. App will no longer be restricted from using background battery.</string>

    <!-- Ignore battery optimizations off description [CHAR LIMIT=NONE] -->
    <string name="ignore_optimizations_off_desc">Recommended for better battery life</string>

    <!-- Ignore battery optimizations dialog title [CHAR LIMIT=NONE] -->
    <string name="ignore_optimizations_title">Allow <xliff:g id="app" example="Tasker">%s</xliff:g> to ignore battery optimizations?</string>

    <!-- Label for None item in AppListPreference [CHAR LIMIT=40] -->
    <string name="app_list_preference_none">None</string>

    <!-- Warning message about disabling usage access on profile owner [CHAR LIMIT=NONE] -->
    <string name="work_profile_usage_access_warning">Turning off usage access for this app doesn\'t
        prevent your admin from tracking data usage for apps in your work profile</string>

    <!-- Number of characters used for lock screen text [CHAR LIMIT=NONE] -->
    <string name="accessibility_lock_screen_progress"><xliff:g id="count" example="1">%1$d</xliff:g> of <xliff:g id="count" example="1">%2$d</xliff:g> characters used</string>

    <!-- System Alert Window settings -->
    <!-- Title of display overlay screen [CHAR LIMIT=30] -->
    <string name="draw_overlay">Display over other apps</string>
    <!-- Settings title in main settings screen for SYSTEM_ALERT_WINDOW [CHAR LIMIT=45] -->
    <string name="system_alert_window_settings">Display over other apps</string>
    <!-- Title for the apps with SYSTEM_ALERT_WINDOW permission/privilege [CHAR LIMIT=20] -->
    <string name="system_alert_window_apps_title">Apps</string>
    <!-- Title for the apps that are allowed to display over other apps [CHAR LIMIT=60] -->
    <string name="system_alert_window_access_title">Display over other apps</string>
    <!-- Label for setting which controls whether app can display over other apps [CHAR LIMIT=45] -->
    <string name="permit_draw_overlay">Allow display over other apps</string>
    <!-- Description of allowing overlay setting [CHAR LIMIT=NONE] -->
    <string name="allow_overlay_description">Allow this app to display on top of other apps you\u2019re using. It may interfere with your use of those apps or change the way they seem to appear or behave.</string>

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

    <!-- Summary of number of apps currently can display over other apps [CHAR LIMIT=60] -->
    <string name="system_alert_window_summary"><xliff:g id="count" example="10">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$d</xliff:g> apps allowed to display over other apps</string>

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

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

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

    <!-- Keywords for setting screen for controlling apps that can install other apps on device -->
    <string name="keywords_install_other_apps">install apps unknown sources</string>

    <!-- Write Settings settings -->
    <!-- Settings title in main settings screen for WRITE_SETTINGS [CHAR LIMIT=30] -->
    <string name="write_settings">Modify system settings</string>
    <!-- Keyword for WRITE_SETTINGS -->
    <string name="keywords_write_settings">write modify system settings</string>
    <!-- Summary of number of apps currently can write system settings [CHAR LIMIT=60] -->
    <string name="write_settings_summary"><xliff:g id="count" example="10">%1$d</xliff:g> of <xliff:g id="count" example="10">%2$d</xliff:g> apps allowed to modify system settings</string>

    <!-- Label for showing apps that can install other apps [CHAR LIMIT=45] -->
    <string name="filter_install_sources_apps">Can install other apps</string>
    <!-- Label for showing apps that can write system settings [CHAR LIMIT=45] -->
    <string name="filter_write_settings_apps">Can modify system settings</string>
    <!-- Title for the apps that are allowed to write system settings [CHAR LIMIT=60] -->
    <string name="write_settings_title">Can modify system settings</string>
    <!-- Main settings screen item's title to go into the write system settings screen [CHAR LIMIT=30] -->
    <string name="write_system_settings">Modify system settings</string>
    <!-- Label for setting which controls whether app can write system settings [CHAR LIMIT=45] -->
    <string name="permit_write_settings">Allow modifying system settings</string>
    <!-- Description of the write system settings [CHAR LIMIT=NONE] -->
    <string name="write_settings_description">This permission allows an app to modify system settings.</string>
    <!-- Summary of app allowed to write system settings [CHAR LIMIT=45] -->
    <string name="write_settings_on">Yes</string>
    <!-- Summary of app not allowed to write system settings [CHAR LIMIT=45] -->
    <string name="write_settings_off">No</string>
    <!-- Title of switch preference that controls whether an external app source is trusted or not [CHAR LIMIT=50] -->
    <string name="external_source_switch_title">Allow from this source</string>

    <!-- Title of setting that controls gesture to open camera [CHAR LIMIT=40] -->
    <string name="camera_gesture_title">Double twist for camera</string>

    <!-- Description of setting that controls gesture to open camera [CHAR LIMIT=NONE] -->
    <string name="camera_gesture_desc">Open the camera app by twisting your wrist twice</string>

    <!-- Title of setting that controls gesture to open camera by double tapping the power button [CHAR LIMIT=40] -->
    <string name="camera_double_tap_power_gesture_title">Press power button twice for camera</string>

    <!-- Description of setting that controls gesture to open camera by double tapping the power button [CHAR LIMIT=NONE] -->
    <string name="camera_double_tap_power_gesture_desc">Quickly open camera without unlocking your screen</string>

    <!-- Title of setting that controls screen zoom (e.g. how large interface elements appear). [CHAR LIMIT=40] -->
    <string name="screen_zoom_title">Display size</string>
    <!-- Short summary for Magnification gesture. Lets the user know that this makes items on screen larger or smaller. Appears in the accessibility portion of Setup Wizard. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_short_summary">Make items on screen larger or smaller</string>
    <!-- Keywords for setting that controls screen zoom (e.g. how large interface elements appear). [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_keywords">display density, screen zoom, scale, scaling</string>
    <!-- Summary of screen zoom setting screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_summary">Make the items on your screen smaller or larger. Some apps on your screen may change position.</string>
    <!-- Title of the screen zoom preview activity. -->
    <string name="screen_zoom_preview_title">Preview</string>
    <!-- Description for the button that makes interface elements smaller. [CHAR_LIMIT=NONE] -->
    <string name="screen_zoom_make_smaller_desc">Make smaller</string>
    <!-- Description for the button that makes interface elements larger. [CHAR_LIMIT=NONE] -->
    <string name="screen_zoom_make_larger_desc">Make larger</string>

    <!-- Name Initial shown in the conversation message icon. [CHAR LIMIT=1] -->
    <string name="screen_zoom_conversation_icon_alex">A</string>
    <!-- Name Initial shown in the conversation message icon. [CHAR LIMIT=1] -->
    <string name="screen_zoom_conversation_icon_pete">P</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_1">Hi Pete!</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_2">Hey, want to grab coffee and catch up today?</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_3">Sounds great. I know of a good place not too far from here.</string>
    <!-- Conversation message body of the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="screen_zoom_conversation_message_4">Perfect!</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_1">Tue 6:00PM</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_2">Tue 6:01PM</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_3">Tue 6:02PM</string>
    <!-- Conversation message timestamp of the messaging app preview screen. [CHAR LIMIT=20] -->
    <string name="screen_zoom_conversation_timestamp_4">Tue 6:03PM</string>

    <!-- Wi-Fi state - Disconnected [CHAR LIMIT=NONE] -->
    <string name="disconnected">Not connected</string>

    <!-- Summary of data usage [CHAR LIMIT=NONE] -->
    <string name="data_usage_summary_format"><xliff:g id="amount" example="50%">%1$s</xliff:g> of data used</string>

    <!-- Summary of data usage [CHAR LIMIT=NONE] -->
    <string name="data_usage_wifi_format"><xliff:g id="amount" example="50%">^1</xliff:g> used on Wi\u2011Fi</string>

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

    <!-- Summary of notifications when no apps are blocked [CHAR LIMIT=NONE] -->
    <string name="notification_summary_none">On for all apps</string>

    <!-- Summary of apps [CHAR LIMIT=NONE] -->
    <string name="apps_summary"><xliff:g id="count" example="24">%1$d</xliff:g> apps installed</string>
    <!-- Example summary of apps used in Setup Wizard preview screen [CHAR LIMIT=NONE] -->
    <string name="apps_summary_example">24 apps installed</string>

    <!-- Summary of storage usage [CHAR LIMIT=NONE] -->
    <string name="storage_summary"><xliff:g id="percentage" example="54%">%1$s</xliff:g> used - <xliff:g id="free_space" example="32GB">%2$s</xliff:g> free</string>

    <!-- Summary of storage usage when there is SD card [CHAR LIMIT=NONE] -->
    <string name="storage_summary_with_sdcard">Internal storage: <xliff:g id="percentage" example="54%">%1$s</xliff:g> used - <xliff:g id="free_space" example="32GB">%2$s</xliff:g> free</string>

    <!-- Summary of display with screen sleep timeout [CHAR LIMIT=NONE] -->
    <string name="display_summary">Sleep after <xliff:g id="timeout_description" example="10 minutes">%1$s</xliff:g> of inactivity</string>
    <!-- Summary for Display settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="display_dashboard_summary">Wallpaper, sleep, font size</string>
    <!-- Example summary of display used in Setup Wizard preview screen [CHAR LIMIT=NONE] -->
    <string name="display_summary_example">Sleep after 10 minutes of inactivity</string>

    <!-- Summary of memory screen [CHAR LIMIT=NONE] -->
    <string name="memory_summary">Avg <xliff:g id="used_memory" example="1.7GB">%1$s</xliff:g> of <xliff:g id="total_memory" example="2GB">%2$s</xliff:g> memory used</string>

    <!-- Summary of User settings [CHAR LIMIT=NONE] -->
    <string name="users_summary">Signed in as <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>

    <!-- Summary of payment screen [CHAR LIMIT=NONE] -->
    <string name="payment_summary"><xliff:g id="app_name" example="Payment App">%1$s</xliff:g> is default</string>

    <!-- Summary of location on screen [CHAR LIMIT=NONE] -->
    <string name="location_on_summary">On</string>

    <!-- Location off [CHAR LIMIT=NONE] -->
    <string name="location_off_summary">Off</string>

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

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

    <!-- Title for dialog displayed when user selects on a setting locked by an admin [CHAR LIMIT=30 BACKUP_MESSAGE_ID:4867639270211833535] -->
    <string name="disabled_by_policy_title">Action not allowed</string>
    <!-- Title for dialog displayed to tell user that changing volume was disallowed by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_adjust_volume">Can’t change volume</string>
    <!-- Title for dialog displayed to tell user that outgoing calls were disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_outgoing_calls">Calling not allowed</string>
    <!-- Title for dialog displayed to tell user that sending SMS were disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_sms">SMS not allowed</string>
    <!-- Title for dialog displayed to tell user that the camera was disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_camera">Camera not allowed</string>
    <!-- Title for dialog displayed to tell user that screenshots are disabled by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_screen_capture">Screenshot not allowed</string>
    <!-- Title for dialog displayed to tell user that turning off backups is disallowed by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_turn_off_backups">Can’t turn off backups</string>
    <!-- Title for dialog displayed to tell user that the app was suspended by an admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_suspend_packages">Can’t open this app</string>
    <!-- Shown when the user tries to change a settings locked by an admin [CHAR LIMIT=200] -->
    <string name="default_admin_support_msg">If you have questions, contact your IT admin</string>
    <!-- Shown in dialog to allow user to see more information about the device admin [CHAR LIMIT=30] -->
    <string name="admin_support_more_info">More details</string>
    <!-- Shown in admin details page to warn user about policies the admin can set in a work profile. [CHAR LIMIT=NONE] -->
    <string name="admin_profile_owner_message">Your admin can monitor and manage apps and data
        associated with your work profile, including settings, permissions, corporate access,
        network activity, and the device\'s location information.</string>
    <!-- Shown in admin details page to warn user about policies the admin can set on a user. [CHAR LIMIT=NONE] -->
    <string name="admin_profile_owner_user_message">Your admin can monitor and manage apps and data
        associated with this user, including settings, permissions, corporate access,
        network activity, and the device\'s location information.</string>
    <!-- Shown in admin details page to warn user about policies the admin can set on a device. [CHAR LIMIT=NONE] -->
    <string name="admin_device_owner_message">Your admin can monitor and manage apps and data
        associated with this device, including settings, permissions, corporate access,
        network activity, and the device\'s location information.</string>

    <!-- Turn off a conditional state of the device (e.g. airplane mode, or hotspot) [CHAR LIMIT=30] -->
    <string name="condition_turn_off">Turn off</string>

    <!-- Turn on a conditional state of the device (e.g. cellular data) [CHAR LIMIT=30] -->
    <string name="condition_turn_on">Turn on</string>

    <!-- Content description used when expanding a condition item to see more details -->
    <string name="condition_expand_show">Show</string>

    <!-- Content description used when collapsing a condition item to see less details -->
    <string name="condition_expand_hide">Hide</string>

    <!-- Title of condition that hotspot is on [CHAR LIMIT=30] -->
    <string name="condition_hotspot_title">Hotspot is on</string>

    <!-- Summary of condition that hotspot is on [CHAR LIMIT=NONE] -->
    <string name="condition_hotspot_summary">Portable Wi-Fi hotspot <xliff:g name="ap_name" example="AndroidAP">%1$s</xliff:g> is active, Wi-Fi for this device is turned off.</string>

    <!-- Title of condition that airplane mode is on [CHAR LIMIT=30] -->
    <string name="condition_airplane_title">Airplane mode is on</string>

    <!-- Summary of condition that airplane mode is on [CHAR LIMIT=NONE] -->
    <string name="condition_airplane_summary">When airplane mode is turned on, Wi\u2011Fi, Bluetooth, and mobile network are turned off. Wi\u2011Fi and Bluetooth can be turned back on.</string>

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

    <!-- Title of condition that battery saver is on [CHAR LIMIT=30] -->
    <string name="condition_battery_title">Battery Saver is on</string>

    <!-- Summary of condition that battery saver is on [CHAR LIMIT=NONE] -->
    <string name="condition_battery_summary">Battery Saver turns off some device features and restricts apps</string>

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

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

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

    <!-- Summary of condition that background data is off [CHAR LIMIT=NONE] -->
    <string name="condition_bg_data_summary">Background data is only available via Wi-Fi. This may affect some apps or services when Wi-Fi is not available.</string>

    <!-- Title of condition that work mode is off [CHAR LIMIT=30] -->
    <string name="condition_work_title">Work profile is off</string>

    <!-- Summary of condition that work mode is off [CHAR LIMIT=NONE] -->
    <string name="condition_work_summary">Apps, background sync, and other features related to your work profile are turned off.</string>

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

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

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

    <!-- Summary of condition that indicates device is muted -->
    <string name="condition_device_muted_summary">Calls and notifications will be muted</string>

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

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

    <!-- Summary of condition that indicates device is set to vibrate -->
    <string name="condition_device_vibrate_summary" product="tablet">Calls and notifications will vibrate device</string>

    <!-- Summary of condition that indicates device is set to vibrate -->
    <string name="condition_device_vibrate_summary" product="default">Calls and notifications will vibrate phone</string>

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

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

    <!-- Title of condition that night display is on (renamed "Night Light" with title caps). [CHAR LIMIT=30] -->
    <string name="condition_night_display_title">Night Light is on</string>

    <!-- Summary of condition that night display is on (renamed "Night Light" with title caps). [CHAR LIMIT=NONE] -->
    <string name="condition_night_display_summary">Screen is tinted amber. This may help you fall asleep.</string>

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

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

    <!-- Title for the suggestions section on the dashboard [CHAR LIMIT=30] -->
    <string name="suggestions_title">Suggestions</string>

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

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

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

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

    <!-- Name of option to remove a suggestion from the list [CHAR LIMIT=30] -->
    <string name="suggestion_remove">Remove</string>

    <!-- Name of the setting to change the display's color temperature -->
    <string name="color_temperature">Cool color temperature</string>

    <!-- Description of the setting to change the display's color temperature -->
    <string name="color_temperature_desc">Use cooler display colors</string>

    <!-- Toast message letting the user know the color temperature setting is not immediate -->
    <string name="color_temperature_toast">To apply color change, turn off screen</string>

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

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

    <!-- Summary for the setting to disable the automatic update -->
    <string name="ota_disable_automatic_update_summary">Apply updates when device restarts</string>

    <!-- Label for category for data usage [CHAR LIMIT=30] -->
    <string name="usage">Usage</string>

    <!-- Label for cellular data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="cellular_data_usage">Mobile data usage</string>

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

    <!-- Label for wifi data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="wifi_data_usage">Wi\u2011Fi data usage</string>

    <!-- Label for ethernet data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="ethernet_data_usage">Ethernet data usage</string>

    <!-- Label for section about wifi in data usage screen [CHAR LIMIT=60] -->
    <string name="wifi">Wi-Fi</string>

    <!-- Label for section about ethernet in data usage screen [CHAR LIMIT=60] -->
    <string name="ethernet">Ethernet</string>

    <!-- Format string for amount of cellular data used [CHAR LIMIT=30] -->
    <string name="cell_data_template"><xliff:g id="amount" example="1 GB">^1</xliff:g> mobile data</string>

    <!-- Format string for amount of wifi data used [CHAR LIMIT=30] -->
    <string name="wifi_data_template"><xliff:g id="amount" example="1 GB">^1</xliff:g> Wi-Fi data</string>

    <!-- Format string for amount of ethernet data used [CHAR LIMIT=30] -->
    <string name="ethernet_data_template"><xliff:g id="amount" example="1 GB">^1</xliff:g> ethernet data</string>

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

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

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

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

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

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

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

    <!-- Summary describing when the billing cycle for their phone carrier starts [CHAR LIMIT=NONE] -->
    <string name="billing_cycle_fragment_summary">Monthly on day <xliff:g name="day_of_month" example="17">%1$s</xliff:g></string>

    <!-- Title of button and screen for which wifi networks have data restrictions [CHAR LIMIT=30 -->
    <string name="network_restrictions">Network restrictions</string>

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

    <!-- A summary shown on data usage screens to indicate inaccuracy of data tracking [CHAR LIMIT=NONE] -->
    <string name="operator_warning">Carrier data accounting may differ from device accounting</string>

    <!-- Format string describing how much data has been used [CHAR LIMIT=20] -->
    <string name="data_used_template"><xliff:g name="amount" example="1 GB">%1$s</xliff:g> used</string>

    <!-- Label for switch about whether to warn user about usage [CHAR LIMIT=30] -->
    <string name="set_data_warning">Set data warning</string>

    <!-- Label for button to set the amount of data before user is warned about usage [CHAR LIMIT=30] -->
    <string name="data_warning">Data warning</string>

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

    <!-- Label for switch about whether to limit how much data can be used [CHAR LIMIT=30] -->
    <string name="set_data_limit">Set data limit</string>

    <!-- Label for button to set the amount of data before user is limited [CHAR LIMIT=30] -->
    <string name="data_limit">Data limit</string>

    <!-- Summary about how much data has been used in a date range [CHAR LIMIT=NONE] -->
    <string name="data_usage_template"><xliff:g name="amount" example="200 MB">%1$s</xliff:g> used <xliff:g name="date_range" example="Jan 1 -- Feb 2">%2$s</xliff:g></string>

    <!-- Accessibility label for button that leads to screen with more configuration options [CHAR LIMIT=NONE] -->
    <string name="configure">Configure</string>

    <!-- List of app names included in data usage on app data usage screen
         [CHAR LIMIT=50] -->
    <string name="data_usage_other_apps">Other apps included in usage</string>

    <!-- Description of number of apps allowed to ignore Data Saver [CHAR LIMIT=NONE] -->
    <plurals name="data_saver_unrestricted_summary">
        <item quantity="one">1 app allowed to use unrestricted data when Data Saver is on</item>
        <item quantity="other"><xliff:g id="count" example="10">%1$d</xliff:g> apps allowed to use unrestricted data when Data Saver is on</item>
    </plurals>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- Name of Data Saver screens [CHAR LIMIT=30] -->
    <string name="data_saver_title">Data Saver</string>

    <!-- Button that leads to list of apps with unrestricted data access [CHAR LIMIT=60] -->
    <string name="unrestricted_data_saver">Unrestricted data</string>

    <!-- Description of message shown when app is blacklisted for background data access [CHAR LIMIT=NONE] -->
    <string name="restrict_background_blacklisted">Background data is turned off</string>

    <!-- Summary for the Data Saver feature being on [CHAR LIMIT=NONE] -->
    <string name="data_saver_on">On</string>

    <!-- Summary for the Data Saver feature being off [CHAR LIMIT=NONE] -->
    <string name="data_saver_off">Off</string>

    <!-- Switch label to enable the Data Saver feature [CHAR LIMIT=NONE] -->
    <string name="data_saver_switch_title">Use Data Saver</string>

    <!-- Title for switch to allow app unrestricted data usage [CHAR LIMIT=30] -->
    <string name="unrestricted_app_title">Unrestricted data usage</string>

    <!-- Title for switch to allow app unrestricted data usage [CHAR LIMIT=30] -->
    <string name="unrestricted_app_summary">Allow unrestricted data access when Data Saver is on</string>

    <!-- Button to switch the default home app [CHAR LIMIT=60] -->
    <string name="home_app">Home app</string>

    <!-- No default home set summary [CHAR LIMIT=NONE] -->
    <string name="no_default_home">No default Home</string>

    <!-- Title of the preference controlling whether the device encryption password/PIN/Pattern must be entered before being able to start the device. [CHAR LIMIT=60]-->
    <string name="lockpattern_settings_require_cred_before_startup">Secure start-up</string>

    <!-- Summary of the preference controlling whether the device encryption *pattern* must be entered before being able to start the device. [CHAR LIMIT=NONE]-->
    <string name="lockpattern_settings_require_pattern_before_startup_summary">Require pattern to start up your device. While off, this device can\'t receive calls, messages, notifications, or alarms.</string>

    <!-- Summary of the preference controlling whether the device encryption *PIN* must be entered before being able to start the device. [CHAR LIMIT=NONE]-->
    <string name="lockpattern_settings_require_pin_before_startup_summary">Require PIN to start up your device. While off, this device can\'t receive calls, messages, notifications, or alarms.</string>

    <!-- Summary of the preference controlling whether the device encryption *password* must be entered before being able to start the device. [CHAR LIMIT=NONE]-->
    <string name="lockpattern_settings_require_password_before_startup_summary">Require password to start up your device. While off, this device can\'t receive calls, messages, notifications, or alarms.</string>

    <!-- Title for suggestion adding more fingerprints [CHAR LIMIT=46] -->
    <string name="suggestion_additional_fingerprints">Add another fingerprint</string>

    <!-- Summary for suggestion adding more fingerprints [CHAR LIMIT=55] -->
    <string name="suggestion_additional_fingerprints_summary">Unlock with a different finger</string>

    <!-- Summary of battery saver when on [CHAR LIMIT=NONE] -->
    <string name="battery_saver_on_summary">On</string>

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

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

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

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

    <!-- [CHAR_LIMIT=NONE] Label for when app is ignoring battery optimizations -->
    <string name="not_battery_optimizing">Not using battery optimization</string>

    <!-- Text for the setting on whether you can type text into notifications without unlocking the device. -->
    <string name="lockscreen_remote_input">If device is locked, prevent typing replies or other text in notifications</string>

    <string-array name="bytes_picker_sizes" translatable="false">
        <item>@*android:string/megabyteShort</item>
        <item>@*android:string/gigabyteShort</item>
    </string-array>

    <!-- [CHAR LIMIT=30] Label for setting to control the default spell checker -->
    <string name="default_spell_checker">Default spell checker</string>

    <!-- [CHAR LIMIT=30] Title for dialog for setting to control the default spell checker -->
    <string name="choose_spell_checker">Choose spell checker</string>

    <!-- [CHAR LIMIT=45] Title for the master switch for spell checker, turning off will disable entire spell check feature. -->
    <string name="spell_checker_master_switch_title">Use spell checker</string>

    <!-- [CHAR LIMIT=30] Label for the placeholder of the current spell checker name.  Used when no spell checker is currently selected. -->
    <string name="spell_checker_not_selected">Not selected</string>

    <!-- Notification log debug tool: missing title -->
    <string name="notification_log_no_title">(none)</string>
    <!-- Notification log debug tool: delimiter between header and field data -->
    <string name="notification_log_details_delimiter">": "</string>
    <!-- Notification log debug tool: header: package name -->
    <string name="notification_log_details_package">pkg</string>
    <!-- Notification log debug tool: header: notification key -->
    <string name="notification_log_details_key">key</string>
    <!-- Notification log debug tool: header: notification group -->
    <string name="notification_log_details_group">group</string>
    <!-- Notification log debug tool: header: notification group summary suffix -->
    <string name="notification_log_details_group_summary"> (summary)</string>
    <!-- Notification log debug tool: header: notification visibility -->
    <string name="notification_log_details_visibility">visibility</string>
    <!-- Notification log debug tool: header: notification public version -->
    <string name="notification_log_details_public_version">publicVersion</string>
    <!-- Notification log debug tool: header: notification priority -->
    <string name="notification_log_details_priority">priority</string>
    <!-- Notification log debug tool: header: notification importance -->
    <string name="notification_log_details_importance">importance</string>
    <!-- Notification log debug tool: header: notification importance explanation -->
    <string name="notification_log_details_explanation">explanation</string>
    <!-- Notification log debug tool: header: notification importance -->
    <string name="notification_log_details_badge">can show badge</string>
    <!-- Notification log debug tool: header: notification contentIntent field -->
    <string name="notification_log_details_content_intent">intent</string>
    <!-- Notification log debug tool: header: notification deleteIntent field -->
    <string name="notification_log_details_delete_intent">delete intent</string>
    <!-- Notification log debug tool: header: notification fullScreenIntent field -->
    <string name="notification_log_details_full_screen_intent">full screen intent</string>
    <!-- Notification log debug tool: header: notification actions list -->
    <string name="notification_log_details_actions">actions</string>
    <!-- Notification log debug tool: header: title -->
    <string name="notification_log_details_title">title</string>
    <!-- Notification log debug tool: header: notification action remoteinput -->
    <string name="notification_log_details_remoteinput">remote inputs</string>
    <!-- Notification log debug tool: header: notification contentView -->
    <string name="notification_log_details_content_view">custom view</string>
    <!-- Notification log debug tool: header: notification extras -->
    <string name="notification_log_details_extras">extras</string>
    <!-- Notification log debug tool: header: notification icon -->
    <string name="notification_log_details_icon">icon</string>
    <!-- Notification log debug tool: header: notification size -->
    <string name="notification_log_details_parcel">parcel size</string>
    <!-- Notification log debug tool: notification ashmem size -->
    <string name="notification_log_details_ashmem">ashmem</string>
    <!-- Notification log debug tool: header: notification sound info -->
    <string name="notification_log_details_sound">sound</string>
    <!-- Notification log debug tool: header: notification vibration info -->
    <string name="notification_log_details_vibrate">vibrate</string>
    <!-- Notification log debug tool: the word 'default' -->
    <string name="notification_log_details_default">default</string>
    <!-- Notification log debug tool: the word 'none' -->
    <string name="notification_log_details_none">none</string>
    <!-- Notification log debug tool: missing ranking information -->
    <string name="notification_log_details_ranking_null">Ranking object is missing.</string>
    <!-- Notification log debug tool: the word 'none' -->
    <string name="notification_log_details_ranking_none">Ranking object doesn\'t contain this key.</string>

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

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

    <!-- [CHAR_LIMIT=NONE] Developer Settings: Label for the option that turns off display cutout emulation, (i.e. on devices whose screen actually has a cutout, selecting this option will show that cutout).-->
    <string name="display_cutout_emulation_device_default">Device default</string>

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

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

    <!-- Developer option to convert to file encryption - final warning -->
    <string name="confirm_convert_to_fbe_warning">Really wipe user data and convert to file encryption?</string>
    <!-- Developer option to convert to file encryption - final button -->
    <string name="button_confirm_convert_fbe">Wipe and convert</string>

    <!-- Reset rate-limiting in the system service ShortcutManager.  "ShortcutManager" is the name of a system service and not translatable.
    If the word "rate-limit" is hard to translate, use "Reset ShortcutManager API call limit" as the source text, which means
    the same thing in this context.
     [CHAR_LIMIT=none] -->
    <string name="reset_shortcut_manager_throttling">Reset ShortcutManager rate-limiting</string>

    <!-- Toast message shown when "Reset ShortcutManager rate-limiting" has been performed. [CHAR_LIMIT=none] -->
    <string name="reset_shortcut_manager_throttling_complete">ShortcutManager rate-limiting has been reset</string>

    <!-- Title of notification suggestion during optional steps of setup. [CHAR_LIMIT=60] -->
    <string name="notification_suggestion_title">Control info on lock screen</string>
    <!-- Summary of notification suggestion during optional steps of setup. [CHAR_LIMIT=80] -->
    <string name="notification_suggestion_summary">Show or hide notification content</string>
    <!-- Setting tab title for all setting options. [CHAR LIMIT=20] -->
    <string name="page_tab_title_summary">All</string>
    <!-- Setting tab title for support setting options. [CHAR LIMIT=25] -->
    <string name="page_tab_title_support">Tips &amp; support</string>

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

    <!-- Title of developer options to set the smallest width of the screen [CHAR LIMIT=60]-->
    <string name="developer_smallest_width">Smallest width</string>

    <!-- Message shown when there are no premium SMS apps [CHAR LIMIT=NONE] -->
    <string name="premium_sms_none">No installed apps have requested Premium SMS access</string>

    <!-- Warning message shown between options to enable Premium SMS for an app [CHAR LIMIT=NONE] -->
    <string name="premium_sms_warning">Premium SMS may cost you money and will add up to your carrier bills. If you enable permission for an app, you will be able to send premium SMS using that app.</string>

    <!-- Title of screen controlling which apps have access to send premium SMS messages [CHAR LIMIT=60] -->
    <string name="premium_sms_access">Premium SMS access</string>

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

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

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

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

    <!-- [CHAR LIMIT=60] Name of dev option that changes the UI Mode -->
    <string name="dark_ui_mode">Night mode</string>

    <!-- [CHAR LIMIT=60] Name of dev option that changes the color of the UI -->
    <string name="dark_ui_mode_title">Set Night mode</string>

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

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

    <!-- Template for formatting country and language. eg Canada - French [CHAR LIMIT=NONE]-->
    <string name="support_country_format"><xliff:g id="country" example="Canada">%1$s</xliff:g> - <xliff:g id="language" example="French">%2$s</xliff:g></string>

    <!-- [CHAR LIMIT=60] Title of work profile setting page -->
    <string name="managed_profile_settings_title">Work profile settings</string>
    <!-- [CHAR LIMIT=60] The preference title for enabling cross-profile remote contact search -->
    <string name="managed_profile_contact_search_title">Contact search</string>
    <!-- [CHAR LIMIT=NONE] The preference summary for enabling cross-profile remote contact search -->
    <string name="managed_profile_contact_search_summary">Allow contact searches by your organization to identify callers and contacts</string>

    <!-- Time in hours -->
    <plurals name="hours">
        <item quantity="one">1 hour</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> hours</item>
    </plurals>

    <!-- Time in minutes -->
    <plurals name="minutes">
        <item quantity="one">1 minute</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> minutes</item>
    </plurals>

    <!-- Time in seconds -->
    <plurals name="seconds">
        <item quantity="one">1 second</item>
        <item quantity="other"><xliff:g id="number" example="7">%s</xliff:g> seconds</item>
    </plurals>

    <!-- Used as title on the automatic storage manager settings. [CHAR LIMIT=60] -->
    <string name="automatic_storage_manager_settings">Manage storage</string>

    <!-- Used as wall of text to describe the feature. [CHAR LIMIT=NONE] -->
    <string name="automatic_storage_manager_text">To help free up storage space, storage manager removes backed up photos and videos from your device.</string>

    <!-- Dropdown preference title for dropdown describing how many days of data to retain.-->
    <string name="automatic_storage_manager_days_title">Remove photos &amp; videos</string>

    <!-- Preference title for the automatic storage manager toggle. [CHAR LIMIT=60]-->
    <string name="automatic_storage_manager_preference_title">Storage manager</string>

    <!-- Used in the storage manager settings screen to control turning on/off the feature entirely -->
    <string name="automatic_storage_manager_master_switch_title">Use Storage manager</string>

    <!-- Category title for the automatic settings in the storage manager settings. [CHAR LIMIT=40] -->
    <string name="deletion_helper_automatic_title">Automatic</string>

    <!-- Category title for the manual settings in the storage manager settings. [CHAR LIMIT=40] -->
    <string name="deletion_helper_manual_title">Manual</string>

    <!-- Preference menu title for accessing the deletion helper from the storage manager settings. [CHAR LIMIT=30]-->
    <string name="deletion_helper_preference_title">Free up space now</string>

    <!-- Preference title for gesture settings [CHAR LIMIT=40 BACKUP_MESSAGE_ID:5280023307132819052]-->
    <string name="gesture_preference_title">Gestures</string>

    <!-- Preference summary for gesture settings (phone) [CHAR LIMIT=NONE]-->
    <string name="gesture_preference_summary" product="default">Quick gestures to control your phone</string>
    <!-- Preference summary for gesture settings (tablet) [CHAR LIMIT=NONE]-->
    <string name="gesture_preference_summary" product="tablet">Quick gestures to control your tablet</string>
    <!-- Preference summary for gesture settings (device) [CHAR LIMIT=NONE]-->
    <string name="gesture_preference_summary" product="device">Quick gestures to control your device</string>

    <!-- Title text for double tap power for camera [CHAR LIMIT=60]-->
    <string name="double_tap_power_for_camera_title">Jump to camera</string>

    <!-- Summary text for double tap power for camera [CHAR LIMIT=160]-->
    <string name="double_tap_power_for_camera_summary">To quickly open camera, press the power button twice. Works from any screen.</string>

    <!-- Title for settings suggestion for double tap power for camera [CHAR LIMIT=60] -->
    <string name="double_tap_power_for_camera_suggestion_title">Open camera quickly</string>

    <!-- Title text for double twist for camera mode [CHAR LIMIT=60]-->
    <string name="double_twist_for_camera_mode_title">Flip camera</string>

    <!-- Summary text for double twist for camera mode  [CHAR LIMIT=160]-->
    <string name="double_twist_for_camera_mode_summary"></string>

    <!-- Title for settings suggestion for double twist for camera [CHAR LIMIT=60] -->
    <string name="double_twist_for_camera_suggestion_title">Take selfies faster</string>

    <!-- Title text for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_title">Swipe up on Home button</string>
    <!-- Summary text for swipe up to switch apps  [CHAR LIMIT=250] -->
    <string name="swipe_up_to_switch_apps_summary">To switch apps, swipe up on the Home button. Swipe up again to see all apps. Works from any screen. You’ll no longer have an Overview button on the bottom right of your screen.</string>
    <!-- Title for settings suggestion for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_suggestion_title">Try the new Home button</string>
    <!-- Summary for settings suggestion for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_suggestion_summary">Turn on the new gesture to switch apps</string>

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

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

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

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

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

    <!-- Summary text for fingerprint swipe for notifications (phone) [CHAR LIMIT=160]-->
    <string name="fingerprint_swipe_for_notifications_summary" product="default">To check your notifications, swipe down on the fingerprint sensor on the back of your phone.</string>
    <!-- Summary text for fingerprint swipe for notifications (tablet) [CHAR LIMIT=160]-->
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet">To check your notifications, swipe down on the fingerprint sensor on the back of your tablet.</string>
    <!-- Summary text for fingerprint swipe for notifications (device) [CHAR LIMIT=160]-->
    <string name="fingerprint_swipe_for_notifications_summary" product="device">To check your notifications, swipe down on the fingerprint sensor on the back of your device.</string>

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

    <!-- Title text for the assist gesture [CHAR LIMIT=60] DO NOT TRANSLATE -->
    <string name="assist_gesture_title" translatable="false"></string>

    <!-- Switch text for each gesture setting state -->
    <string name="gesture_setting_on">On</string>
    <string name="gesture_setting_off">Off</string>

    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because the bootloader has been unlocked [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked">Bootloader is already unlocked</string>
    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because there is no connectivity. [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_connectivity">Connect to the internet first</string>
    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because there is no connectivity or the device is locked by the carrier [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked">Connect to the internet or contact your carrier</string>
    <!-- setting enable OEM unlock Checkbox's summary to explain this Checkbox is disabled because this setting is unavailable on sim-locked devices. [CHAR_LIMIT=60] -->
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device">Unavailable on carrier-locked devices</string>
    <!-- Information displayed after user locks OEM lock [Char Limit=None]-->
    <string name="oem_lock_info_message">Please restart the device to enable device protection feature.</string>
    <string name="automatic_storage_manager_freed_bytes"><xliff:g id="size" example="3.25MB">%1$s</xliff:g> total made available\n\nLast ran on <xliff:g id="date" example="Jan 12">%2$s</xliff:g></string>

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

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

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

    <!-- Preference label for an tappable preference that will open the instant apps settings. [CHAR LIMIT=60] -->
    <string name="instant_apps_settings">Instant Apps preferences</string>

    <!-- Section title for the Domain URL app preference list [CHAR LIMIT=60]-->
    <string name="domain_url_section_title">Installed apps</string>

    <!-- Warning when activating the automatic storage manager on legacy devices. [CHAR LIMIT=NONE] -->
    <string name="automatic_storage_manager_activation_warning">Your storage is now being managed by the storage manager</string>

    <!-- Accounts for section header [CHAR LIMIT=30] -->
    <string name="account_for_section_header">Accounts for <xliff:g id="user_name" example="Jason">%1$s</xliff:g></string>

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

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

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

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

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

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

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

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

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

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

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


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

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

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

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

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

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

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

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

    <!-- Name of setting for switching the SystemUI theme [CHAR LIMIT=60] -->
    <string name="device_theme">Device theme</string>
    <!-- When SystemUI theme is chosen based on the wallpaper color [CHAR LIMIT=60] -->
    <string name="systemui_theme_wallpaper">Automatic (based on wallpaper)</string>
    <!-- When SystemUI theme is light [CHAR LIMIT=60] -->
    <string name="systemui_theme_light">Light</string>
    <!-- When SystemUI theme is dark [CHAR LIMIT=60] -->
    <string name="systemui_theme_dark">Dark</string>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- Title label for new device suggestion, which is displayed in Settings homepage [CHAR LIMIT=100] -->
    <string name="new_device_suggestion_title">What\'s new and exciting?</string>

    <!-- Summary label for new device suggestion, which is displayed in Settings homepage [CHAR LIMIT=100] -->
    <string name="new_device_suggestion_summary" product="default">Take a tour of your new phone</string>

    <!-- Summary label for new device suggestion, which is displayed in Settings homepage [CHAR LIMIT=100] -->
    <string name="new_device_suggestion_summary" product="tablet">Take a tour of your new tablet</string>

    <!-- Summary label for new device suggestion, which is displayed in Settings homepage [CHAR LIMIT=100] -->
    <string name="new_device_suggestion_summary" product="device">Take a tour of your new device</string>

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

    <!-- Note displayed when certain features are not available on low ram devices. [CHAR LIMIT=NONE] -->
    <string name="disabled_low_ram_device">This feature is not available on this device</string>

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

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

    <!-- Title for Directory Access settings -->
    <string name="directory_access">Directory access</string>
    <!-- Keywords for Directory Access settings -->
    <string name="keywords_directory_access">directory access</string>

    <!-- String used to describe the name of a directory in a volume; it must
         show both names, with the directory name wrapped in parenthesis -->
    <string name="directory_on_volume"><xliff:g id="volume" example="SD Card">%1$s</xliff:g> (<xliff:g id="directory" example="Movies">%2$s</xliff:g>)</string>

    <!-- Slices Strings -->

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

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

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

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

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

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


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

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

    <!-- Settings item title for automatic Bluetooth on while driving preference [CHAR LIMIT=35] -->
    <string name="bluetooth_on_while_driving_pref">Use Bluetooth when driving</string>
    <!-- Settings item summary for automatic Bluetooth on while driving preference [CHAR LIMIT=100] -->
    <string name="bluetooth_on_while_driving_summary">Turn on Bluetooth automatically when driving</string>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    <!-- Bluetooth message permission alert for notification content [CHAR LIMIT=none] -->
    <string name="bluetooth_message_access_notification_content">A device wants to access your messages. Tap for details.</string>
    <!-- Bluetooth message permission alert for dialog title [CHAR LIMIT=none] -->
    <string name="bluetooth_message_access_dialog_title">Allow access to messages?</string>
    <!-- Bluetooth message permission alert for dialog content [CHAR LIMIT=none] -->
    <string name="bluetooth_message_access_dialog_content">A Bluetooth device, <xliff:g id="device_name" example="My device">%1$s</xliff:g>, wants to access your messages.\n\nYou haven\u2019t connected to <xliff:g id="device_name" example="My device">%2$s</xliff:g> before.</string>
    <!-- Bluetooth phonebook permission alert for notification content [CHAR LIMIT=none] -->
    <string name="bluetooth_phonebook_access_notification_content">A device wants to access your contacts and call log. Tap for details.</string>
    <!-- Bluetooth phonebook permission alert for dialog title [CHAR LIMIT=none] -->
    <string name="bluetooth_phonebook_access_dialog_title">Allow access to contacts and call log?</string>
    <!-- Bluetooth phonebook permission alert for dialog content [CHAR LIMIT=none] -->
    <string name="bluetooth_phonebook_access_dialog_content">A Bluetooth device, <xliff:g id="device_name" example="My device">%1$s</xliff:g>, wants to access your contacts and call log. This includes data about incoming and outgoing calls.\n\nYou haven\u2019t connected to <xliff:g id="device_name" example="My device">%2$s</xliff:g> before.</string>

    <!-- Label for button to not allow grant the permission for remote devices. [CHAR_LIMIT=50] -->
    <string name="request_manage_bluetooth_permission_dont_allow">Don\u2019t allow</string>

    <!-- Bluetooth sim card permission alert for notification title [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_notification_title">SIM card access request</string>
    <!-- Bluetooth sim card permission alert for notification content [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_notification_content">A device wants to access your SIM card. Tap for details.</string>
    <!-- Bluetooth sim card permission alert for dialog title [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_dialog_title">Allow access to SIM card?</string>
    <!-- Bluetooth sim card permission alert for dialog content [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_dialog_content">A Bluetooth device, <xliff:g id="device_name" example="My device">%1$s</xliff:g>, wants to access data on your SIM card. This includes your contacts.\n\nWhile connected, <xliff:g id="device_name" example="My device">%2$s</xliff:g> will receive all calls made to <xliff:g id="phone_number" example="0912345678">%3$s</xliff:g>.</string>
    <!-- Bluetooth connect permission alert for notification title [CHAR LIMIT=none] -->
    <string name="bluetooth_connect_access_notification_title">Bluetooth device available</string>
    <!-- Bluetooth connect permission alert for notification content [CHAR LIMIT=none] -->
    <string name="bluetooth_connect_access_notification_content">A device wants to connect. Tap for details.</string>
    <!-- Bluetooth connect permission alert for dialog title [CHAR LIMIT=none] -->
    <string name="bluetooth_connect_access_dialog_title">Connect to Bluetooth device?</string>
    <!-- Bluetooth connect permission alert for dialog content [CHAR LIMIT=none] -->
    <string name="bluetooth_connect_access_dialog_content"><xliff:g id="device_name" example="My device">%1$s</xliff:g> wants to connect to this phone.\n\nYou haven\u2019t connected to <xliff:g id="device_name" example="My device">%2$s</xliff:g> before.</string>
    <!-- Strings for Dialog don't connect button -->
    <string name="bluetooth_connect_access_dialog_negative">Don\u2019t connect</string>
    <!-- Strings for Dialog connect button -->
    <string name="bluetooth_connect_access_dialog_positive">Connect</string>
</resources>
