<?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>
    <!-- Used in confirmation dialogs as the action that the user will tap to turn on the feature. [CHAR LIMIT=40]-->
    <string name="confirmation_turn_on">Turn on</string>

    <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
    <string name="device_info_default">Unknown</string>
    <!-- String for removal of sensitive info on about, depending on tap -->
    <string name="device_info_protected_single_press">Tap to show info</string>
    <!-- [CHAR LIMIT=NONE] Device Info screen. Countdown for user taps to enable development settings -->
    <string name="show_dev_countdown">{count, plural,
      =1      {You are now # step away from being a developer.}
      other   {You are now # steps away from being a developer.}
    }</string>
    <!-- [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 attempts to launch developer options before enabling it. -->
    <string name="dev_settings_disabled_warning">Please enable developer options first.</string>

    <!-- [CHAR LIMIT=NONE] Toast message when non-admin user attempts to launch developer options. -->
    <string name="dev_settings_available_to_admin_only_warning">Only the admin users can access developer settings.</string>


    <!-- Category headings in left-pane header menu --> <skip />
    <!-- Settings main menu category heading. System (Updates, data, accessibility, about phone). [CHAR LIMIT=40] -->
    <string name="header_category_system">System</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_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_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>

    <!-- Content description for preview pager. [CHAR LIMIT=NONE] -->
    <string name="preview_pager_content_description">Preview</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>

    <!-- Title for stay awake on fold radio button. [CHAR_LIMIT=NONE] -->
    <string name="stay_awake_on_fold_title">Always</string>
    <!-- Summary for stay awake on fold radio button. [CHAR_LIMIT=NONE] -->
    <string name="stay_awake_on_fold_summary">Front display turns on when you fold your device</string>
    <!-- Title for selective stay awake radio button. [CHAR_LIMIT=NONE] -->
    <string name="selective_stay_awake_title">Only games, videos, and more</string>
    <!-- Summary for selective stay awake radio button. [CHAR_LIMIT=NONE] -->
    <string name="selective_stay_awake_summary">Front display turns on for apps that stop your screen going idle</string>
    <!-- Title for fold grace period radio button that, on fold, goes to the lockscreen. [CHAR_LIMIT=NONE] -->
    <string name="stay_awake_on_lockscreen_title">Swipe up to continue</string>
    <!-- Summary for folding grace period radio button that, on fold, goes to the lockscreen. [CHAR_LIMIT=NONE] -->
    <string name="stay_awake_on_lockscreen_summary">Fold your phone and swipe up on the front display to continue using the app, or wait a few seconds for the screen to lock</string>

    <!-- Title for sleep on fold radio button. [CHAR_LIMIT=NONE] -->
    <string name="sleep_on_fold_title">Never</string>
    <!-- Summary for sleep on fold radio button. [CHAR_LIMIT=NONE] -->
    <string name="sleep_on_fold_summary">Front display locks when you fold your device</string>

    <!-- Auto rotate switchbar title. [CHAR_LIMIT=NONE] -->
    <string name="auto_rotate_settings_primary_switch_title">Use auto-rotate</string>

    <!-- Disclaimer for camera based rotate [CHAR_LIMIT=NONE] -->
    <string name="smart_rotate_text_headline">Face Detection uses the front-facing camera to improve auto-rotate accuracy. Images are never stored or sent to Google.</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, heading above the list of nearby bluetooth devices. [CHAR LIMIT=NONE] -->
    <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, 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>
    <!-- Title for bluetooth pairing item [CHAR LIMIT=60] -->
    <string name="bluetooth_pairing_pref_title">Pair new device</string>
    <!-- Keywords for bluetooth pairing item [CHAR LIMIT=30] -->
    <string name="keywords_add_bt_device">bluetooth</string>


    <!-- Button to help user to pair right ear of the hearing aid device. It will show when only one of the hearing aid device set is connected. [CHAR LIMIT=20] -->
    <string name="bluetooth_pair_right_ear_button">Pair right ear</string>
    <!-- Button to help user to pair left ear of the hearing aid device. It will show when only one of the hearing aid device set is connected. [CHAR LIMIT=20] -->
    <string name="bluetooth_pair_left_ear_button">Pair left ear</string>
    <!-- Connected devices settings. Title of the dialog to hint user to pair other ear of the hearing aid device. Shows when only one of the hearing aid device set is connected. [CHAR LIMIT=25] -->
    <string name="bluetooth_pair_other_ear_dialog_title">Pair your other ear</string>
    <!-- Connected devices settings. Message of the dialog to hint user to pair right ear of the hearing aid device. Shows when only left side of hearing aid device set is connected. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message">Your left hearing device is connected.\n\nTo pair the right one, make sure it\u2019s turned on and ready to pair.</string>
    <!-- Connected devices settings. Message of the dialog to hint user to pair other ear of the hearing aid device. Shows when only right side of the hearing aid device set is connected. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message">Your right hearing device is connected.\n\nTo pair the left one, make sure it\u2019s turned on and ready to pair.</string>
    <!-- Connected devices settings. Positive button of the dialog to help user to pair right ear of the hearing aid device. Dialog shows when only one of the hearing aid device set is connected. [CHAR LIMIT=20] -->
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button">Pair right ear</string>
    <!-- Connected devices settings. Positive button of the dialog to help user to pair left ear of the hearing aid device. Dialog shows when only one of the hearing aid device set is connected. [CHAR LIMIT=20] -->
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button">Pair left ear</string>
    <!-- Title for all hearing devices related controls section. [CHAR LIMIT=60] -->
    <string name="bluetooth_device_controls_general">For all available hearing devices</string>
    <!-- Connected devices settings. Title of the preference to show the entrance of the hearing device controls related page. [CHAR LIMIT=65] -->
    <string name="bluetooth_device_controls_title">Hearing device settings</string>
    <!-- Connected devices settings. Title of the preference to show the entrance of the hearing device controls related page. [CHAR LIMIT=65] -->
    <string name="bluetooth_device_controls_summary">Shortcut, hearing aid compatibility</string>
    <!-- Title for this device specific controls section. [CHAR LIMIT=30] -->
    <string name="bluetooth_device_controls_specific">For this device</string>
    <!-- Connected devices settings. Title of the preference to show the entrance of the audio output page. It can change different types of audio are played on phone or other bluetooth devices. [CHAR LIMIT=35] -->
    <string name="bluetooth_audio_routing_title">Audio output</string>
    <!-- Title for bluetooth audio routing page footer. [CHAR LIMIT=30] -->
    <string name="bluetooth_audio_routing_about_title">About audio output</string>
    <!-- Connected devices settings. Summary of the preference to show the entrance of the audio output page. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_audio_routing_summary">Route sounds to your hearing device or phone speaker</string>
    <!-- Title for related tools section. This section will list related tools below. [CHAR LIMIT=15] -->
    <string name="bluetooth_screen_related">Related</string>

    <!-- Bluetooth audio output settings. Title of the option managing ringtone and alarms audio path. [CHAR LIMIT=30] -->
    <string name="bluetooth_ringtone_title">Ringtone and alarms</string>
    <!-- Bluetooth audio output settings. Title of the option managing call audio path. [CHAR LIMIT=30] -->
    <string name="bluetooth_call_title">Audio during calls</string>
    <!-- Bluetooth audio output settings. Title of the option managing media and system sounds related audio path. [CHAR LIMIT=30] -->
    <string name="bluetooth_media_title">Media and system sounds</string>
    <!-- Bluetooth audio output settings. Title of the option managing notification audio path. [CHAR LIMIT=60] -->
    <string name="bluetooth_notification_title">Notifications</string>
    <!-- Description for text in accessibility hearing aids footer. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_audio_routing_footer_summary">By default, audio output is determined by individual apps</string>

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

    <!-- Title for contextual Bluetooth devices card when Bluetooth is off [CHAR LIMIT=NONE]-->
    <string name="bluetooth_devices_card_off_title">Bluetooth is off</string>
    <!-- Description about contextual Bluetooth devices card when Bluetooth is off [CHAR LIMIT=NONE]-->
    <string name="bluetooth_devices_card_off_summary">Tap to turn it on</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 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>

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

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

    <!-- UI debug setting: Disable Bluetooth A2DP hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_a2dp_hw_offload">Disable Bluetooth A2DP hardware offload</string>
    <!-- UI debug setting: Disable Bluetooth LE audio hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_le_audio_hw_offload">Disable Bluetooth LE audio hardware offload</string>
    <!-- UI debug setting: Disable Bluetooth hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_hw_offload_dialog_title">Restart Device?</string>
    <!-- UI debug setting: Disable Bluetooth hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_hw_offload_dialog_message">You need to restart your device to change this setting.</string>
    <!-- UI debug setting: Disable Bluetooth hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_hw_offload_dialog_confirm">Restart</string>
    <!-- UI debug setting: Disable Bluetooth hardware offload [CHAR LIMIT=none] -->
    <string name="bluetooth_disable_hw_offload_dialog_cancel">Cancel</string>

    <!-- Setting toggle title for disabling Bluetooth LE Audio feature. [CHAR LIMIT=40] -->
    <string name="bluetooth_disable_leaudio">Disable Bluetooth LE audio</string>
    <!-- Summary of toggle for disabling Bluetooth LE audio [CHAR LIMIT=none]-->
    <string name="bluetooth_disable_leaudio_summary">Disables Bluetooth LE audio feature if the device supports LE audio hardware capabilities.</string>
    <!-- Setting toggle title for switch Bluetooth LE Audio mode. [CHAR LIMIT=40] -->
    <string name="bluetooth_leaudio_mode">Bluetooth LE Audio mode</string>
    <!-- Setting toggle title for enabling Bluetooth LE Audio toggle in Device Details. [CHAR LIMIT=40] -->
    <string name="bluetooth_show_leaudio_device_details">Show LE audio toggle in Device Details</string>

    <!-- Setting toggle title for ignoring Bluetooth LE Audio Allowlist. [CHAR LIMIT=none] -->
    <string name="bluetooth_bypass_leaudio_allowlist">Bypass Bluetooth LE Audio Allowlist</string>
    <!-- Summary of toggle for ignoring Bluetooth LE Audio Allowlist [CHAR LIMIT=none]-->
    <string name="bluetooth_bypass_leaudio_allowlist_summary">Use LE Audio by default even if LE Audio peripheral hasn\'t been verified to meet Allowlist criteria.</string>

    <!-- Title for Bluetooth device group with media capability group [CHAR LIMIT=none]-->
    <string name="connected_device_media_device_title">Media devices</string>
    <!-- Title for Bluetooth device group with media capability group [CHAR LIMIT=none]-->
    <string name="connected_device_call_device_title">Call devices</string>
    <!-- Title for connected device group [CHAR LIMIT=none]-->
    <string name="connected_device_other_device_title">Other devices</string>
    <!-- Title for connected device group [CHAR LIMIT=none]-->
    <string name="connected_device_saved_title">Saved devices</string>
    <!-- Title for fast pair device group [CHAR LIMIT=none]-->
    <string name="connected_device_fast_pair_device_title">Associated with account</string>
    <!-- Title for previously associated fast pair device group [CHAR LIMIT=none]-->
    <string name="connected_device_previously_associated_fast_pair_device_title">Previously used with account</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>
    <!-- Preference screen title for Bluetooth preference to open paired but no connection list [CHAR LIMIT=none]-->
    <string name="connected_device_previously_connected_screen_title">Previously connected</string>
    <!-- Toast text for hint user bluetooth is turned on [CHAR LIMIT=none]-->
    <string name="connected_device_bluetooth_turned_on_toast">Bluetooth turned on</string>

    <!-- Title to see all the previous connected devices [CHAR LIMIT=50] -->
    <string name="previous_connected_see_all">See all</string>
    <!-- Title to see all fast pair devices [CHAR LIMIT=none]-->
    <string name="connected_device_fast_pair_device_see_all">See all</string>

    <!-- Title for stylus device details page [CHAR LIMIT=50] -->
    <string name="stylus_device_details_title">Stylus</string>
    <!-- Preference title for setting the app that opens user presses stylus button [CHAR LIMIT=none] -->
    <string name="stylus_default_notes_app">Tail button press</string>
    <!-- Summary for the app that opens when user presses stylus tail button, if set to a work profile app [CHAR LIMIT=none] -->
    <string name="stylus_default_notes_summary_work"><xliff:g id="app_name" example="Mail">%s</xliff:g> (Work profile)</string>
    <!-- Preference title for toggling whether handwriting in textfields is enabled [CHAR LIMIT=none] -->
    <string name="stylus_textfield_handwriting">Write in text fields</string>
    <!-- Preference title for toggling whether stylus button presses are ignored [CHAR LIMIT=none] -->
    <string name="stylus_ignore_button">Ignore all stylus button presses</string>
    <!-- Name shown in the title of individual stylus preference in the connected devices page [CHAR LIMIT=60] -->
    <string name="stylus_connected_devices_title">Stylus</string>

    <!-- Title for audio sharing page [CHAR LIMIT=none]-->
    <string name="audio_sharing_title">Audio sharing</string>
    <!-- Title for audio sharing primary switch [CHAR LIMIT=none]-->
    <string name="audio_sharing_switch_title">Share audio</string>
    <!-- Title for calls and alarms device on audio sharing page [CHAR LIMIT=none]-->
    <string name="calls_and_alarms_device_title">Calls and alarms</string>

    <!-- Title for audio streams preference category [CHAR LIMIT=none]-->
    <string name="audio_streams_category_title">Connect to a LE audio stream</string>
    <!-- Title for audio streams preference [CHAR LIMIT=none]-->
    <string name="audio_streams_pref_title">Nearby audio streams</string>
    <!-- Title for audio streams page [CHAR LIMIT=none]-->
    <string name="audio_streams_title">Audio streams</string>
    <!-- Summary for QR code scanning in audio streams page [CHAR LIMIT=none]-->
    <string name="audio_streams_qr_code_summary">Connect to an audio stream using QR code</string>
    <!--Text that appears when scanning for nearby audio streams is finished and no streams were found [CHAR LIMIT=40]-->
    <string name="audio_streams_empty">No nearby audio streams were found.</string>

    <!-- Date & time settings screen title -->
    <string name="date_and_time">Date &amp; time</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_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_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>

    <!-- 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. [CHAR LIMIT=30]-->
    <string name="language_picker_title">Languages</string>

    <!-- Title for category of the locale picker . [CHAR LIMIT=50]-->
    <string name="language_picker_category_title">Preferred language order</string>

    <!-- Description for indication of current system default language. [CHAR LIMIT=50]-->
    <string name="desc_current_default_language">System language</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>

    <!-- Title of preference for the locale picker activity. [CHAR LIMIT=30]-->
    <string name="app_locale_preference_title">Language</string>

    <!-- Title for the locale picker category. [CHAR LIMIT=50]-->
    <string name="locale_picker_category_title">Preferred Language</string>

    <!-- Title for the Apps' locale menu entry [CHAR LIMIT=50]-->
    <string name="app_locales_picker_menu_title">App languages</string>

    <!-- Summary for the app's locale picker activity. [CHAR LIMIT=50]-->
    <string name="app_locale_picker_summary">Set the language for each app</string>

    <!-- Title for the App's locale picker activity. [CHAR LIMIT=50]-->
    <string name="app_locale_picker_title">App language</string>

    <!-- Category for the suggested app's locales. [CHAR LIMIT=50]-->
    <string name="suggested_app_locales_title">Suggested languages</string>

    <!-- Category for the app's locale picker activity. [CHAR LIMIT=50]-->
    <string name="all_supported_app_locales_title">All languages</string>

    <!-- Title for preference of the system default locale. [CHAR LIMIT=50]-->
    <string name="preference_of_system_locale_title">System language</string>

    <!-- Summary for preference of the system default locale. [CHAR LIMIT=50]-->
    <string name="preference_of_system_locale_summary">System default</string>

    <!-- Description for the app without any supported languages. [CHAR LIMIT=NONE]-->
    <string name="desc_no_available_supported_locale">Language selection for this app isn\u2019t available from Settings.</string>

    <!-- Description for the disclaimer of per app language. [CHAR LIMIT=NONE]-->
    <string name="desc_app_locale_disclaimer">Language may differ from languages available in the app. Some apps may not support this setting.</string>

    <!-- Description for introduction of the locale selection supported of app list [CHAR LIMIT=NONE]-->
    <string name="desc_app_locale_selection_supported">Set the language for each app.</string>

    <!-- Description for the introduction to language picker activity. [CHAR LIMIT=NONE]-->
    <string name="desc_introduction_of_language_picker">Your system, apps, and websites use the first supported language from your preferred languages.</string>

    <!-- Description for the notice of language picker. [CHAR LIMIT=NONE]-->
    <string name="desc_notice_of_language_picker">To select a language for each app, go to app language settings.</string>

    <!-- Title for locale helper page [CHAR LIMIT=NONE] -->
    <string name="desc_locale_helper_footer_general">Learn more about app languages</string>

    <!-- Link for Locale helper page. [CHAR LIMIT=NONE]-->
    <string name="link_locale_picker_footer_learn_more" translatable="false">https://support.google.com/android?p=per_language_app_settings</string>

    <!-- Title for asking to change system locale or not. [CHAR LIMIT=50]-->
    <string name="title_change_system_locale">Change system language to %s ?</string>

    <!-- The title of a confirmation dialog to indicate adding a system locale. [CHAR LIMIT=50]-->
    <string name="title_system_locale_addition">Add %s to preferred languages?</string>

    <!-- The content of a confirmation dialog indicating the impact when the user adds a system locale. [CHAR LIMIT=NONE]-->
    <string name="desc_system_locale_addition">This lets apps and websites know you also prefer this language.</string>

    <!-- The text of the confirmation dialog showing the system locale will be changed. [CHAR LIMIT=NONE]-->
    <string name="desc_notice_device_locale_settings_change">Your device settings and regional preferences will change.</string>

    <!-- A dialog button for confirmmation of system locale change. [CHAR LIMIT=25]-->
    <string name="button_label_confirmation_of_system_locale_change">Change</string>

    <!-- Title for saying this selected locale is unavailable to use. [CHAR LIMIT=50]-->
    <string name="title_unavailable_locale">%s not available</string>

    <!-- The text of the confirmation dialog for saying this selected locale is unavailable to use. [CHAR LIMIT=NONE]-->
    <string name="desc_unavailable_locale">This language can’t be used as a system language, but you’ve let apps and websites know you prefer this language.</string>

    <!-- Regional Preferences begin -->
    <!-- The title of the menu entry of regional preferences. [CHAR LIMIT=50] -->
    <string name="regional_preferences_title">Regional preferences</string>
    <!-- The summary of the  menu entry of regional preferences. [CHAR LIMIT=NONE] -->
    <string name="regional_preferences_summary">Set units and number preferences</string>
    <!-- The subtitle of main page of regional preferences. [CHAR LIMIT=NONE] -->
    <string name="regional_preferences_main_page_sub_title">Let apps know your regional preferences so they can personalize your experience.</string>
    <!-- The subtitle of option's page of regional preferences for Temperature units, Calendar and First day of week. [CHAR LIMIT=NONE] -->
    <string name="regional_preferences_option_page_sub_title">Apps will use your regional preferences where possible.</string>
    <!-- The title of menu entry of Temperature unit preference. [CHAR LIMIT=50] -->
    <string name="temperature_preferences_title">Temperature</string>
    <!-- The title of the  menu entry of First day of week preference. [CHAR LIMIT=50]  -->
    <string name="first_day_of_week_preferences_title">First day of week</string>
    <!-- The title of the menu entry of Numbers system preference. [CHAR LIMIT=50]  -->
    <string name="numbers_preferences_title">Numbers preferences</string>
    <!-- The summary of default string for each regional preference. [CHAR LIMIT=50] -->
    <string name="default_string_of_regional_preference">Use default</string>
    <!-- The title of Celsius for preference of temperature unit. [CHAR LIMIT=50] -->
    <string name="celsius_temperature_unit">Celsius (\u00B0C)</string>
    <!-- The title of Fahrenheit for preference of temperature unit. [CHAR LIMIT=50] -->
    <string name="fahrenheit_temperature_unit">Fahrenheit (\u00B0F)</string>
    <!-- The title of sunday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="sunday_first_day_of_week">Sunday</string>
    <!-- The title of monday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="monday_first_day_of_week">Monday</string>
    <!-- The title of tuesday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="tuesday_first_day_of_week">Tuesday</string>
    <!-- The title of wednesday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="wednesday_first_day_of_week">Wednesday</string>
    <!-- The title of thursday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="thursday_first_day_of_week">Thursday</string>
    <!-- The title of friday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="friday_first_day_of_week">Friday</string>
    <!-- The title of saturday for preference of first day of week. [CHAR LIMIT=50] -->
    <string name="saturday_first_day_of_week">Saturday</string>
    <!-- Title for regional preference footer. [CHAR LIMIT=NONE] -->
    <string name="title_regional_pref_footer">If an app doesn’t support regional preferences, the app will use its default locale settings.</string>
    <!-- Description for text in regional preference footer. [CHAR LIMIT=NONE] -->
    <string name="desc_regional_pref_footer_learn_more">Learn more about language preferences.</string>
    <!-- Support link for the regional preference page. [CHAR LIMIT=NONE]-->
    <string name="regional_pref_footer_learn_more_link" translatable="false">https://support.google.com/android?p=regional_preferences</string>

    <!-- Category for the terms of address. [CHAR LIMIT=NONE]-->
    <string name="category_title_terms_of_address">Additional preferences</string>
    <!-- Preference title for the terms of address. [CHAR LIMIT=NONE]-->
    <string name="terms_of_address_title">Terms of address</string>
    <!-- Preference summary for the terms of address. [CHAR LIMIT=NONE]-->
    <string name="terms_of_address_summary">Set how you want to be addressed</string>
    <!-- The subtitle of terms of address. [CHAR LIMIT=NONE] -->
    <string name="terms_of_address_intro_title">Apps can use your terms of address to personalize how they address you.</string>
    <!-- The title of not specified of terms of address. [CHAR LIMIT=NONE] -->
    <string name="terms_of_address_not_specified">Not specified</string>
    <!-- The title of feminine of terms of address. [CHAR LIMIT=NONE] -->
    <string name="terms_of_address_feminine">Feminine</string>
    <!-- The title of masculine of terms of address. [CHAR LIMIT=NONE] -->
    <string name="terms_of_address_masculine">Masculine</string>
    <!-- The title of neutral of terms of address. [CHAR LIMIT=NONE] -->
    <string name="terms_of_address_neutral">Neutral</string>

    <!-- The title of the confirmation dialog shown when the user selects one / several languages and tries to remove them [CHAR LIMIT=60] -->
    <string name="dlg_remove_locales_title">{count, plural,
      =1      {Remove selected language?}
      other   {Remove selected languages?}
    }</string>

    <!-- 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">Not available as system language</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>

    <!-- 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>
    <!-- Button label for generic share action [CHAR LIMIT=20] -->
    <string name="share">Share</string>
    <!-- Button label for generic add action [CHAR LIMIT=20] -->
    <string name="add">Add</string>
    <!-- Button label for remove action [CHAR LIMIT=20] -->
    <string name="remove">Remove</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>
    <!-- Wireless controls settings screen, setting check box label -->
    <string name="airplane_mode">Airplane mode</string>
    <!-- Wireless Settings screen title for things like Wi-Fi, bluetooth, airplane mode. -->
    <string name="wireless_networks_settings_title">Wireless &amp; networks</string>

    <!-- mobile network settings screen, setting check box title -->
    <string name="roaming">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, message in dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_warning">Roaming charges may apply.</string>

    <!-- Date & time setting screen setting switch title: whether the system clock (Unix epoch time) should be determined automatically [CHAR LIMIT=100] -->
    <string name="date_time_auto">Set time automatically</string>
    <!-- Date & time setting screen setting switch title: whether the time zone should be determined automatically [CHAR LIMIT=100]  -->
    <string name="zone_auto_title">Set automatically</string>
    <!-- Date & time setting screen setting switch summary for non-telephony devices [CHAR LIMIT=100] -->
    <string name="auto_zone_requires_location_summary">Location will be used for setting the time zone when this toggle is on</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">Use locale default</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 title for setting time format (allowing user to set device display in 12-hour format or 24-hour format) [CHAR LIMIT=30] -->
    <string name="time_format_category_title">Time format</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>
    <!-- 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 in time zone setting screen [CHAR LIMIT=30] -->
    <string name="date_time_select_fixed_offset_time_zones">Select UTC offset</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 a follow-up sentence [CHAR LIMIT=NONE] -->
    <string name="zone_info_footer_first_sentence">Uses <xliff:g id="offset_and_name" example="Pacific Time (GMT-08:00)">%1$s</xliff:g>. <xliff:g id="second_sentence" example="Pacific Daylight Time starts on Mar 11 2018.">%2$s</xliff:g></string>
    <!-- Label describing the upcoming daylight savings time change [CHAR LIMIT=NONE] -->
    <string name="zone_info_footer_second_sentence"><xliff:g id="dst_time_type" example="Pacific Daylight Time">%1$s</xliff:g> starts on <xliff:g id="transition_date" example="Mar 11 2018">%2$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>

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

    <!-- Security settings screen, setting option name to change screen timeout -->
    <string name="lock_after_timeout">Lock after screen timeout</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 timeout</string>
    <!-- Security settings screen, setting option summary to change screen timeout, with additional explanation-->
    <string name="lock_immediately_summary_with_exception">Immediately after timeout, 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 timeout, except when kept unlocked by <xliff:g id="trust_agent_name">%2$s</xliff:g></string>
    <!-- Text shown for title of owner info setting [CHAR LIMIT=30]-->
    <string name="owner_info_settings_title">Add text on 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>
    <!-- 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>

    <!-- 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 [CHAR LIMIT=60] -->
    <string name="location_settings_primary_switch_title">Use location</string>
    <!-- Summary for Location settings when location is off [CHAR LIMIT=NONE] -->
    <string name="location_settings_summary_location_off">Off</string>
    <!-- Summary for Location settings when location is on, explaining how many apps have location permission [CHAR LIMIT=NONE]-->
    <string name="location_settings_summary_location_on">{count, plural,
      =1      {On / # app has access to location}
      other   {On / # apps have access to location}
    }</string>
    <!-- Location settings, loading the number of apps which have location permission [CHAR LIMIT=30] -->
    <string name="location_settings_loading_app_permission_stats">Loading\u2026</string>
    <!-- Location settings footer warning text when location is on [CHAR LIMIT=NONE] -->
    <string name="location_settings_footer_general">
        Apps with the Nearby devices permission can determine the
        relative position of connected devices.
    </string>
    <!-- Location settings footer warning text when location is off [CHAR LIMIT=NONE] -->
    <string name="location_settings_footer_location_off">
        Location access is off for apps and services. Your device location may still be sent to
        emergency responders when you call or text an emergency number.
    </string>
    <!-- Location settings footer link to support page [CHAR LIMIT=NONE] -->
    <string name="location_settings_footer_learn_more_link" translatable="false">
        https://support.google.com/android/answer/3467281
    </string>
    <!-- Location settings footer link content description [CHAR LIMIT=NONE] -->
    <string name="location_settings_footer_learn_more_content_description">
        Learn more about Location settings
    </string>
    <!-- Tooltip for switchbar on Chrome devices. [CHAR LIMIT=90]-->
    <string name="location_settings_tooltip_text_for_chrome">To change location access, go to Settings > Security and Privacy > Privacy controls</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</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>
    <!-- Screen title for a list of settings controlling what to show on user's lockscreen [CHAR LIMIT=60] -->
    <string name="lockscreen_settings_title">Lock screen</string>
    <!-- Category title for the settings that control what lockscreen shows. [CHAR LIMIT=30] -->
    <string name="lockscreen_settings_what_to_show_category">What to show</string>
    <!-- Summary for settings preference disabled by administrator [CHAR LIMIT=50] -->
    <string name="disabled_by_administrator_summary">Not available</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, Find My Device, app security</string>
    <!-- TODO(b/208624929): Update to an UX approved title and char limit. -->
    <!-- Main Settings screen setting title for the item that takes you to the safety center [CHAR LIMIT=60] -->
    <string name="safety_center_title">Security &amp; privacy</string>
    <!-- TODO(b/208624929): Update to an UX approved summary and char limit. -->
    <!-- Main Settings screen setting summary for the item that takes you to the privacy and security settings. [CHAR LIMIT=60] -->
    <string name="safety_center_summary">App security, device lock, permissions</string>

    <!-- Face enrollment and settings --><skip />
    <!-- Note: Update FaceEnrollParentalConsent.CONSENT_STRING_RESOURCES when any _consent_ strings are added or removed. -->
    <!-- Message shown in summary field when face unlock is set up. [CHAR LIMIT=40] -->
    <string name="security_settings_face_preference_summary">Face added</string>
    <!-- Message shown in summary field when Face Unlock is not set up. [CHAR LIMIT=54] -->
    <string name="security_settings_face_preference_summary_none">Setup needed</string>
    <!-- Title shown for menu item that launches face settings or enrollment. [CHAR LIMIT=32] -->
    <string name="security_settings_face_preference_title">Face Unlock</string>
    <!-- Title shown for menu item that launches face settings or enrollment, for work profile [CHAR LIMIT=50] -->
    <string name="security_settings_face_profile_preference_title">Face Unlock for work</string>
    <!-- Introduction title shown in face enrollment education screen [CHAR LIMIT=50] -->
    <string name="security_settings_face_enroll_education_title">How to set up Face Unlock</string>
    <!-- Introduction title shown in face enrollment education screen for accessibility [CHAR LIMIT=50]-->
    <string name="security_settings_face_enroll_education_title_accessibility">Set up Face Unlock</string>
    <!-- Introduction title shown in face enrollment education screen to show the face unlock feature, when face unlock is disabled by device admin [CHAR LIMIT=60] -->
    <string name="security_settings_face_enroll_education_title_unlock_disabled">Use your face to authenticate</string>
    <!-- Introduction detail message shown in face education [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_education_message"></string>
    <!-- Button that takes the user to the enrollment activity [CHAR LIMIT=20] -->
    <string name="security_settings_face_enroll_education_start">Start</string>
    <!-- Confirmation dialog message shown when users with system accessibility features enabled try to start the non-accessibility version of enrollment [CHAR LIMIT=150] -->
    <string name="security_settings_face_enroll_education_accessibility_dialog_message">If accessibility Face Unlock is turned off, some setup steps may not work properly with TalkBack.</string>
    <!-- Negative button text for users who were shown the accessibility dialog [CHAR LIMIT=10] -->
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative">Go back</string>
    <!-- Positive button text for users who were shown the accessibility dialog [CHAR LIMIT=20] -->
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive">Continue setup</string>
    <!-- Button shown which shows accessibility toggles for face enrollment when clicked. [CHAR LIMIT=32] -->
    <string name="security_settings_face_enroll_introduction_accessibility">Use accessibility setup</string>
    <!-- Message shown for a toggle which when enabled, allows the user to enroll using a simpler flow for accessibility [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_accessibility_diversity"></string>
    <!-- Message shown for a toggle which when enabled, allows the user to enroll using a simpler flow for accessibility [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_accessibility_vision"></string>
    <!-- Button text to cancel enrollment from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_face_enroll_introduction_cancel">Cancel</string>
    <!-- Button text to cancel enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_face_enroll_introduction_no_thanks">No thanks</string>
    <!-- Button text to start enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_face_enroll_introduction_agree">I agree</string>
    <!-- Button text to scroll to the end of a scrollview. [CHAR LIMIT=30] -->
    <string name="security_settings_face_enroll_introduction_more">More</string>
    <!-- Introduction title shown in face enrollment to introduce the face unlock feature [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_introduction_title">Unlock with your face</string>
    <!-- Introduction title shown in face enrollment when when asking for parental consent for the face unlock feature [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_consent_introduction_title">Allow face unlock</string>
    <!-- Introduction title shown in face enrollment to introduce the face unlock feature, when face unlock is disabled by device admin [CHAR LIMIT=60] -->
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled">Use your face to authenticate</string>
    <!-- Introduction detail message shown in face enrollment dialog, when face unlock is disabled by device admin [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled">Use your face to unlock your phone or approve purchases.\n\nNote: You can\u2019t use your face to unlock this device. For more information, contact your organization\u2019s admin.</string>
    <!-- Introduction detail message shown in face enrollment screen in setup wizard. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_message_setup">Use your face to unlock your phone, authorize purchases, or sign in to apps</string>
    <!-- Title of a section on the face enrollment introduction page that provides additional information. [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_introduction_info_title"></string>
    <!-- Message on the face enrollment introduction page that provides information about glasses. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_info_glasses"></string>
    <!-- Message on the face enrollment introduction page that provides information about glasses when asking for parental consent. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_info_consent_glasses"></string>

    <!-- Title of a section on the face enrollment introduction page that explains how face unlock works. [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_introduction_how_title"></string>
    <!-- Title of a section on the face enrollment introduction page that explains privacy controls for face unlock. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_control_title"></string>
    <!-- Title of a section on the face enrollment introduction page that explains privacy controls for face unlock when asking for parental consent. [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_enroll_introduction_control_consent_title"></string>
    <!-- Title shown in face enrollment dialog [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_repeat_title">Center your face in the circle</string>
    <!-- Button text to skip enrollment of face [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_enrolling_skip">Skip</string>
    <!-- Text shown when users has enrolled a maximum number of faces [CHAR LIMIT=NONE] -->
    <string name="face_intro_error_max">You\u2019ve added the maximum number of faces</string>
    <!-- Text shown when an unknown error caused the device to be unable to add faces [CHAR LIMIT=NONE] -->
    <string name="face_intro_error_unknown">Can\u2019t add more faces</string>
    <!-- Dialog message for dialog which shows when face cannot be enrolled. [CHAR LIMIT=45] -->
    <string name="security_settings_face_enroll_error_dialog_title">Enrollment was not completed</string>
    <!-- Button text shown in face dialog shown when an error occurs during enrollment [CHAR LIMIT=22] -->
    <string name="security_settings_face_enroll_dialog_ok">OK</string>
    <!-- Dialog message for dialog which shows when face cannot be enrolled due to being idle too long. -->
    <string name="security_settings_face_enroll_error_timeout_dialog_message">Face enrollment time limit reached. Try again.</string>
    <!-- Dialog message for dialog which shows when face cannot be enrolled due to an internal error or face can't be read. -->
    <string name="security_settings_face_enroll_error_generic_dialog_message">Face enrollment didn\'t work.</string>
    <!-- Message shown in face enrollment dialog once enrollment is completed -->
    <string name="security_settings_face_enroll_finish_title">All set. Looking good.</string>
    <!-- Button text to exit face wizard after everything is done [CHAR LIMIT=15] -->
    <string name="security_settings_face_enroll_done">Done</string>
    <!-- Settings suggestion title text for re-enrolling a face. [CHAR LIMIT=50] -->
    <string name="security_settings_face_enroll_should_re_enroll_title">Improve Face Unlock performance</string>
    <!-- Settings suggestion subtitle text for re-enrolling a face. [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_should_re_enroll_subtitle">Set up Face Unlock again</string>
    <!-- Settings suggestion title text for mandatory re-enrolling of a face. [CHAR LIMIT=50] -->
    <string name="security_settings_face_enroll_must_re_enroll_title">Set up Face Unlock again</string>
    <!-- Settings suggestion subtitle text for mandatory re-enrolling of a face. [CHAR LIMIT=40] -->
    <string name="security_settings_face_enroll_must_re_enroll_subtitle">Improve security and performance</string>
    <!-- Settings suggestion alert body title for re-enrolling a face. [CHAR LIMIT=60] -->
    <string name="security_settings_face_enroll_improve_face_alert_title">Set up Face Unlock</string>
    <!-- Settings suggestion alert body text for re-enrolling a face. [CHAR LIMIT=300] -->
    <string name="security_settings_face_enroll_improve_face_alert_body">Delete your current face model to set up Face Unlock again.\n\nYour face model will be permanently and securely deleted.\n\nAfter deletion, you will need your PIN, pattern, or password to unlock your phone or for authentication in apps.</string>
    <!-- Settings suggestion alert body text for re-enrolling a face. [CHAR LIMIT=300] -->
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint">Delete your current face model to set up Face Unlock again.\n\nYour face model will be permanently and securely deleted.\n\nAfter deletion, you will need your fingerprint, PIN, pattern, or password to unlock your phone or for authentication in apps.</string>
    <!-- Title for a category shown for the face settings page. [CHAR LIMIT=20] -->
    <string name="security_settings_face_settings_use_face_category">Use Face Unlock for</string>
    <!-- Title for a category shown for the face settings page, followed by items that the user can toggle on/off to require/disable. [CHAR LIMIT=50] -->
    <string name="security_settings_face_settings_preferences_category">When using Face Unlock</string>
    <!-- Text shown on a toggle which disables/enables face unlock, depending if the user's eyes are open. [CHAR LIMIT=30] -->
    <string name="security_settings_face_settings_require_attention">Require eyes to be open</string>
    <!-- Text shown on the details of a toggle which disables/enables face unlock, depending if the user's eyes are open. [CHAR LIMIT=70] -->
    <string name="security_settings_face_settings_require_attention_details">To unlock the phone, your eyes must be open</string>
    <!-- When authenticating in apps, always require confirmation (e.g. confirm button) after a face is authenticated. [CHAR LIMIT=50] -->
    <string name="security_settings_face_settings_require_confirmation">Always require confirmation</string>
    <!-- When authenticating in apps, always require confirmation (e.g. confirm button) after a face is authenticated. [CHAR LIMIT=70] -->
    <string name="security_settings_face_settings_require_confirmation_details">When using Face Unlock in apps, always require confirmation step</string>
    <!-- Button text in face settings which removes the user's face model from the device [CHAR LIMIT=40] -->
    <string name="security_settings_face_settings_remove_face_model">Delete face model</string>
    <!-- Button text in face settings which lets the user enroll their face [CHAR LIMIT=40] -->
    <string name="security_settings_face_settings_enroll">Set up Face Unlock</string>
    <!-- Dialog title shown when the user removes an enrollment [CHAR LIMIT=35] -->
    <string name="security_settings_face_settings_remove_dialog_title">Delete face model?</string>
    <!-- Dialog contents shown when the user removes an enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_remove_dialog_details">Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your PIN, pattern, or password to unlock your phone or for authentication in apps.</string>
    <!-- Dialog contents shown when the user removes an enrollment when configured as a convenience [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_remove_dialog_details_convenience">Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your PIN, pattern, or password to unlock your phone.</string>
    <!-- Dialog contents shown when the user removes an enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_remove_dialog_details_fingerprint">Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your fingerprint, PIN, pattern, or password to unlock your phone or for authentication in apps.</string>
    <!-- Dialog contents shown when the user removes an enrollment when configured as a convenience [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv">Your face model will be permanently and securely deleted.\n\nAfter deletion, you will need your fingerprint, PIN, pattern, or password to unlock your phone.</string>
    <!-- Subtitle shown for contextual setting face enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_face_settings_context_subtitle">Use Face Unlock to unlock your phone</string>

    <!-- Fingerprint enrollment and settings --><skip />
    <!-- Note: Update FingerprintEnrollParentalConsent.CONSENT_STRING_RESOURCES when any _consent_ strings are added or removed. -->
    <!-- Title shown for choose lock options [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint">Fingerprint</string>
    <!-- Title shown for menu item that launches fingerprint settings or enrollment [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_preference_title">Fingerprint</string>
    <!-- Title for a category shown for the fingerprint settings page, followed by items that the user can toggle on/off to require/disable. [CHAR LIMIT=50] -->
    <string name="security_settings_fingerprint_settings_preferences_category">When using Fingerprint Unlock</string>
    <!-- Title shown for work menu item that launches fingerprint settings or enrollment [CHAR LIMIT=22] -->
    <string name="security_settings_work_fingerprint_preference_title">Fingerprint for work</string>
    <!-- Preference to add another fingerprint -->
    <string name="fingerprint_add_title">Add fingerprint</string>
    <!-- Message showing the current number of fingerprints set up. Shown for a menu item that launches fingerprint settings or enrollment. -->
    <string name="security_settings_fingerprint_preference_summary">{count, plural,
      =1      {Fingerprint added}
      other   {# fingerprints added}
    }</string>
    <!-- message shown in summary field when no fingerprints are registered -->
    <string name="security_settings_fingerprint_preference_summary_none">Setup needed</string>
    <!-- Introduction title shown in fingerprint enrollment to introduce the fingerprint feature [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_introduction_title">Set up your fingerprint</string>
    <!-- Introduction title shown in fingerprint enrollment when asking for parental consent for fingerprint unlock [CHAR LIMIT=29] -->
    <string name="security_settings_fingerprint_enroll_consent_introduction_title">Allow fingerprint unlock</string>
    <!-- Introduction title shown in fingerprint enrollment to introduce the fingerprint feature, when fingerprint unlock is disabled by device admin [CHAR LIMIT=40] -->
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled">Use your fingerprint</string>
    <!-- Learn more text of footer preference for fingerprint settings [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_settings_footer_learn_more">Learn more about Fingerprint Unlock</string>
    <!-- Introduction title shown in the bottom of fingerprint enrollment dialog [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1">You\u2019re in control</string>
    <!-- Introduction title shown in the bottom of fingerprint enrollment dialog [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1">You and your child are in control</string>
    <!-- Introduction title shown in the bottom of fingerprint enrollment dialog [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2">Keep in mind</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>
    <!-- Button text to cancel enrollment from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_cancel">Cancel</string>
    <!-- Button text to cancel enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks">No thanks</string>
    <!-- Button text to agree the consent and continue to the next screen from the introduction [CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_introduction_agree">I agree</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]-->

    <!-- Introduction detail message shown in fingerprint enrollment introduction screen in setup wizard. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup">When you see this icon, use your fingerprint for authentication, like when you sign in to apps or approve a purchase</string>
    <!-- Introduction subtitle message shown in fingerprint enrollment introduction screen in setup wizard. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1">Keep in mind</string>
    <!-- Introduction subtitle message shown in fingerprint enrollment introduction screen in setup wizard. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2">How it works</string>
    <!-- Introduction description message shown in fingerprint enrollment introduction screen in setup wizard. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2">Fingerprint Unlock creates a unique model of your fingerprint to verify it\u2019s you. To create this fingerprint model during setup, you will take images of your fingerprint from different positions.</string>
    <!-- Introduction description message shown in fingerprint enrollment introduction screen in setup wizard when asking for parental consent. [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2">Fingerprint Unlock creates a unique model of your child\u2019s fingerprint to verify it\u2019s them. To create this fingerprint model during setup, they will take images of their fingerprint from different positions.</string>
    <!-- Introduction description message shown in fingerprint enrollment introduction screen in setup wizard. [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6">For best results, use a screen protector that\u2019s Made for Google certified. With other screen protectors, your fingerprint may not work.</string>
    <!-- Introduction description message shown in fingerprint enrollment introduction screen in setup wizard when asking for parental consent. [CHAR LIMIT=NONE] -->
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6">For best results, use a screen protector that\u2019s Made for Google certified. With other screen protectors, your child\u2019s fingerprint may not work.</string>
    <!-- Introduction detail message shown in fingerprint enrollment introduction to learn more about fingerprint [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more"></string>

    <!-- Watch unlock enrollment and settings --><skip />
    <!-- Title shown for menu item that launches watch unlock settings. [CHAR LIMIT=40] -->
    <string name ="security_settings_activeunlock_preference_title">Watch Unlock</string>
    <!-- Introduction shown in face and fingerprint page to introduce the biometric feature. [CHAR LIMIT=NONE]-->
    <string name="biometric_settings_intro_with_activeunlock">When you set up Face Unlock and Fingerprint Unlock, your phone will ask for your fingerprint when you wear a mask or are in a dark area.\n\nWatch Unlock is another convenient way to unlock your phone, for example, when your fingers are wet or face isn\u2019t recognized.</string>
    <!-- Introduction shown in fingerprint page to explain that watch unlock can be used if fingerprint isn't recognized. [CHAR LIMIT=NONE]-->
    <string name="biometric_settings_intro_with_fingerprint">Watch Unlock is another convenient way to unlock your phone, for example, when your fingerprint isn\u2019t recognized.</string>
    <!-- Introduction shown in face page to explain that watch unlock can be used if face isn't recognized. [CHAR LIMIT=NONE]-->
    <string name="biometric_settings_intro_with_face">Watch Unlock is another convenient way to unlock your phone, for example, when your face isn\u2019t recognized.</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for"> Use fingerprint or watch to</string>
    <string name="biometric_settings_use_face_or_watch_for"> Use face or watch to</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for"> Use face, fingerprint, or watch to</string>
    <string name="biometric_settings_use_watch_for"> Use watch to</string>
    <!-- Message for a biometric preference toggle, indicating that an action can only be performed by using Face Unlock or Watch Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_face_or_watch_preference_summary">Using face or watch</string>
    <!-- Message for a biometric preference toggle, indicating that an action can only be performed by using Fingerprint Unlock or Watch Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary">Using fingerprint or watch</string>
    <!-- Message for a biometric preference toggle, indicating that an action can be performed by using either Face Unlock, Fingerprint Unlock, or Watch Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary">Using face, fingerprint, or watch</string>
    <!-- Message for a biometric preference toggle, indicating that an action can be performed by using Watch Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_watch_preference_summary">Using watch</string>
    <!-- Title shown in watch unlock require face or fingerprint setup page [CHAR LIMIT=60] -->
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title">Set up Face or Fingerprint Unlock first</string>
    <!-- Message shown in watch unlock require face or fingerprint setup page [CHAR LIMIT=NONE] -->
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message">You can unlock with your watch when your face or fingerprint isn\u2019t recognized</string>
    <!-- Title shown in watch unlock require fingerprint setup page [CHAR LIMIT=60] -->
    <string name="security_settings_activeunlock_require_fingerprint_setup_title">Set up Fingerprint Unlock first</string>
    <!-- Message shown in watch unlock require fingerprint setup page [CHAR LIMIT=NONE] -->
    <string name="security_settings_activeunlock_require_fingerprint_setup_message">You can unlock with your watch when your fingerprint isn\u2019t recognized</string>
    <!-- Title shown in watch unlock require face setup page [CHAR LIMIT=60] -->
    <string name="security_settings_activeunlock_require_face_setup_title">Set up Face Unlock first</string>
    <!-- Message shown in watch unlock require face setup page [CHAR LIMIT=NONE] -->
    <string name="security_settings_activeunlock_require_face_setup_message">You can unlock with your watch when your face isn\u2019t recognized</string>
    <!-- Button text to launch biometric setup [CHAR LIMIT=30] -->
    <string name="security_settings_activeunlock_biometric_setup">Set up</string>
    <!-- Message showing that fingerprint and watch is set up. Shown for a menu item that launches fingerprint and watch unlock settings or enrollment. [CHAR LIMIT=80]-->
    <string name="security_settings_fingerprint_single_watch_preference_summary">Fingerprint and <xliff:g id="watch" example="Dani's Watch">%s</xliff:g> added</string>
    <!-- Message showing that multiple fingerprints and watch is set up. Shown for a menu item that launches fingerprint and watch unlock settings or enrollment. [CHAR LIMIT=80]-->
    <string name="security_settings_fingerprint_multiple_watch_preference_summary">Fingerprints and <xliff:g id="watch" example="Dani's Watch">%s</xliff:g> added</string>
    <!-- Message showing that face and watch is set up. Shown for a menu item that launches face and watch unlock settings or enrollment. [CHAR LIMIT=80]-->
    <string name="security_settings_face_watch_preference_summary">Face and <xliff:g id="watch" example="Dani's Watch">%s</xliff:g> added</string>
    <!-- Message showing that fingerprint, face, and the current watch is set up. Shown for a menu item that launches fingerprint, face,  and active unlock settings or enrollment. [CHAR LIMIT=80] -->
    <string name="security_settings_fingerprint_single_face_watch_preference_summary">Face, fingerprint, and <xliff:g id="watch" example="Dani's Watch">%s</xliff:g> added</string>
    <!-- Message showing that multiple fingerprints, face, and the current watch is set up. Shown for a menu item that launches fingerprint, face,  and active unlock settings or enrollment. [CHAR LIMIT=80]-->
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary">Face, fingerprints, and <xliff:g id="watch" example="Dani's Watch">%s</xliff:g> added</string>

    <!-- RemoteAuth unlock enrollment and settings --><skip />
    <!-- Title shown for menu item that launches watch unlock settings. [CHAR LIMIT=40] -->
    <string name ="security_settings_remoteauth_preference_title">Remote Authenticator Unlock</string>
    <!-- Message shown in summary field when remote authenticator is set up. [CHAR LIMIT=40] -->
    <string name="security_settings_remoteauth_preference_summary">Watch added</string>
    <!-- Strings for RemoteAuth enroll introduction page -->
    <!-- Introduction title shown in remote enrollment to introduce the remote feature [CHAR LIMIT=29] -->
    <string name="security_settings_remoteauth_enroll_introduction_title">Set up your watch</string>
    <!-- Summary of the Watch Unlock feature that allows users to unlock the phone with paired watches [CHAR_LIMIT=NONE]-->
    <string name="security_settings_remoteauth_enroll_introduction_message">Watch Unlock is another convenient way to unlock this phone, for example, when your fingers are wet or face isn\u2019t recognized.\n\nYou can use your watch to unlock this phone when you:</string>
    <!-- Button text to cancel enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_remoteauth_enroll_introduction_disagree">Not now</string>
    <!-- Button text to start enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_remoteauth_enroll_introduction_agree">Continue</string>
    <!-- Button text to scroll to the end of a scrollview. [CHAR LIMIT=30] -->
    <string name="security_settings_remoteauth_enroll_introduction_more">More</string>
    <!-- Heading of the paragraph that explains how the Watch Unlock feature works [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_how_title">How it works</string>
    <!-- Explains that paired watches must be unlocked, on-body, and nearby, in order to unlock the phone [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open">Your watch must be unlocked, on your wrist, and within reach of this phone. You won\u2019t need to unlock your watch again while it\u2019s on your wrist.</string>
    <!-- Explains that users will be notified on the watch when the phone is unlocked by the watch, and they can tap on the notification to lock the phone from the watch [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications">When this phone is unlocked, you\u2019ll get notified on your watch. If it was unlocked when you didn’t intend to, tap the notification to lock the phone again.</string>
    <!-- Heading of the paragraph that explains how to opt out of the Watch Unlock feature [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title">You\u2019re in control</string>
    <!-- Explains that users can prevent their watches from unlocking their phone by removing them in the Watch Unlock settings [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch">You can remove your watch from Watch Unlock at any time in Settings</string>
    <!-- Subtitle for animation that explains users can unlock by tapping a notification [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification">Tap a notification</string>
    <!-- Subtitle for animation that explains users can unlock by swiping up on the lock screen [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up">Swipe up on the lock screen</string>
    <!-- Strings for RemoteAuth enroll enrolling page -->
    <!-- Title of the screen that allows users to choose from a list of available watches to enable the Watch Unlock feature [CHAR_LIMIT=45] -->
    <string name="security_settings_remoteauth_enroll_enrolling_title">Choose your watch</string>
    <!-- Heading text for the list of watches available for the Watch Unlock feature [CHAR_LIMIT=40] -->
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading">Available watches</string>
    <!-- Button text to cancel enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_remoteauth_enroll_enrolling_disagree">Cancel</string>
    <!-- Button text to start enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_remoteauth_enroll_enrolling_agree">Confirm</string>
    <!-- Strings for RemoteAuth enroll finish page -->
    <!-- Title of the dialog that shows when a paired watch has been set up successfully and can be used to unlock the phone [CHAR_LIMIT=45] -->
    <string name="security_settings_remoteauth_enroll_finish_title">You\u2019re all set!</string>
    <!-- Explains when a paired watch can be used to unlock the phone after it has been set up successfully [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_enroll_finish_description">You can now use your watch to unlock this phone when you swipe up on the lock screen or tap a notification</string>
    <!-- Button text to finish enrollment [CHAR LIMIT=30] -->
    <string name="security_settings_remoteauth_enroll_finish_btn_next">Done</string>
    <!-- Strings for RemoteAuth settings page-->
    <!-- Title for remote authenticator settings page [CHAR_LIMIT=NONE]-->
    <string name="security_settings_remoteauth_settings_title">Watch Unlock</string>
    <!-- Explains when a watch can be used to unlock the phone [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_settings_description">You can use your watch to unlock this phone when you swipe up on the lock screen or tap a notification</string>
    <!-- Explains how to enable the Watch Unlock feature on a watch [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_settings_info_footer">To use Watch Unlock, your watch must be unlocked, on your wrist, within reach, and connected to this phone. If the connection is interrupted, you\u2019ll need to unlock the phone before you can use Watch Unlock.\n\nKeep in mind:\nYou can only have one watch set up at a time. To add another watch, first remove the current one.</string>
    <!-- Links to the Watch Unlock help center article [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_settings_learn_more">Learn more about Watch Unlock</string>
    <!-- Button text to add new watch [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_settings_register_new_authenticator">Add watch</string>
    <!-- Accessibility label of a button that lets users remove enrolled watches from Watch Unlock settings [CHAR_LIMIT=NONE] -->
    <string name="security_settings_remoteauth_settings_remove_device">Remove watch</string>

    <!-- Biometric settings --><skip />
    <!-- Title shown for menu item that launches biometric settings. [CHAR LIMIT=66] -->
    <string name="security_settings_biometric_preference_title">Fingerprint &amp; Face Unlock</string>
    <!-- Title shown for work menu item that launches biometric settings. [CHAR LIMIT=66] -->
    <string name="security_settings_work_biometric_preference_title">Face &amp; Fingerprint Unlock for work</string>
    <!-- Message shown in summary field of biometric settings. [CHAR LIMIT=66] -->
    <string name="security_settings_biometric_preference_summary_none_enrolled">Setup needed</string>
    <!-- Message shown in summary field of biometric settings when face is enrolled, and multiple fingerprints are enrolled. [CHAR LIMIT=66]-->
    <string name="security_settings_biometric_preference_summary_both_fp_multiple">Face and fingerprints added</string>
    <!-- Message shown in summary field of biometric settings when face is enrolled, and a single fingerprintis enrolled. [CHAR LIMIT=66]-->
    <string name="security_settings_biometric_preference_summary_both_fp_single">Face and fingerprint added</string>
    <!-- Introduction shown in face and fingerprint page to introduce the biometric feature. [CHAR LIMIT=NONE]-->
    <string name="biometric_settings_intro">When you set up Face Unlock and Fingerprint Unlock, your phone will ask for your fingerprint when you wear a mask or are in a dark area</string>
    <!-- Biometric category title - biometric options for unlocking the device. [CHAR LIMIT=50] -->
    <string name="biometric_settings_category_ways_to_unlock">Ways to unlock</string>
    <!-- Biometric category title - biometric options for unlocking the device. [CHAR LIMIT=60] -->
    <string name="biometric_settings_category_use_face_fingerprint">Use face or fingerprint to</string>
    <!-- Text shown on a toggle which allows or disallows the device to use biometric for unlocking the device. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_biometric_unlock_phone">Unlock your phone</string>
    <!-- Text shown on a toggle which allows or disallows the device to use biometric for authentication. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_biometric_for_apps">Verify it\u2019s you in apps</string>
    <!-- Message for a biometric preference toggle, indicating that an action can only be performed by using Face Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_face_preference_summary">Using face</string>
    <!-- Message for a biometric preference toggle, indicating that an action can only be performed by using Fingerprint Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_fingerprint_preference_summary">Using fingerprint</string>
    <!-- Message for a biometric preference toggle, indicating that an action can be performed by using either Face Unlock or Fingerprint Unlock. [CHAR LIMIT=50] -->
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary">Using face or fingerprint</string>
    <!-- Button text shown during enrollment to proceed after a child user has handed the device to a parent or guardian. [CHAR LIMIT=22] -->
    <string name="biometric_settings_hand_back_to_guardian_ok">OK</string>
    <!-- Dialog title for dialog which shows when trying to add face in split mode. [CHAR LIMIT=NONE] -->
    <string name="biometric_settings_add_face_in_split_mode_title">Can\u2019t set up Face Unlock</string>
    <!-- Dialog message for dialog which shows when trying to add face in split mode. [CHAR LIMIT=NONE] -->
    <string name="biometric_settings_add_face_in_split_mode_message">Exit split screen to set up Face Unlock</string>
    <!-- Dialog title for dialog which shows when trying to add fingerprint in split mode. [CHAR LIMIT=80] -->
    <string name="biometric_settings_add_fingerprint_in_split_mode_title">Can\u2019t set up fingerprint</string>
    <!-- Dialog message for dialog which shows when trying to add fingerprint in split mode. [CHAR LIMIT=NONE] -->
    <string name="biometric_settings_add_fingerprint_in_split_mode_message">Exit split screen to set up Fingerprint Unlock</string>
    <!-- Button text shown in adding biometrics dialog that allows the user to go back to the settings page [CHAR LIMIT=22] -->
    <string name="biometric_settings_add_biometrics_in_split_mode_ok">OK</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>
    <!-- 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>
    <!-- Button text to skip lock screen setup [CHAR LIMIT=20] -->
    <string name="skip_lock_screen_dialog_button_label">Skip</string>
    <!-- Button text to cancel lock screen skip dialog [CHAR LIMIT=20] -->
    <string name="cancel_lock_screen_dialog_button_label">Cancel</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>
    <!-- Introduction title shown in SFPS enrollment dialog to locate the sensor [CHAR LIMIT=60] -->
    <string name="security_settings_sfps_enroll_find_sensor_title">Touch the power button without pressing it</string>
    <!-- Introduction title shown in UDFPS enrollment dialog to locate the sensor [CHAR LIMIT=60] -->
    <string name="security_settings_udfps_enroll_find_sensor_title">How to set up your fingerprint</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>
    <!-- Message shown in UDFPS enrollment dialog to locate the sensor [CHAR LIMIT=NONE]-->
    <string name="security_settings_udfps_enroll_find_sensor_message">The fingerprint sensor is on your screen. You\u2019ll capture your fingerprint on the next screen.</string>
    <!-- Button for starting fingerprint enrollment. [CHAR LIMIT=10]-->
    <string name="security_settings_udfps_enroll_find_sensor_start_button">Start</string>
    <!-- Message announced to a11y users during UDFPS enrollment to help them locate the sensor. [CHAR LIMIT=NONE] -->
    <string name="security_settings_udfps_enroll_a11y">Move your finger across the screen to find the sensor. Touch &amp; hold the fingerprint sensor.</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 try and enroll again[CHAR LIMIT=22] -->
    <string name="security_settings_fingerprint_enroll_dialog_try_again">Try again</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>
    <!-- Message shown in UDFPS enrollment dialog to begin enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_udfps_enroll_start_message">Keep your fingerprint flat on the sensor until you feel a vibration</string>
    <!-- Message shown in SFPS enrollment dialog to begin enrollment [CHAR LIMIT=NONE] -->
    <string name="security_settings_sfps_enroll_start_message">Without pressing the button, keep your fingerprint on the sensor until you feel a vibration.\n\nMove your finger slightly each time. This helps capture more of your fingerprint.</string>
    <!-- Title shown in fingerprint enrollment [CHAR LIMIT=NONE]-->
    <string name="security_settings_fingerprint_enroll_udfps_title">Touch &amp; hold the fingerprint sensor</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>
    <!-- Title shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=40] -->
    <string name="security_settings_udfps_enroll_title_one_more_time">One more time</string>
    <!-- Title shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=60] -->
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon">Follow the fingerprint icon</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>
    <!-- Message shown in fingerprint enrollment dialog to repeat touching the fingerprint sensor [CHAR LIMIT=160] -->
    <string name="security_settings_udfps_enroll_repeat_message">Touch &amp; hold each time the fingerprint icon moves. This helps capture more of your fingerprint.</string>
    <!-- Title shown during fingerprint enrollment that instructs the user to enroll their fingertip [CHAR LIMIT=80] -->
    <string name="security_settings_udfps_enroll_fingertip_title">Place the tip of your finger on the sensor</string>
    <!-- Title shown during fingerprint enrollment that instructs the user to enroll the left edge of their finger [CHAR LIMIT=80] -->
    <string name="security_settings_udfps_enroll_left_edge_title">Place the left edge of your finger</string>
    <!-- Title shown during fingerprint enrollment that instructs the user to enroll the right edge of their finger [CHAR LIMIT=80] -->
    <string name="security_settings_udfps_enroll_right_edge_title">Place the right edge of your finger</string>
    <!-- Title shown during SFPS enrollment that instructs the user to enroll the center of their finger [CHAR LIMIT=80] -->
    <string name="security_settings_sfps_enroll_finger_center_title">Place the center part of your finger on the sensor</string>
    <!-- Title shown during SFPS enrollment that instructs the user to enroll their fingertip [CHAR LIMIT=80] -->
    <string name="security_settings_sfps_enroll_fingertip_title">Place the tip of your finger on the sensor</string>
    <!-- Title shown during SFPS enrollment that instructs the user to enroll the left edge of their finger [CHAR LIMIT=80] -->
    <string name="security_settings_sfps_enroll_left_edge_title">Place the left edge of your finger on the sensor</string>
    <!-- Title shown during SFPS enrollment that instructs the user to enroll the right edge of their finger [CHAR LIMIT=80] -->
    <string name="security_settings_sfps_enroll_right_edge_title">Finally, place the right edge of your finger on the sensor</string>
    <!-- Message shown during fingerprint enrollment that instructs the user to enroll the edges of their finger [CHAR LIMIT=160] -->
    <string name="security_settings_udfps_enroll_edge_message">Place the side of your fingerprint on the sensor and hold, then switch to the other side</string>
    <!-- Message shown in fingerprint enrollment asking users to repeat touching the fingerprint sensor. [CHAR LIMIT=160] -->
    <string name="security_settings_udfps_enroll_repeat_a11y_message">This helps capture more of your fingerprint</string>
    <!-- Message read to a11y users when SFPS enrollment progress is made. The number is from 0 to 100. [CHAR LIMIT=NONE]-->
    <string name="security_settings_sfps_enroll_progress_a11y_message">Enrolling fingerprint <xliff:g id="percentage" example="10">%d</xliff:g> percent</string>
    <!-- a11y label on finger animation indicating SFPS enrollment progress. The number is from 0 to 100. [CHAR LIMIT=NONE]-->
    <string name="security_settings_sfps_animation_a11y_label">Enrolled <xliff:g id="percentage" example="10">%d</xliff:g> percent</string>
    <!-- Message read to a11y users when UDFPS enrollment progress is made. The number is from 0 to 100. [CHAR LIMIT=NONE]-->
    <string name="security_settings_udfps_enroll_progress_a11y_message">Enrolling fingerprint <xliff:g id="percentage" example="10">%d</xliff:g> percent</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>
    <!-- Key for require screen on to auth toggle shown in fingerprint enrollment dialog once enrollment is completed. [CHAR LIMIT=NONE] -->
    <string name="security_settings_require_screen_on_to_auth_key" translatable="false">security_settings_require_screen_on_to_auth</string>
    <!-- Title for require screen on to auth toggle shown in fingerprint enrollment dialog once enrollment is completed. [CHAR LIMIT=NONE] -->
    <string name="security_settings_require_screen_on_to_auth_title">Touch to unlock anytime</string>
    <!-- Description for require screen on to auth toggle shown in fingerprint enrollment dialog once enrollment is completed. [CHAR LIMIT=NONE] -->
    <string name="security_settings_require_screen_on_to_auth_description">Touch the sensor to unlock, even when the screen is off. This makes accidental unlocking more likely.</string>
    <!-- Description for require screen on to auth toggle shown in fingerprint enrollment dialog once enrollment is completed. [CHAR LIMIT=NONE] -->
    <string name="security_settings_require_screen_on_to_auth_keywords">Screen, Unlock</string>
    <!-- Button text to skip enrollment of fingerprint [CHAR LIMIT=40] -->
    <string name="security_settings_fingerprint_enroll_enrolling_skip">Do it later</string>
    <!-- Accessibility message for fingerprint enrollment asking the user to place the tip of their finger on the fingerprint sensor [CHAR LIMIT=NONE] -->
    <string name="security_settings_udfps_tip_fingerprint_help">Lift, then touch again</string>
    <!-- Accessibility message for fingerprint enrollment asking the user to place the sides of their finger on the fingerprint sensor [CHAR LIMIT=NONE] -->
    <string name="security_settings_udfps_side_fingerprint_help">Place the side of your fingerprint on the sensor and hold, then switch to the other side</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>
    <!-- Title of dialog shown when the user tries to skip for setup screen lock, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_skip_setup_title">Skip setup for <xliff:g id="options" example="PIN • Face • Fingerprint">%s</xliff:g>?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a PIN, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pin_skip_title">Skip PIN setup?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a PIN, warning them of potential consequences of not doing so [CHAR LIMIT=90]-->
    <string name="lock_screen_pin_skip_face_title">Skip setup for PIN and face?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a PIN, warning them of potential consequences of not doing so [CHAR LIMIT=90]-->
    <string name="lock_screen_pin_skip_fingerprint_title">Skip setup for PIN and fingerprint?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a PIN, warning them of potential consequences of not doing so [CHAR LIMIT=90]-->
    <string name="lock_screen_pin_skip_biometrics_title">Skip setup for PIN, face, and fingerprint?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a password, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_password_skip_title">Skip password setup?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a password, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_password_skip_face_title">Skip setup for password and face?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a password, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_password_skip_fingerprint_title">Skip setup for password and fingerprint?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a password, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_password_skip_biometrics_title">Skip setup for password, face, and fingerprint?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a pattern, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pattern_skip_title">Skip pattern setup?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a pattern, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pattern_skip_face_title">Skip setup for pattern and face?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a pattern, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pattern_skip_fingerprint_title">Skip setup for pattern and fingerprint?</string>
    <!-- Title of dialog shown when the user tries to skip setting up a pattern, warning them of potential consequences of not doing so [CHAR LIMIT=48]-->
    <string name="lock_screen_pattern_skip_biometrics_title">Skip setup for pattern, face, and fingerprint?</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 processed in enrollment. [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title">Can\u2019t complete fingerprint setup</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled because the HAL is unable to process it (SUW). -->
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup">You can try again now or set up your fingerprint later in Settings.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled because the HAL is unable to process it. -->
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message">You can try again now or set up your fingerprint later.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled. [CHAR LIMIT=45] -->
    <string name="security_settings_fingerprint_enroll_error_dialog_title">Fingerprint setup timed out</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled due to being idle too long (SUW). -->
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup">You can set up your fingerprint later in Settings.</string>
    <!-- Dialog message for dialog which shows when finger cannot be enrolled due to an internal error or fingerprint can't be read (SUW). -->
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup">Something went wrong. You can set up your fingerprint later in Settings.</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">You can set up your fingerprint later.</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">Something went wrong. You can set up your fingerprint later.</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 in the case unlocking is disabled [CHAR LIMIT=NONE] -->
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1">The screen lock option is disabled. To learn more, contact your organization\u2019s admin.</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_fingerprint_disclaimer_lockscreen_disabled_2">You can still use your fingerprint to authorize purchases and app access.</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>
    <!-- Dialog title during fingerprint enrollment to indicate bad sensor calibration. [CHAR LIMIT=100] -->
    <string name="security_settings_fingerprint_bad_calibration_title">Can\u2019t use fingerprint sensor</string>
    <!-- Text shown during fingerprint enrollment to indicate bad sensor calibration. [CHAR LIMIT=100] -->
    <string name="security_settings_fingerprint_bad_calibration">Visit a repair provider.</string>
    <!-- Title for the section that has additional security settings. [CHAR LIMIT=60] -->
    <string name="security_advanced_settings">More security settings</string>
    <!-- String for the "More security settings" summary when a work profile is on the device. [CHAR_LIMIT=NONE] -->
    <string name="security_advanced_settings_work_profile_settings_summary">Work profile lock, encryption, and more</string>
    <!-- Summary string for the "More security settings" section. [CHAR_LIMIT=NONE] -->
    <string name="security_advanced_settings_no_work_profile_settings_summary">Encryption, credentials, and more</string>
    <!-- Search keywords for the "More security settings" section in security settings. [CHAR_LIMIT=NONE] -->
    <string name="security_advanced_settings_keywords">security, more security settings, more settings, advanced security settings</string>
    <!-- Title for the section that has additional privacy settings. [CHAR LIMIT=60] -->
    <string name="privacy_advanced_settings">More privacy settings</string>

    <!-- Title for the subpage in the "Security & privacy". This page consists of the more security and privacy settings. Can be navigated by Settings -> Security & privacy -> More security & privacy [CHAR LIMIT=NONE] -->
    <string name="more_security_privacy_settings">More security &amp; privacy</string>
    <!-- Title for the section that has security entries in the More security & privacy page. Also used for Private Space security category. [CHAR LIMIT=60] -->
    <string name="security_header">Security</string>
    <!-- Title for the section that has privacy entries in the More security & privacy page. [CHAR LIMIT=60] -->
    <string name="privacy_header">Privacy</string>
    <!-- Title for the section that has work profile entries in the More security & privacy page. [CHAR LIMIT=60] -->
    <string name="work_profile_category_header">Work profile</string>

    <!-- Title for the Private Space page. [CHAR LIMIT=60] -->
    <string name="private_space_title">Private space</string>
    <!-- Summary for the Private Space page. [CHAR LIMIT=NONE] -->
    <string name="private_space_summary">Keep private apps locked and hidden</string>
    <!-- Description for the Private Space page. [CHAR LIMIT=NONE] -->
    <string name="private_space_description">Keep private apps in a separate space that you can hide or lock</string>
    <!-- Title for the Private Space one lock preference. [CHAR LIMIT=60] -->
    <string name="private_space_lock_title">Private space lock</string>
    <!-- Description for the Private Space one lock preference page. [CHAR LIMIT=NONE] -->
    <string name="private_space_one_lock_summary">You can unlock your private space the same way you unlock your device, or choose a different lock</string>
    <!-- Title for the Private Space one lock preference. [CHAR LIMIT=60] -->
    <string name="private_space_screen_lock_title">Use device screen lock</string>
    <!-- Title for the Face and Fingerprint preference. [CHAR LIMIT=60] -->
    <string name="private_space_biometric_title">Face &amp; Fingerprint Unlock</string>
    <!-- Title for the Fingerprint preference when face hardware is not supported on device. [CHAR LIMIT=40] -->
    <string name="private_space_fingerprint_title">Fingerprint Unlock</string>
    <!-- Title for the Face preference when fingerprint unlock is not supported on device. [CHAR LIMIT=40] -->
    <string name="private_space_face_title">Face Unlock</string>
    <!-- Summary for the Face and Fingerprint preference when no biometric is set. [CHAR LIMIT=60] -->
    <string name="private_space_biometric_summary">Tap to set up</string>
    <!-- Title for the Fingerprint unlock for private space preference. [CHAR LIMIT=60] -->
    <string name="private_space_fingerprint_unlock_title">Fingerprint Unlock for private space</string>
    <!-- Title for the Face unlock for private space preference. [CHAR LIMIT=60] -->
    <string name="private_space_face_unlock_title">Face Unlock for private space</string>
    <!-- Biometric category title - biometric options for unlocking the device. [CHAR LIMIT=50] -->
    <string name="private_space_category_ways_to_unlock">Ways to unlock</string>
    <!-- Summary for one lock when device screen lock is used as private profile lock. [CHAR LIMIT=40] -->
    <string name="private_space_screen_lock_summary">Same as device screen lock</string>
    <!-- Dialog message to choose a new lock for Private Space. [CHAR LIMIT=50] -->
    <string name="private_space_new_lock_title">Choose a new lock for private space?</string>
    <!-- Title for the preference for auto lock private space and auto lock private space settings page. [CHAR LIMIT=50] -->
    <string name="private_space_auto_lock_title">Lock private space automatically</string>
    <!-- Description for private space auto lock settings page. [CHAR LIMIT=NONE] -->
    <string name="private_space_auto_lock_page_summary">You can lock your private space automatically if you haven\’t used your device for a period of time</string>
    <!-- Configure auto lock: Value for auto lock configuration to lock private space every time device locks. [CHAR LIMIT=40] -->
    <string name="private_space_auto_lock_every_time">Every time device locks</string>
    <!-- Configure auto lock: Value for auto lock configuration to lock private space after 5 minutes of inactivity. [CHAR LIMIT=40] -->
    <string name="private_space_auto_lock_after_inactivity">After 5 minutes of inactivity</string>
    <!-- Configure auto lock: Value for auto lock configuration to never lock private space. [CHAR LIMIT=20] -->
    <string name="private_space_auto_lock_never">Never</string>
    <!-- Title for the preference to hide Private Space. [CHAR LIMIT=60] -->
    <string name="private_space_hide_title">Hide when locked</string>
    <!-- Title for the hide Private Space setting. [CHAR LIMIT=60] -->
    <string name="privatespace_hide_page_title">Hide private space when locked</string>
    <!-- Description for hide Private Space settings page. [CHAR LIMIT=NONE] -->
    <string name="privatespace_hide_page_summary">To stop other people knowing you have a private space on your device, you can hide it from your apps list</string>
    <!-- Header in hide Private Space settings page to access Private Space when hidden. [CHAR LIMIT=60] -->
    <string name="privatespace_access_header">Access private space when hidden</string>
    <!-- Text in hide Private Space settings page on how to search Private Space when hidden. [CHAR LIMIT=90] -->
    <string name="privatespace_search_description">From your apps list, enter \"private space\" in the search bar</string>
    <!-- Text in hide Private Space settings page to tap on Private Space tile. [CHAR LIMIT=60] -->
    <string name="privatespace_tap_tile_description">Tap the private space tile</string>
    <!-- Text in hide Private Space settings page to Unlock Private Space. [CHAR LIMIT=60] -->
    <string name="privatespace_unlock_description">Unlock your private space</string>
    <!-- Used to describe the off state of Private space hidden [CHAR LIMIT=30] -->
    <string name="privatespace_hide_off_summary">Off</string>
    <!-- Used to describe the off state of Private space hidden [CHAR LIMIT=30] -->
    <string name="privatespace_hide_on_summary">On</string>
    <!-- System category for the Private Space page. [CHAR LIMIT=30] -->
    <string name="private_space_category_system">System</string>
    <!-- Title for the preference to delete Private Space. [CHAR LIMIT=40] -->
    <string name="private_space_delete_title">Delete private space</string>
    <!-- Title for the delete private space page. [CHAR LIMIT=40] -->
    <string name="private_space_delete_header">Delete private space?</string>
    <!-- Description for hide Private Space settings page. [CHAR LIMIT=NONE] -->
    <string name="private_space_delete_summary">Your private space will be removed from your device. All private apps and data will be deleted. You can’t undo this action.</string>
    <!-- Text for the accounts added to private space that will be removed. [CHAR LIMIT=90] -->
    <string name="private_space_accounts">The following accounts will be removed from your private space:</string>
    <!-- Label for private space delete button [CHAR LIMIT=30] -->
    <string name="private_space_delete_button_label">Delete</string>
    <!-- Title for the private space delete confirmation page. [CHAR LIMIT=40] -->
    <string name="private_space_confirm_deletion_header">Deleting private space\u2026</string>
    <!-- Description for private space delete confirmation page that mentions it will take a few moments. [CHAR LIMIT=40] -->
    <string name="private_space_confirm_deletion_summary">This will take a few moments</string>
    <!-- Toast to show when the private space was deleted. [CHAR LIMIT=NONE] -->
    <string name="private_space_deleted">Private space deleted</string>
    <!-- Toast to show when the private space could not be deleted. [CHAR LIMIT=NONE] -->
    <string name="private_space_delete_failed">Private space could not be deleted</string>
    <!-- Toast to show when the private space is unlocked from settings entry point. [CHAR LIMIT=40] -->
    <string name="private_space_unlocked">Private space unlocked</string>
    <!-- Title of the Alert Dialog when no screen lock is set [CHAR LIMIT=30] -->
    <string name="no_device_lock_title">Set a screen lock</string>
    <!-- Summary of the alert when no screen lock is set [CHAR LIMIT=90] -->
    <string name="no_device_lock_summary">To use your private space, set a screen lock on this device</string>
    <!-- Action label for dialog when no screen lock is set [CHAR LIMIT=30] -->
    <string name="no_device_lock_action_label">Set screen lock</string>
    <!-- Action label to cancel Alert dialog when no screen lock is set [CHAR LIMIT=30] -->
    <string name="no_device_lock_cancel">Cancel</string>
    <!-- Action label to cancel private space Setup flow [CHAR LIMIT=30] -->
    <string name="private_space_cancel_label">Cancel</string>
    <!-- Label for private space setup button to create private space [CHAR LIMIT=30] -->
    <string name="private_space_setup_button_label">Set up</string>
    <!-- Title for Private Space setup education screen. [CHAR LIMIT=50] -->
    <string name="private_space_setup_title">Set up a private space</string>
    <!-- Summary for the private space setup education screen. [CHAR LIMIT=NONE] -->
    <string name="private_space_hide_apps_summary">Keep private apps in a separate space that you can hide or lock</string>
    <!-- Text shown in private space setup screen which explains how the private space works [CHAR LIMIT=50] -->
    <string name="private_space_how_title">How it works</string>
    <!-- Text shown in private space setup screen which explains private space can be accessed from bottom of all apps list. [CHAR LIMIT=NONE] -->
    <string name="private_space_access_bottom_text">You can access your private space from the bottom of your apps list</string>
    <!-- Text shown in private space setup screen which explains private space apps are protected by a lock. [CHAR LIMIT=60] -->
    <string name="private_space_protected_lock_text">Apps in your private space are protected by a lock</string>
    <!-- Text shown in private space setup screen which explains notifications from private space apps will not be shown when private space is locked. [CHAR LIMIT=NONE] -->
    <string name="private_space_hidden_notifications_text">Notifications from apps in your private space are hidden when it\u2019s locked</string>
    <!-- This is info text to help explain in private space setup screen that the permissions granted to private space apps will not be shown in settings when private space is locked. [CHAR LIMIT=NONE] -->
    <string name="private_space_apps_permission_text">Apps in your private space won\'t appear in permission manager, privacy dashboard, and other settings when your private space is locked.\n\nYour private space can\'t be moved to a new device. You\'ll need to set up another private space if you want to use it on another device.\n\nAnyone that connects your device to a computer or installs harmful apps on your device may be able to access your private space.</string>
    <!-- Text shown at the bottom in private space auto advancing  screens. [CHAR LIMIT=60] -->
    <string name="private_space_setting_up_text">Setting up private space\u2026</string>
    <!-- Title for private space setup in auto advancing screen informing private space notifications are hidden when locked. [CHAR LIMIT=NONE] -->
    <string name="private_space_notifications_hidden_title">Notifications from private space apps are hidden when it\u2019s locked</string>
    <!-- Title for private space setup in auto advancing screen informing photos/files from private space can be shared when unlocked. [CHAR LIMIT=NONE] -->
    <string name="private_space_share_photos_title">Unlock private space to share photos or files</string>
    <!-- Title for private space setup in auto advancing screen informing some system apps are already installed in private space. [CHAR LIMIT=NONE] -->
    <string name="private_space_apps_installed_title">Some apps are already installed in your private space</string>
    <!-- Title for private space creation error screen. [CHAR LIMIT=60] -->
    <string name="private_space_error_screen_title">Couldn\u2019t set up a private space</string>
    <!-- Label for button to retry creating private space again on creation error. [CHAR LIMIT=30] -->
    <string name="private_space_tryagain_label">Try Again</string>
    <!-- Title for private space lock setup screen. [CHAR LIMIT=90] -->
    <string name="private_space_lockscreen_title">Use screen lock to unlock private space?</string>
    <!-- Summary for the private space lock setup screen. [CHAR LIMIT=NONE] -->
    <string name="private_space_lockscreen_summary">You can unlock your private space the same way you unlock your device, or choose a different lock</string>
    <!-- Action label to use existing device lock for private space. [CHAR LIMIT=50] -->
    <string name="private_space_use_screenlock_label">Use screen lock</string>
    <!-- Label for private space lock setup button to choose a new lock. [CHAR LIMIT=50] -->
    <string name="private_space_set_lock_label">Choose new lock</string>
    <!-- Title for private space setup success screen. [CHAR LIMIT=30] -->
    <string name="private_space_success_title">All set!</string>
    <!-- Summary for the private space setup success screen. [CHAR LIMIT=NONE] -->
    <string name="private_space_access_text">To find your private space, go to your apps list then scroll down</string>
    <!-- Label for private space done button to show a toast, finish setup and launch All apps [CHAR LIMIT=30] -->
    <string name="private_space_done_label">Done</string>
    <!-- Toast to show on private space setup completion informing user to scroll down All apps to access private space. [CHAR LIMIT=60] -->
    <string name="private_space_scrolldown_to_access">Scroll down to find private space</string>
    <!-- Title for private space account login error screen. [CHAR LIMIT=30] -->
    <string name="private_space_retry_signin_title">Sign in</string>
    <!-- Summary for the private space account login error screen. [CHAR LIMIT=NONE] -->
    <string name="private_space_retry_summary">Sign in to an account to use with your private space</string>
    <!-- Label for button to skip private space account sign in. [CHAR LIMIT=30] -->
    <string name="private_space_skip_login_label">Not now</string>
    <!-- Label for button to coninue with private space account sign in. [CHAR LIMIT=30] -->
    <string name="private_space_continue_login_label">Continue</string>
    <!-- private space lock setup screen title. This title is asking the user to choose a type of screen lock (such as a pattern, PIN, or password) that they need to enter to unlock private space. [CHAR LIMIT=60] -->
    <string name="private_space_lock_setup_title">Choose a lock for your private space</string>
    <!-- private space lock setup screen description [CHAR LIMIT=NONE] -->
    <string name="private_space_lock_setup_description">You can unlock your private space using your fingerprint. For security, this option requires a backup lock.</string>
    <!-- Header for private space choose your PIN screen [CHAR LIMIT=40] -->
    <string name="private_space_choose_your_pin_header">Set a PIN for your private space</string>
    <!-- Header for private space choose your password screen [CHAR LIMIT=40] -->
    <string name="private_space_choose_your_password_header">Set a password for your private space</string>
    <!-- Header for private space choose your pattern screen [CHAR LIMIT=40] -->
    <string name="private_space_choose_your_pattern_header">Set a pattern for your private space</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 a single fingerprint gets deleted. [CHAR LIMIT=50]-->
    <string name="fingerprint_delete_title">Delete \'<xliff:g id="fingerprint_id" example="Fingerprint 2">%1$s</xliff:g>\'</string>
    <string name="fingerprint_last_delete_message_profile_challenge">You won\'t be able to use your fingerprint to unlock your work profile, authorize purchases, or sign in to work apps.</string>

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

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

    <!-- Title of the issue card in Safety Center when no screen lock is set [CHAR LIMIT=50] -->
    <string name="no_screen_lock_issue_title">Set a screen lock</string>
    <!-- Summary of the issue card in Safety Center when no screen lock is set [CHAR LIMIT=NONE] -->
    <string name="no_screen_lock_issue_summary">For added security, set a PIN, pattern, or password for this device.</string>
    <!-- Action label for the issue card in Safety Center when no screen lock is set [CHAR LIMIT=50] -->
    <string name="no_screen_lock_issue_action_label">Set screen lock</string>
    <!-- Title of the notification shown by Safety Center when no screen lock is set. This notification is shown in the notification shade, outside of the main Safety Center UI. [CHAR LIMIT=50] -->
    <string name="no_screen_lock_issue_notification_title">Set a screen lock</string>
    <!-- Summary/body text of the notification shown by Safety Center when no screen lock is set. This notification is shown in the notification shade, outside of the main Safety Center UI. [CHAR LIMIT=NONE] -->
    <string name="no_screen_lock_issue_notification_text">For added security, set a PIN, pattern, or password for this device.</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>

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

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

    <!--  Screen title. This title is asking the user to choose a type of screen lock for their device, such as a pattern, PIN, or password. [CHAR LIMIT=55] -->
    <string name="lock_settings_picker_new_lock_title">Choose a screen lock</string>

    <!--  Screen title. This title is asking the user to choose a new screen lock for their device, such as a pattern, PIN, or password. [CHAR LIMIT=55] -->
    <string name="lock_settings_picker_update_lock_title">Choose a new screen lock</string>

    <!--  Screen title. This title is asking the user to choose a type of screen lock (such as a pattern, PIN, or password) that they need to enter to use their work apps. [CHAR LIMIT=56] -->
    <string name="lock_settings_picker_new_profile_lock_title">Choose a lock for work apps</string>

    <!--  Screen title. This title is asking the user to choose a new screen lock (such as a pattern, PIN, or password) that they need to enter to use their work apps. [CHAR LIMIT=55] -->
    <string name="lock_settings_picker_update_profile_lock_title">Choose a new work lock</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_biometrics_added_security_message">For added security, set a backup screen lock</string>

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

    <!-- Text shown on the screen lock menu. This text is letting the user know that their IT admin can't reset their screen lock if they forget it. [CHAR LIMIT=100] -->
    <string name="lock_settings_picker_admin_restricted_personal_message">If you forget your screen lock, your IT admin can\u2019t reset it.</string>
    <!-- Text shown on the screen lock menu. This text is letting the user know that they can choose to set another lock that would be specifically for their work apps. [CHAR LIMIT=100] -->
    <string name="lock_settings_picker_admin_restricted_personal_message_action">Set a separate work lock</string>

    <!-- Message shown in screen lock picker for setting up a work profile screen lock. [CHAR LIMIT=80] -->
    <string name="lock_settings_picker_profile_message">If you forget this lock, ask your IT admin to reset it</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>

    <!-- Title of the lock screen auto pin confirm setting. [CHAR LIMIT=NONE] -->
    <string name="lock_screen_auto_pin_confirm_title">Auto-confirm unlock</string>
    <!-- Summary of the lock screen auto pin confirm setting. [CHAR LIMIT=NONE] -->
    <string name="lock_screen_auto_pin_confirm_summary">Unlock automatically if you input a correct PIN of 6 digits or more. This is slightly less secure than tapping Enter to confirm.</string>
    <!-- Message shown to check auto pin confirmation feature when the user is updating the PIN. [CHAR LIMIT=NONE] -->
    <string name="auto_pin_confirm_user_message">Auto-confirm correct PIN</string>
    <!-- Message shown to explain the security concern if a user opts-in to the auto-pin feature. [CHAR LIMIT=NONE] -->
    <string name="auto_pin_confirm_opt_in_security_message">Confirming your PIN by tapping Enter is more secure than using auto-confirm</string>
    <!-- Description of pin confirmation screen when auto confirm setting is turned on. [CHAR LIMIT=NONE] -->
    <string name="auto_confirm_on_pin_verify_description">Enter device PIN to enable auto-confirm</string>
    <!-- Description of pin confirmation screen when auto confirm setting is turned off. [CHAR LIMIT=NONE] -->
    <string name="auto_confirm_off_pin_verify_description">Enter device PIN to disable auto-confirm</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>

    <!--  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 preference that disables unlock security [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_off_title">None</string>

    <!-- Title for preference that disables unlock security [CHAR LIMIT=22] -->
    <string name="unlock_set_unlock_none_title">Swipe</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>

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

    <!-- 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 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">Pattern \u2022 Fingerprint</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">PIN \u2022 Fingerprint</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">Password \u2022 Fingerprint</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>

    <!-- Title for preference that guides the user through creating a backup unlock pattern for Face Unlock [CHAR LIMIT=45]-->
    <string name="face_unlock_set_unlock_pattern">Pattern \u2022 Face</string>
    <!-- Title for preference that guides the user through creating a backup unlock PIN for Face Unlock [CHAR LIMIT=45]-->
    <string name="face_unlock_set_unlock_pin">PIN \u2022 Face</string>
    <!-- Title for preference that guides the user through creating a backup unlock password for Face Unlock [CHAR LIMIT=45]-->
    <string name="face_unlock_set_unlock_password">Password \u2022 Face</string>
    <!-- Title for preference that guides the user to skip Face Unlock setup [CHAR LIMIT=60]-->
    <string name="face_unlock_skip_face">Continue without Face Unlock</string>

    <!-- Title for preference that guides the user to skip face unlock setup [CHAR LIMIT=60]-->
    <string name="biometrics_unlock_skip_biometrics">Continue without fingerprint or face</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>

    <!-- Title of the dialog shown when the user removes the device lock [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_title">Remove all types of device unlock?</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">"A pattern protects your phone if it\u2019s lost or stolen"</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">"A pattern protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>This also deletes the fingerprint model stored on your device. You won\u2019t be able to use your fingerprint for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock pattern and the user has face authentication enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_face">"A pattern protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock pattern and the user has face authentication and fingerprint enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint">"A pattern protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face or fingerprint for authentication in apps."</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">"A PIN protects your phone if it\u2019s lost or stolen"</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and there are apps with auth-bound keys that will be affected [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys">"You will lose saved data like your PIN.<xliff:g id="empty_line">\n\n</xliff:g>Cards set up for tap to pay will be removed.<xliff:g id="empty_line">\n\n</xliff:g>Wallets and other apps that require device unlock may not work properly."</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">"A PIN protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>This also deletes the fingerprint model stored on your device. You won\u2019t be able to use your fingerprint for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has fingerprints enrolled and there are apps with auth-bound keys that will be affected [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys">"You will lose saved data like your PIN and fingerprint model.<xliff:g id="empty_line">\n\n</xliff:g>Cards set up for tap to pay will be removed.<xliff:g id="empty_line">\n\n</xliff:g>Wallets and other apps that require device unlock may not work properly."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has face enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_face">"A PIN protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has face enrolled and there are apps with auth-bound keys that will be affected [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys">"You will lose saved data like your PIN and face model.<xliff:g id="empty_line">\n\n</xliff:g>Cards set up for tap to pay will be removed.<xliff:g id="empty_line">\n\n</xliff:g>Wallets and other apps that require device unlock may not work properly."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has face authentication and fingerprint enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint">"A PIN protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face or fingerprint for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock PIN and the user has face authentication and fingerprint enrolled and there are apps with auth-bound keys that will be affected [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys">"You will lose saved data like your PIN, face and fingerprint models.<xliff:g id="empty_line">\n\n</xliff:g>Cards set up for tap to pay will be removed.<xliff:g id="empty_line">\n\n</xliff:g>Wallets and other apps that require device unlock may not work properly."</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">"A password protects your phone if it\u2019s lost or stolen"</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">"A password protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>This also deletes the fingerprint model stored on your device. You won\u2019t be able to use your fingerprint for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock password and the user has face enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_face">"A password protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock password and the user has face authentication and fingerprint enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint">"A password protects your phone if it\u2019s lost or stolen.<xliff:g id="empty_line">\n\n</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face or fingerprint for authentication in apps."</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>This also deletes the fingerprint model stored on your device. You won\u2019t be able to use your fingerprint for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock of unknown type and the user has face enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_face">"Device protection features will not work without your screen lock.<xliff:g id="empty_line">\n\n</xliff:g>Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face for authentication in apps."</string>
    <!-- Content of the dialog shown when the user removes the device lock of unknown type and the user has face authentication and fingerprint enrolled [CHAR LIMIT=NONE] -->
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint">"Device protection features will not work without your screen lock.<xliff:g id="empty_line">\n\n</xliff:g>This deletes the fingerprint model stored on your device. Your face model will also be permanently and securely deleted. You won\u2019t be able to use your face or fingerprint for authentication in apps."</string>

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

    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock and that it requests for a strong PIN or password  [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_high_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a strong PIN or password and may not work as expected without one</string>
    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock and that it requests for a medium strength PIN or password [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_medium_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a new PIN or password and may not work as expected without one</string>
    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock and it requests for any screen lock [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_low_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a new pattern, PIN, or password and may not work as expected without one</string>
    <!-- Footer preference text in the screen lock type picker to indicate which app is requesting a new screen lock [CHAR LIMIT=NONE] -->
    <string name="unlock_footer_none_complexity_requested"><xliff:g id="app_name" example="Gmail">%1$s</xliff:g> recommends a new screen lock</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>

    <!-- Hint shown in dialog screen when password is too short -->
    <string name="lockpassword_password_too_short">{count, plural,
      =1      {Must contain at least # character}
      other   {Must be at least # characters}
    }</string>
    <!-- Hint shown in dialog screen when password is too short and only using numbers. [CHAR LIMIT=NONE] -->
    <string name="lockpassword_password_too_short_all_numeric">
        {count, plural,
            =1    {If using only numbers, must be at least 1 digit}
            other {If using only numbers, must be at least # digits}
        }
    </string>
    <!-- Hint shown in dialog screen when PIN is too short -->
    <string name="lockpassword_pin_too_short">{count, plural,
      =1      {PIN must contain at least # digit}
      other   {PIN must be at least # digits}
    }</string>

    <!-- Hint shown in dialog screen when PIN is too short with Additional text indicating minAutoConfirmLen(eg: 6) digits PIN offer additional security -->
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message">{count, plural,
        =1      {PIN must contain at least # digit, but a {minAutoConfirmLen}-digit PIN is recommended for added security}
        other   {PIN must be at least # digits, but a {minAutoConfirmLen}-digit PIN is recommended for added security}
        }</string>

    <!-- Error shown in popup when password is too long -->
    <string name="lockpassword_password_too_long">{count, plural,
      =1      {Must be fewer than # character}
      other   {Must be fewer than # characters}
    }</string>
    <!-- Error shown in popup when PIN is too long -->
    <string name="lockpassword_pin_too_long">{count, plural,
      =1      {Must be fewer than # digit}
      other   {Must be fewer than # digits}
    }</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 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 doesn't contain the required number of letters -->
    <string name="lockpassword_password_requires_letters">{count, plural,
      =1      {Must contain at least 1 letter}
      other   {Must contain at least # letters}
    }</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of lowercase letters -->
    <string name="lockpassword_password_requires_lowercase">{count, plural,
      =1      {Must contain at least 1 lowercase letter}
      other   {Must contain at least # lowercase letters}
    }</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of uppercase letters -->
    <string name="lockpassword_password_requires_uppercase">{count, plural,
      =1      {Must contain at least 1 uppercase letter}
      other   {Must contain at least # uppercase letters}
    }</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of numerical digits -->
    <string name="lockpassword_password_requires_numeric">{count, plural,
      =1      {Must contain at least 1 numerical digit}
      other   {Must contain at least # numerical digits}
    }</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of special symbols -->
    <string name="lockpassword_password_requires_symbols">{count, plural,
      =1      {Must contain at least 1 special symbol}
      other   {Must contain at least # special symbols}
    }</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of non-letter characters -->
    <string name="lockpassword_password_requires_nonletter">{count, plural,
      =1      {Must contain at least 1 non-letter character}
      other   {Must contain at least # non-letter characters}
    }</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain the required number of non-numerical characters -->
    <string name="lockpassword_password_requires_nonnumerical">{count, plural,
      =1      {Must contain at least 1 non-numerical character}
      other   {Must contain at least # non-numerical characters}
    }</string>

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

    <!-- [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 Clear button that clears all text entered by the user so far. -->
    <string name="lockpassword_clear_label">Clear</string>

    <!-- Toast for a failed password change attempt when the old credential has been changed. [CHAR LIMIT=120]-->
    <string name="lockpassword_credential_changed">Screen lock was already changed. Try again with the new screen lock.</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>

    <!-- 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 -->
    <string name="number_of_device_admins">{count, plural,
      =1      {# active app}
      other   {# active apps}
    }</string>

    <!-- 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-->
    <string name="manage_trust_agents_summary_on">{count, plural,
      =1      {1 active trust agent}
      other   {# active trust agents}
    }</string>

    <!-- Bluetooth settings -->
    <!--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>

    <!-- ======================================================================================= -->
    <!-- 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 a bluetooth device from a coordinated set is bonding late. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_group_late_bonding">Confirm to add the second piece of your audio device</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>

    <!-- Pairing dialog text to remind user the pairing including all of the devices in a coordinated set. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_paring_group_msg">Confirm to pair with the audio device</string>

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

    <!-- Phonebook sharing toggle message in pairing dialogs.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_phonebook_toggle_text">Also allow access to contacts and call history</string>

    <!-- Phonebook sharing toggle detailed message in pairing dialogs.  [CHAR LIMIT=NONE] -->
    <string name="bluetooth_pairing_phonebook_toggle_details">Info will be used for call announcements and more</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 sub heading for available devices during and after scanning. [CHAR LIMIT=40] -->
    <string name="bluetooth_preference_found_media_devices">Available devices</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. Text displayed when Bluetooth is off and device list is empty [CHAR LIMIT=NONE]-->
    <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 Bluetooth scanning settings.</string>
    <!-- Bluetooth settings. Link text to bring the user to "scanning settings" screen. [CHAR LIMIT=NONE]-->
    <string name="bluetooth_scan_change">Change</string>

    <!-- Title of device details screen [CHAR LIMIT=28]-->
    <string name="device_details_title">Device details</string>
    <!-- Title for keyboard settings preferences. [CHAR LIMIT=50] -->
    <string name="bluetooth_device_keyboard_settings_preference_title">Keyboard settings</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>
    <!-- Title of the items to show multuple devices MAC address [CHAR LIMIT=NONE]-->
    <string name="bluetooth_multuple_devices_mac_address">Device\'s Bluetooth address:\n<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>
    <!-- Content Description for companion device app associations removal button [CHAR LIMIT=28]-->
    <string name="remove_association_button">Remove association</string>
    <!-- Bluetooth device details companion apps. The title of a confirmation dialog for remove an app. [CHAR LIMIT=60] -->
    <string name="bluetooth_companion_app_remove_association_dialog_title">Disconnect App?</string>
    <!-- Bluetooth device details companion apps. The body of confirmation dialog for remove association. [CHAR LIMIT=60] -->
    <string name="bluetooth_companion_app_body"><xliff:g id="app_name" example="App Name">%1$s</xliff:g> app will no longer connect to your <xliff:g id="device_name" example="Device Name">%2$s</xliff:g></string>
    <!-- Summary of Bluetooth LE Audio toggle in Device Details. [CHAR LIMIT=40] -->
    <string name="device_details_leaudio_toggle_summary">Experimental. Improves audio quality.</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 device details companion apps. In the confirmation dialog for removing an associated app, this is the label on the button that will complete the disassociate action. [CHAR LIMIT=80] -->
    <string name = "bluetooth_companion_app_remove_association_confirm_button">Disconnect app</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>

    <!-- Nfc developer settings: The title of the setting. [CHAR LIMIT=60] -->
    <string name="nfc_stack_debuglog_title">NFC stack debug log</string>
    <!-- Nfc developer settings: The description of the setting. -->
    <string name="nfc_stack_debuglog_summary">Increase NFC stack logging level</string>

    <!-- Nfc developer settings: The title of the setting to enable nfc verbose vendor log. [CHAR LIMIT=60] -->
    <string name="nfc_verbose_vendor_log_title">NFC verbose vendor debug log</string>
    <!-- Nfc developer settings: The description of the setting to enable nfc verbose vendor log. [CHAR_LIMIT=NONE] -->
    <string name="nfc_verbose_vendor_log_summary">Include additional device-specific vendor logs in bugreports, which may contain private information. </string>
    <!-- Nfc developer settings: The title of the setting to enable full nfc snoop log. [CHAR LIMIT=60] -->
    <string name="nfc_snoop_log_title">NFC NCI unfiltered log</string>
    <!-- Nfc developer settings: The description of the setting to enable full nfc nci log. [CHAR_LIMIT=NONE] -->
    <string name="nfc_snoop_log_summary">Capture detail NFC packets, which may contain private information. </string>
    <!-- Nfc developer settings: The title of the popup dialog. [CHAR_LIMIT=60] -->
    <string name="nfc_reboot_dialog_title">Restart Device?</string>
    <!-- Nfc developer settings: The content of the popup dialog. [CHAR_LIMIT=NONE] -->
    <string name="nfc_reboot_dialog_message">Detail NFC logging is intended for development purposes only. Additional NFC data is included in bug reports, which may contain private information. Restart your device to change this setting. </string>
    <!-- Nfc developer settings: The confirm button of the popup dialog. [CHAR_LIMIT=60] -->
    <string name="nfc_reboot_dialog_confirm">Restart</string>

    <!-- Wifi Display settings. The title of the screen. [CHAR LIMIT=40] -->
    <string name="wifi_display_settings_title">Cast</string>
    <!-- Wifi Display settings. The keywords of the setting. [CHAR LIMIT=NONE] -->
    <string name="keywords_wifi_display_settings">mirror</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. 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 a universal identifier for 2.4GHz band -->
    <string name="wifi_band_24ghz">2.4 GHz</string>
    <!-- Wifi Internal 5GHz as a universal identifier for 5GHz band -->
    <string name="wifi_band_5ghz">5 GHz</string>
    <!-- Wifi 6GHz is used as a universal identifier for 6GHz band [CHAR LIMIT=40] -->
    <string name="wifi_band_6ghz">6 GHz</string>
    <!-- Wifi Sign in text for button [CHAR LIMIT = 40]-->
    <string name="wifi_sign_in_button_text">Sign in</string>
    <!-- Text for button to go to Wifi venue information webpage when Wifi is a captive portal [CHAR LIMIT=40]-->
    <string name="wifi_venue_website_button_text">Open site</string>
    <!-- Text shown in wifi settings indicating how much time is left on an internet access point that has a time limit for the session [CHAR LIMIT=40] -->
    <string name="wifi_time_remaining"><xliff:g id="Remaining time" example="1 day, 2 hours, 3 minutes">%1$s</xliff:g> left</string>
    <!-- Text shown in wifi settings indicating at what time the connection will expire on an internet access point that has a time limit for the session [CHAR LIMIT=40] -->
    <string name="wifi_expiry_time">Expires on <xliff:g id="Expiry time" example="2020/01/02 12:34PM">%1$s</xliff:g></string>
    <!-- Transmit Link speed on Wifi Status screen [CHAR LIMIT=32] -->
    <string name="tx_link_speed"><xliff:g id="Transmit link speed" example="150 Mbps">%1$d</xliff:g> Mbps</string>
    <!-- Receive Link speed on Wifi Status screen [CHAR LIMIT=32] -->
    <string name="rx_link_speed"><xliff:g id="Receive link speed" example="54 Mbps">%1$d</xliff:g> Mbps</string>
    <!-- Link speed on Wifi Status screen [CHAR LIMIT=32] -->
    <string name="link_speed"><xliff:g id="Link speed" example="54 Mbps">%1$d</xliff:g> 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>

    <!-- Debugging developer settings: Enable ART verifier for Debuggable Apps [CHAR LIMIT=67] -->
    <string name="art_verifier_for_debuggable_title">Verify bytecode of debuggable apps</string>
    <!-- Debugging developer settings: Enable ART verifier for Debuggable Apps [CHAR LIMIT=NONE] -->
    <string name="art_verifier_for_debuggable_summary">Allow ART to verify bytecode for debuggable apps</string>

    <!-- Debugging developer settings: show refresh rate? [CHAR LIMIT=36] -->
    <string name="show_refresh_rate">Show refresh rate</string>
    <!-- Debugging developer settings: show refresh rate summary [CHAR LIMIT=58] -->
    <string name="show_refresh_rate_summary">Show the current display refresh rate</string>

    <!-- Debugging developer settings: show HDR/SDR ratio? [CHAR LIMIT=36] -->
    <string name="show_hdr_sdr_ratio">Show HDR/SDR ratio</string>
    <!-- Debugging developer settings: show HDR/SDR ratio summary [CHAR LIMIT=58] -->
    <string name="show_hdr_sdr_ratio_summary">Show the current HDR/SDR ratio</string>

    <!-- NFC settings -->
    <!-- Used in the 1st-level settings screen to turn on NFC -->
    <string name="nfc_quick_toggle_title">NFC</string>

    <!-- Used in the settings screen to secure NFC [CHAR LIMIT=NONE] -->
    <string name="nfc_secure_settings_title">Require device unlock for NFC</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="nfc_disabled_summary">Unavailable because NFC is turned off</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 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_primary_switch_title">Use Wi\u2011Fi</string>
    <!-- Title of the Wi-fi settings screen -->
    <string name="wifi_settings_category">Wi\u2011Fi settings</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 public networks are nearby -->
    <string name="wifi_notify_open_networks">Notify for public networks</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 allow user to connect to wep networks-->
    <string name="wifi_allow_wep_networks">Allow WEP networks</string>
    <!-- Checkbox summary for option to allow user to connect to wep networks-->
    <string name="wifi_allow_wep_networks_summary">WEP is an older security protocol that\u0027s less secure</string>
    <!-- Checkbox summary for option to allow user to connect to wep networks when it is blocked by carrier-->
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow">Your carrier doesn\u0027t allow WEP networks because they\u0027re less secure</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>
    <!-- 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>Wi\u2011Fi 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>Wi\u2011Fi scanning
        settings<xliff:g id="link_end">LINK_END</xliff:g>.</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>
    <!-- Menu option to launch Wi-Fi Direct settings [CHAR LIMIT=20]-->
    <string name="wifi_menu_p2p">Wi\u2011Fi Direct</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 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 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>
    <!-- Wi-Fi settings dialog. Warning on the password entry page for a WEP network, when WEP networks are allowed. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_warning_wep_network">This network uses an older security protocol that\u0027s less secure</string>
    <!-- Wi-Fi settings dialog. Title of dialog displayed when WEP network is blocked. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_wep_networks_blocked_title"><xliff:g id="name">%1$s</xliff:g> is blocked</string>
    <!-- Wi-Fi settings dialog. Summary text of dialog displayed when WEP network toggle is turned off. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_wep_networks_summary_toggle_off">This network uses an older security protocol called WEP, which is less secure. To connect anyway, you can allow WEP networks.</string>
    <!-- Wi-Fi settings dialog. Summary text of dialog displayed when WEP network is blocked by the carrier. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier">Your carrier doesn\u0027t allow you to connect to this network because it uses an older security protocol that’s less secure</string>
    <!-- Wi-Fi settings dialog. Button text of dialog displayed when WEP network toggle is turned off. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_wep_networks_button_allow">Allow WEP</string>
    <!-- Wi-Fi settings dialog. Button text of dialog displayed when WEP network toggle is blocked. [CHAR LIMIT=NONE] -->
    <string name="wifi_settings_ssid_block_button_close">Close</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 focus on Advanced Options[CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description">Drop down list Advanced Options</string>
    <!-- Extended message for talkback to say when Advanced Options is collapsed. (e.g., Double-tap to expand) [CHAR LIMIT=NONE] -->
    <string name="wifi_advanced_toggle_description_collapsed">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 transmit link speed of the connection. [CHAR LIMIT=32] -->
    <string name="tx_wifi_speed">Transmit link speed</string>
    <!-- Label for the receive link speed of the connection. [CHAR LIMIT=32] -->
    <string name="rx_wifi_speed">Receive link speed</string>
    <!-- Label for the link speed of the connection. [CHAR LIMIT=32] -->
    <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 EAP minimum TLS version of the network -->
    <string name="wifi_eap_min_tls_ver">Minimum TLS version</string>
    <!-- Label for the OCSP type of the network. [CHAR LIMIT=32] -->
    <string name="wifi_eap_ocsp">Online Certificate Status</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 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 prefer 5GHz wifi ap band  [CHAR LIMIT=80]-->
    <string name="wifi_ap_prefer_5G">5.0 GHz Band preferred</string>
    <!-- Label for the spinner to show ip settings [CHAR LIMIT=25] -->
    <string name="wifi_ip_settings">IP settings</string>
    <!-- Label for the spinner to show Wifi MAC randomization [CHAR LIMIT=25] -->
    <string name="wifi_privacy_settings">Privacy</string>
    <!-- Label for the subscription preference. [CHAR LIMIT=32] -->
    <string name="wifi_subscription">Subscription</string>
    <!-- Summary text for the subscription preference. [CHAR LIMIT=NONE] -->
    <string name="wifi_subscription_summary">View or change subscription</string>
    <!-- Summary for Wifi MAC randomization option when it is ephemeral network [CHAR LIMIT=50] -->
    <string name="wifi_privacy_settings_ephemeral_summary">Randomized MAC</string>
    <!-- Title for the fragment to add a device into the wifi network [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_add_device_to_network">Add a device</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=120] -->
    <string name="wifi_dpp_center_qr_code">Center the QR code below to add the device to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Title for the fragment to scan QR code [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_scan_qr_code">Scan QR code</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_qr_code_join_network">Center the QR code below to connect to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_qr_code_join_unknown_network">Join Wi\u2011Fi by scanning a QR code</string>
    <!-- Title for the fragment to share Wi-Fi [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_share_wifi">Share Wi\u2011Fi</string>
    <!-- Hint for the user to use another device to scan QR code on screen to join Wi-Fi [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_qr_code_with_another_device">Scan this QR code with another device to join \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Hint for the user to use another device to scan QR code on screen to join a open Wi-Fi [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device">Scan this QR code to connect to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_authentication_or_configuration">Try again. If the issue continues, contact the device manufacturer</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_not_compatible">Something went wrong</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_timeout">Make sure the device has been plugged in, charged, and turned on</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_generic">Make sure the device has been plugged in, charged, and turned on. If the issue continues, contact the device manufacturer</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_not_supported">Adding \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d isn\u2019t supported by this device</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_cannot_find_network">Try moving the device closer to your Wi\u2011Fi access point/router</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_enrollee_authentication">Check the password and try again</string>
    <!-- Hint for Wi-Fi DPP handshake failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_failure_enrollee_rejected_configuration">Contact the device manufacturer</string>
    <!-- Hint for Wi-Fi connection fail [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_check_connection_try_again">Check connection and try again</string>
    <!-- Title for the fragment choose network [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_choose_network">Choose network</string>
    <!-- Hint for the user to center another device's QR code in the below camera window [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_choose_network_to_connect_device">To connect your device, choose a network</string>
    <!-- Hint for the user to add the device to a Wi-Fi network [CHAR LIMIT=NONE] -->
    <string name="wifi_dpp_add_device_to_wifi">Add this device to \u201c<xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g>\u201d?</string>
    <!-- Title for the fragment to tell the user that Wi-Fi shared with device successfully [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_wifi_shared_with_device">Wi\u2011Fi shared with device</string>
    <!-- Button label to add another device to Wi-Fi [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_add_another_device">Add another device</string>
    <!-- Button label to choose different Wi-Fi network [CHAR LIMIT=80]  -->
    <string name="wifi_dpp_choose_different_network">Choose different network</string>
    <!-- Hint for QR code detection [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_could_not_add_device">Couldn\u2019t add device</string>
    <!-- Title for the fragment to show that device found but naming known [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_device_found">Device found</string>
    <!-- Hint for Wi-Fi DPP handshake running [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_sharing_wifi_with_this_device">Sharing Wi\u2011Fi with this device\u2026</string>
    <!-- Hint for Wi-Fi DPP handshake running [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_connecting">Connecting\u2026</string>
    <!-- Title for the fragment to show that the QR code is for sharing Wi-Fi hotspot network [CHAR LIMIT=50] -->
    <string name="wifi_dpp_share_hotspot">Share hotspot</string>
    <!-- Title for Wi-Fi DPP lockscreen title [CHAR LIMIT=50] -->
    <string name="wifi_dpp_lockscreen_title">Verify it\u0027s you</string>
    <!-- Hint for Wi-Fi password [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_wifi_password">Wi\u2011Fi password: <xliff:g id="password" example="my password">%1$s</xliff:g></string>
    <!-- Hint for Wi-Fi hotspot password [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_hotspot_password">Hotspot password: <xliff:g id="password" example="my password">%1$s</xliff:g></string>
    <!-- Label for a Wi-Fi network to specify if the device will auto connect to the Wi-Fi network
         when signal of the Wi-Fi network is reachable [CHAR LIMIT=50]  -->
    <string name="wifi_auto_connect_title">Auto\u2011connect</string>
    <!-- Hint for Wi-Fi Auto-connect [CHAR LIMIT=NONE]  -->
    <string name="wifi_auto_connect_summary">Allow connection to this network when in range</string>
    <!-- Label for "Use a QR code to add a device to this network" [CHAR LIMIT=50]  -->
    <string name="wifi_dpp_add_device">Add device</string>
    <!-- Hint for "Add device" [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_connect_network_using_qr_code">Use a QR code to add a device to this network</string>
    <!-- Hint for QR code process failure [CHAR LIMIT=NONE]  -->
    <string name="wifi_dpp_qr_code_is_not_valid_format">QR code isn\u0027t a valid format</string>
    <!-- Label for the try again button [CHAR LIMIT=20]-->
    <string name="retry">Retry</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 Trust On First Use[CHAR_LIMIT=64] -->
    <string name="wifi_trust_on_first_use">Trust on First Use</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>
    <!-- Warning message displayed if user does not specify a user certification for
         WPA3-Enterprise 192-bit. Only displayed if the user does not specify user certificate
         for WPA3-Enterprise 192-bit [CHAR LIMIT=80]-->
    <string name="wifi_no_user_cert_warning">Certificate required.</string>
    <!-- Message to inform user, an app want to enable network scanning.  [CHAR LIMIT=250] -->
    <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 to inform user, an unknown app want to enable network scanning.  [CHAR LIMIT=250] -->
    <string name="wifi_scan_always_turn_on_message_unknown">To improve location accuracy and for other purposes, an unknown app wants to turn on network scanning, even when Wi\u2011Fi is off.\n\nAllow this for all apps that want to scan?</string>
    <string name="wifi_scan_always_confirm_allow">Allow</string>
    <string name="wifi_scan_always_confirm_deny">Deny</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>
    <!-- Dialog text to tell the user that the selected network has incomplete Internet access. [CHAR LIMIT=100] -->
    <string name="partial_connectivity_text">Some apps and services may not work due to limited connectivity. Use anyway?</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>
    <!-- A notification for connected to a Wi-Fi network [CHAR LIMIT=NONE] -->
    <string name="wifi_connected_to_message">Connected to <xliff:g id="network_name" example="MyNetwork">%1$s</xliff:g></string>
    <!-- Button label to connecting progress to a Wi-Fi network [CHAR LIMIT=20] -->
    <string name="wifi_connecting">Connecting\u2026</string>
    <!-- Failured notification for connect -->
    <string name="wifi_failed_connect_message">Failed to connect to network</string>
    <!-- Not in range notification for connect [CHAR LIMIT=40] -->
    <string name="wifi_not_in_range_message">Network not in range</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>
    <!-- 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>

    <!-- Wi-Fi Advanced Settings --> <skip />
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates the number of networks, not including passpoint network, a user has saved. [CHAR LIMIT=30] -->
    <string name="wifi_saved_access_points_summary">{count, plural,
      =1      {1 network}
      other   {# networks}
    }</string>
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates the number of passpoint networks a user has saved. [CHAR LIMIT=30] -->
    <string name="wifi_saved_passpoint_access_points_summary">{count, plural,
      =1      {1 subscription}
      other   {# subscriptions}
    }</string>
    <!-- Wi-Fi settings screen, Saved networks summary.  This shows below the "Saved networks" item and indicates number of whole kinds networks, if there are both normal saved networks and saved passpoint networks. The number will be at least 2, so the one case is only to prevent lint error. [CHAR LIMIT=60] -->
    <string name="wifi_saved_all_access_points_summary">{count, plural,
      =1      {1 network &amp; subscription}
      other   {# networks &amp; subscriptions}
    }</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the Wi-Fi device's SSID. [CHAR LIMIT=20] -->
    <string name="wifi_advanced_ssid_title">SSID</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the device's Wi-Fi MAC address. [CHAR LIMIT=50] -->
    <string name="wifi_advanced_device_mac_address_title">Device MAC address</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the randomized Wi-Fi MAC address. [CHAR LIMIT=50] -->
    <string name="wifi_advanced_randomized_mac_address_title">Randomized MAC address</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the randomized Wi-Fi MAC address when disconnected. [CHAR LIMIT=69] -->
    <string name="wifi_advanced_randomized_mac_address_disconnected_title">Randomized MAC address (last used)</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 wifi type info [CHAR LIMIT=50]-->
    <string name="wifi_type_title">Type</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>

    <!-- Hotspot device details preference category title in Network details [CHAR LIMIT=NONE]-->
    <string name="hotspot_device_details_category">Hotspot device details</string>
    <!-- Internet source preference in Hotspot device details preference category [CHAR LIMIT=NONE]-->
    <string name="hotspot_device_details_internet_source">Internet source</string>
    <!-- Wi-Fi summary in Internet source preference [CHAR LIMIT=NONE]-->
    <string name="internet_source_wifi">Wi\u2011Fi</string>
    <!-- Mobile data summary in Internet source preference [CHAR LIMIT=NONE]-->
    <string name="internet_source_mobile_data">Mobile data</string>
    <!-- Ethernet summary in Internet source preference [CHAR LIMIT=NONE]-->
    <string name="internet_source_ethernet">Ethernet</string>
    <!-- Hotspot device details battery charging summary [CHAR LIMIT=NONE]-->
    <string name="hotspot_battery_charging_summary"><xliff:g id="battery_percentage" example="80%">%1$s</xliff:g> \u2011 Charging</string>
    <!-- Hotspot device details preference category title in Network details [CHAR LIMIT=NONE]-->
    <string name="hotspot_connection_category">Hotspot connection</string>
    <!-- Connection strength preference in Hotspot connection preference category [CHAR LIMIT=NONE]-->
    <string name="hotspot_connection_strength">Connection strength</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>
    <!-- Tab title for showing subscribed WiFi access points. [CHAR LIMIT=20] -->
    <string name="wifi_subscribed_access_points_tab">Subscriptions</string>
    <!-- Tab title for showing saved other networks. -->
    <string name="wifi_saved_other_networks_tab">Other networks</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 (unless overridden by Private DNS)</string>
    <!-- Label for the DNS (second one)-->
    <string name="wifi_dns2">DNS 2 (unless overridden by Private DNS)</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>
    <!-- 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 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>
    <!-- Label for Wifi hotspot password. -->
    <string name="wifi_hotspot_password_title">Hotspot password</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">When no devices are connected</string>
    <!-- Title for the toggle to enable/disable the maximize compatibility [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_maximize_compatibility">Extend compatibility</string>
    <!-- Summary for the toggle to show the maximize compatibility warning message in single AP device [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary">Helps other devices find this hotspot. Reduces hotspot connection speed.</string>
    <!-- Summary for the toggle to show the maximize compatibility warning message in dual AP device [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary">Helps other devices find this hotspot. Increases battery usage.</string>
    <!-- Title for Wifi hotspot speed [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_title">Speed &amp; compatibility</string>
    <!-- Summary for Wifi hotspot speed to 2.4 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_summary_2g">2.4 GHz / Compatible with most devices</string>
    <!-- Summary for Wifi hotspot speed to 5 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_summary_5g">5 GHz / Compatible with many devices</string>
    <!-- Summary for Wifi hotspot speed to 6 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_summary_6g">6 GHz / Compatible with few devices</string>
    <!-- Summary for Wifi hotspot speed to 6 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_summary_2g_and_5g">2.4 and 5 GHz / Compatible with most devices</string>
    <!-- Top introduction on the Wi-Fi hotspot speed settings, summarizes options available for Wi-Fi hotspot bands. [CHAR LIMIT=NONE] -->
    <string name="wifi_hotspot_speed_intro">Choose a frequency for your hotspot. The frequency affects the connection speed and what types of devices can find your hotspot.</string>
    <!-- Category title on the radio button of the Wi-Fi hotspot speed. [CHAR LIMIT=NONE] -->
    <string name="wifi_hotspot_speed_category">Preferred frequency</string>
    <!-- Title for radio button of the Wi-Fi hotspot speed to 2.4 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_2g">2.4 GHz</string>
    <!-- Summary for radio button of the Wi-Fi hotspot speed to 2.4 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_2g_summary">Slower speeds. Compatible with most devices.</string>
    <!-- Title for radio button of the Wi-Fi hotspot speed to 5 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_5g">5 GHz</string>
    <!-- Summary for radio button of the Wi-Fi hotspot speed to 5 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_5g_summary">Fast speeds. Compatible with many devices.</string>
    <!-- Title for radio button of the Wi-Fi hotspot speed to 2.4 GHz and 5 GHz bands [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_2g_5g">2.4 and 5 GHz</string>
    <!-- Summary for radio button of the Wi-Fi hotspot speed to 2.4 GHz and 5 GHz bands [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_2g_5g_summary">Fast speeds. This dual-band hotspot is compatible with most devices.</string>
    <!-- Title for radio button of the Wi-Fi hotspot speed to 6 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_6g">6 GHz</string>
    <!-- Summary for radio button of the Wi-Fi hotspot speed to 6 GHz band [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_6g_summary">Fastest speeds. Compatible with few devices.</string>
    <!-- Summary for the Wi-Fi hotspot speed unavailable [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_speed_summary_unavailable">Not available in your country or region</string>
    <!-- The footer message for switch screen resolution [CHAR LIMIT=NONE] -->
    <string name="wifi_hotspot_speed_footer">If your preferred frequency isn\u0027t available, your hotspot may use a different one. Hotspot security settings may change if you change the frequency.</string>
    <!-- Summary for the Wi-Fi hotspot security unavailable [CHAR LIMIT=NONE] -->
    <string name="wifi_hotspot_security_summary_unavailable">Not available with 6 GHz</string>
    <!-- The footer message for Wi-Fi hotspot security settings [CHAR LIMIT=NONE] -->
    <string name="wifi_hotspot_security_footer">Security settings may change if you change the hotspot’s frequency</string>

    <!-- Title for the instant hotspot state [CHAR LIMIT=NONE]-->
    <string name="wifi_hotspot_instant_title">Instant hotspot</string>
    <!-- Summary text when instant hotspot is turned on -->
    <string name="wifi_hotspot_instant_summary_on">On</string>
    <!-- Summary text when instant hotspot is turned off -->
    <string name="wifi_hotspot_instant_summary_off">Off</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>
    <!-- Dialog title text when carrier does not support tethering -->
    <string name="wifi_tether_carrier_unsupport_dialog_title">Tethering unavailable</string>
    <!-- Dialog content text when carrier does not support tethering -->
    <string name="wifi_tether_carrier_unsupport_dialog_content">Contact your carrier for details</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>
    <!-- Default access point SSID used for tethering -->
    <string name="wifi_tether_configure_ssid_default">AndroidHotspot</string>
    <!-- Title for the panel of add Wi-Fi network from APP [CHAR LIMIT=50] -->
    <string name="wifi_add_app_single_network_title">Save this network?</string>
    <!-- Summary for saving status when saving single network [CHAR LIMIT=30] -->
    <string name="wifi_add_app_single_network_saving_summary">Saving\u2026</string>
    <!-- Summary for saved status when saving single network   [CHAR LIMIT=30] -->
    <string name="wifi_add_app_single_network_saved_summary">Saved</string>
    <!-- Summary for save failed status when saving single network [CHAR LIMIT=50] -->
    <string name="wifi_add_app_network_save_failed_summary">Can\u2019t save. Try again.</string>
    <!--  Title for the panel of add multiple Wi-Fi networks from APP [CHAR LIMIT=50] -->
    <string name="wifi_add_app_networks_title">Save networks?</string>
    <!-- Summary for the panel of add Wi-Fi networks from APP [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_networks_saving_summary">Saving <xliff:g id="number" example="3">%d</xliff:g> networks\u2026</string>
    <!-- Summary for saved status when saving multiple networks   [CHAR LIMIT=NONE] -->
    <string name="wifi_add_app_networks_saved_summary">Networks saved</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="tx_link_speed_label" translatable="false">Transmit link speed:</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="rx_link_speed_label" translatable="false">Receive 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">Calling preference</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" translatable="false">
        <item>@*android:string/wfc_mode_wifi_preferred_summary</item>
        <item>@*android:string/wfc_mode_cellular_preferred_summary</item>
        <item>@*android:string/wfc_mode_wifi_only_summary</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" translatable="false">
        <item>"2"</item>
        <item>"1"</item>
        <item>"0"</item>
    </string-array>
    <string-array name="wifi_calling_mode_choices_without_wifi_only" translatable="false">
        <item>@*android:string/wfc_mode_wifi_preferred_summary</item>
        <item>@*android:string/wfc_mode_cellular_preferred_summary</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" translatable="false">
        <item>"2"</item>
        <item>"1"</item>
    </string-array>

    <!-- Summary of WFC preference item on the WFC preference selection dialog. [CHAR LIMIT=70]-->
    <string name="wifi_calling_mode_wifi_preferred_summary">If Wi\u2011Fi is unavailable, use mobile network</string>
    <!-- Summary of WFC preference item on the WFC preference selection dialog. [CHAR LIMIT=70]-->
    <string name="wifi_calling_mode_cellular_preferred_summary">If mobile network is unavailable, use Wi\u2011Fi</string>
    <!-- Summary of WFC preference item on the WFC preference selection dialog. [CHAR LIMIT=70]-->
    <string name="wifi_calling_mode_wifi_only_summary">Call over Wi\u2011Fi. If Wi\u2011Fi is lost, call will end.</string>

    <!-- 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.<xliff:g id="additional_text" example="Learn More">%1$s</xliff:g></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 private dns is on. [CHAR LIMIT=10] -->
    <string name="private_dns_mode_on">On</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>
    <!-- Hint for a Wi-Fi network is disconnected successfully [CHAR LIMIT=NONE] -->
    <string name="wifi_disconnected_from">Disconnected from <xliff:g id="ssid" example="OfficeWifi">%1$s</xliff:g></string>
    <!-- Sound and vibration settings screen heading. [CHAR LIMIT=30] -->
    <string name="sound_settings">Sound &amp; vibration</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>

    <!-- 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 personal clone accounts group [CHAR LIMIT=NONE] -->
    <string name="accessibility_category_clone">Clone 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>
    <!-- Sound & display settings screen, locked rotation check box label [CHAR LIMIT=30] -->
    <string name="auto_rotate_option_off">Off</string>
    <!-- Sound & display settings screen, accelerometer-based rotation check box label [CHAR LIMIT=30] -->
    <string name="auto_rotate_option_on">On</string>
    <!-- Sound & display settings screen, face-based rotation check box label [CHAR LIMIT=30] -->
    <string name="auto_rotate_option_face_based">On - Face-based</string>
    <!-- SmartAutoRotatePreferenceFragment settings screen, face-based rotation switch label [CHAR LIMIT=30] -->
    <string name="auto_rotate_switch_face_based">Face Detection</string>
    <!-- Accessibility description for auto rotate learn more link [CHAR LIMIT=NONE] -->
    <string name="auto_rotate_link_a11y">Learn more about auto-rotate</string>

    <!-- Display settings screen, screen resolution settings title [CHAR LIMIT=30] -->
    <string name="screen_resolution_title">Screen resolution</string>
    <!-- Display settings screen, screen resolution option for high resolution [CHAR LIMIT=45] -->
    <string name="screen_resolution_option_high">High resolution</string>
    <!-- Display settings screen, screen resolution option for full resolution [CHAR LIMIT=45] -->
    <string name="screen_resolution_option_full">Full resolution</string>
    <!-- The footer message for switch screen resolution [CHAR LIMIT=NONE] -->
    <string name="screen_resolution_footer">Full resolution uses more of your battery. Switching your resolution may cause some apps to restart.</string>
    <!-- Message announced to a11y users when they selected one resolution [CHAR LIMIT=NONE] -->
    <string name="screen_resolution_selected_a11y">Selected</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>

    <!-- 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 enable adaptive brightness [CHAR LIMIT=30] -->
    <string name="auto_brightness_title">Adaptive brightness</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>
    <!-- Setting option summary when adaptive brightness is on [CHAR LIMIT=NONE] -->
    <string name="auto_brightness_summary_on">On</string>
    <!-- Setting option summary when adaptive brightness is off [CHAR LIMIT=NONE] -->
    <string name="auto_brightness_summary_off">Off</string>

    <!-- Display settings screen, display white balance settings title [CHAR LIMIT=30] -->
    <string name="display_white_balance_title">Display white balance</string>
    <!-- Display settings screen, display white balance settings summary [CHAR LIMIT=NONE] -->
    <string name="display_white_balance_summary"></string>
    <!-- Display settings screen, setting option name to change Fold setting -->
    <string name="fold_lock_behavior_title">Continue using apps on fold</string>
    <!-- Display settings screen, game default frame rate settings title [CHAR LIMIT=65] -->
    <string name="disable_game_default_frame_rate_title">Disable default frame rate for games</string>
    <!-- Display settings screen, game default frame rate settings summary [CHAR LIMIT=NONE] -->
    <string name="disable_game_default_frame_rate_summary">Disable limiting the maximum frame rate for games at <xliff:g id="frame_rate" example="60">%1$d</xliff:g> Hz.</string>
    <!-- Display settings screen, peak refresh rate settings title [CHAR LIMIT=30] -->
    <string name="peak_refresh_rate_title">Smooth display</string>
    <!-- Display settings screen, peak refresh rate settings summary [CHAR LIMIT=NONE] -->
    <string name="peak_refresh_rate_summary">Automatically raises the refresh rate up to <xliff:g name="refresh_rate" example="120">%1$d</xliff:g> Hz for some content. Increases battery usage.</string>
    <!-- Display developer settings: Force to the highest refresh rate [CHAR LIMIT=NONE] -->
    <string name="force_high_refresh_rate_toggle">Force peak refresh rate</string>
    <!-- Display developer settings: Force to the highest refresh rate description [CHAR LIMIT=NONE]-->
    <string name="force_high_refresh_rate_desc">Highest refresh rate for improved touch responsiveness &amp; animation quality. Increases battery usage.</string>
    <!-- Display settings screen, setting option name to enable adaptive sleep [CHAR LIMIT=30] -->
    <string name="adaptive_sleep_title">Screen attention</string>
    <!-- adaptive_sleep settings screen, title about the required permission is missing [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_title_no_permission">Camera access needed</string>
    <!-- adaptive_sleep settings screen, subtitle when permission is missing [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_summary_no_permission">Camera access is required for screen attention. Tap to manage permissions for Device Personalization Services</string>
    <!-- adaptive_sleep settings screen, text for the camera permission button [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_manage_permission_button">Manage permissions</string>
    <!-- Description about the feature adaptive sleep [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_description">Prevents your screen from turning off if you\u2019re looking at it</string>
    <!-- Description feature's privacy sensitive details to make sure users understand what feature users, what it saves/sends etc [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_privacy">Screen attention uses the front camera to see if someone is looking at the screen. It works on device, and images are never stored or sent to Google.</string>
    <!-- Title of the contextual adaptive sleep card [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_contextual_slice_title">Turn on screen attention</string>
    <!-- Description about the contextual adaptive sleep card [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_contextual_slice_summary">Keep screen on when looking at it</string>
    <!-- Description about the power consumption implication in screen timeout footer [CHAR LIMIT=NONE]-->
    <string name="power_consumption_footer_summary">Longer screen timeout will use more battery.</string>
    <!-- auto_rotate settings screen, title about the camera privacy lock enabled [CHAR LIMIT=NONE]-->
    <string name="auto_rotate_camera_lock_title">Camera is locked</string>
    <!-- Description feature's privacy sensitive details to make sure users understand what feature users, what it saves/sends etc [CHAR LIMIT=NONE]-->
    <string name="auto_rotate_camera_lock_summary">Camera must be unlocked for Face Detection</string>
    <!-- screen_timeout settings screen, summary about the camera being disabled [CHAR LIMIT=NONE]-->
    <string name="adaptive_sleep_camera_lock_summary">Camera must be unlocked for Screen Attention</string>
    <!-- auto_rotate settings screen, title about the required permission is missing [CHAR LIMIT=NONE]-->
    <string name="auto_rotate_summary_no_permission">Camera access is required for Face Detection. Tap to manage permissions for Device Personalization Services</string>
    <!-- auto_rotate settings screen, text for the camera permission button [CHAR LIMIT=NONE]-->
    <string name="auto_rotate_manage_permission_button">Manage permissions</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 the color temperature of the display. [CHAR LIMIT=30] -->
    <string name="night_display_temperature_title">Intensity</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 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>
    <!-- Night display slice screen, subtitle of intensity setting when night light is off. [CHAR LIMIT=30] -->
    <string name="night_display_not_currently_on">Night Light not currently on</string>

    <!-- Twilight Mode -->
    <!-- When location mode is off, twilight scheduling does not function. [CHAR LIMIT=120] -->
    <string name="twilight_mode_location_off_dialog_message">Device location needed to determine your sunset and sunrise times.</string>
    <!-- When location mode is off, twilight scheduling does not function. [CHAR LIMIT=40] -->
    <string name="twilight_mode_launch_location">Location settings</string>

    <!--    Dark ui screen-->
    <!-- Display settings screen, activation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_on_manual">Turn on now</string>
    <!-- Display settings screen, deactivation button action for manual mode. [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_off_manual">Turn off now</string>
    <!-- Display settings screen, activation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_on_auto">Turn on until sunrise</string>
    <!-- Display settings screen, deactivation button action for sunset-to-sunrise schedule [CHAR LIMIT=40] -->
    <string name="dark_ui_activation_off_auto">Turn off until sunset</string>
    <!-- Dark UI screen, setting option name to enable Dark UI [CHAR LIMIT=30] -->
    <string name="dark_ui_title">Dark Mode</string>
    <!-- Dark UI screen, setting option name to configure whether Dark UI turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="dark_ui_auto_mode_title">Schedule</string>
    <!-- Dark UI screen, setting option value for Dark UI to *never* turn on/off automatically. [CHAR LIMIT=30] -->
    <string name="dark_ui_auto_mode_never">None</string>
    <!-- Dark UI screen, setting option value for Dark UI to turn on/off automatically at sunset/sunrise. [CHAR LIMIT=32] -->
    <string name="dark_ui_auto_mode_auto">Turns on from sunset to sunrise</string>
    <!-- Dark UI screen, setting option value for Dark theme to turn on/off automatically according to a user defined schedule. [CHAR LIMIT=32] -->
    <string name="dark_ui_auto_mode_custom">Turns on at custom time</string>
    <!-- Dark UI screen, setting option value for Dark theme to turn on/off automatically according to a user bedtime schedule. [CHAR LIMIT=40] -->
    <string name="dark_ui_auto_mode_custom_bedtime">Turns on at bedtime</string>
    <!-- Dark UI screen, setting option name controlling the current activation status. [CHAR LIMIT=30] -->
    <string name="dark_ui_status_title">Status</string>
    <!-- Display settings screen, summary of Dark UI when off and will *never* turn on automatically. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_off_auto_mode_never">Will never turn on automatically</string>
    <!-- Display settings screen, summary of Dark UI when off and will turn on automatically at sunset. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_off_auto_mode_auto">Will turn on automatically at sunset</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="dark_ui_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 Dark UI when off and will turn on automatically at bedtime. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime">Will turn on automatically at bedtime</string>
    <!-- Display settings screen, summary of Dark UI when on and will *never* turn off automatically. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_on_auto_mode_never">Will never turn off automatically</string>
    <!-- Display settings screen, summary of Dark UI when on and will turn off automatically at sunrise. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_on_auto_mode_auto">Will turn off automatically at sunrise</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="dark_ui_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 Dark UI when on and will turn off automatically after bedtime. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime">Will turn off automatically after bedtime</string>
    <!-- Dark theme screen, description of Dark theme feature. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_text">Dark theme uses a black background to help keep battery alive longer on some screens. Dark theme schedules wait to turn on until your screen is off.</string>
    <!-- Dark UI screen footer summary text shown when the when Dark theme turns on/off automatically according to a user bedtime schedule. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_bedtime_footer_summary">Dark theme is currently following your Bedtime mode schedule</string>
    <!-- Dark UI screen footer action text shown when the when Dark theme turns on/off automatically according to a user bedtime schedule. [CHAR LIMIT=NONE] -->
    <string name="dark_ui_bedtime_footer_action">Bedtime mode settings</string>


    <!-- Sound & display settings screen, setting option name to change screen timeout -->
    <string name="screen_timeout">Screen timeout</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>
    <!-- Sound & display settings screen, setting option summary if there is no matching candidate -->
    <string name="screen_timeout_summary_not_set">Not set</string>
    <!-- Wallpaper settings title [CHAR LIMIT=30] -->
    <string name="wallpaper_settings_title">Wallpaper</string>
    <!-- Styles & Wallpapers settings title [CHAR LIMIT=30] -->
    <string name="style_and_wallpaper_settings_title">Wallpaper &amp; style</string>
    <!-- Summary for the top level wallpapers settings [CHAR LIMIT=NONE]-->
    <string name="wallpaper_dashboard_summary">Home, lock screen</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>
    <!-- Styles and Wallpaper settings title [CHAR_LIMIT=46] -->
    <string name="style_suggestion_title">Customize your phone</string>
    <!-- Styles and Wallpapers summary [CHAR_LIMIT=70] -->
    <string name="style_suggestion_summary">Try different styles, wallpapers, and more</string>
    <!-- Display settings screen, trigger for screen saver options [CHAR LIMIT=30] -->
    <string name="screensaver_settings_title">Screen saver</string>
    <!-- List of synonyms used in the settings search bar to find the “Screen saver”. [CHAR LIMIT=NONE] -->
    <string name="keywords_screensaver">screensaver</string>
    <!-- Summary for screensaver unavailable when Bedtime mode is on [CHAR LIMIT=50] -->
    <string name="screensaver_settings_when_to_dream_bedtime">Unavailable because bedtime mode is on</string>
    <!-- The title for the toggle which disables/enables screen savers [CHAR_LIMIT=30] -->
    <string name="screensaver_settings_toggle_title">Use screen saver</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when docked or asleep and charging [CHAR LIMIT=35] -->
    <string name="screensaver_settings_summary_either_long">While charging or docked</string>
    <!-- Display settings screen, summary fragment for screen saver options, actived while docked and charging [CHAR LIMIT=35] -->
    <string name="screensaver_settings_summary_dock_and_charging">While docked and charging</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when asleep and charging [CHAR LIMIT=35] -->
    <string name="screensaver_settings_summary_sleep">While charging</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated when docked [CHAR LIMIT=35] -->
    <string name="screensaver_settings_summary_dock">While docked</string>
    <!-- Display settings screen, summary fragment for screen saver options, activated never [CHAR LIMIT=35] -->
    <string name="screensaver_settings_summary_never">Never</string>
    <!-- Display settings screen, summary for screen saver options, screen saver is turned on [CHAR LIMIT=50] -->
    <string name="screensaver_settings_summary_on">
        On / <xliff:g id="screen_saver" example="Art gallery">%1$s</xliff:g>
    </string>
    <!-- Display settings screen, summary for screen saver options, screen saver is turned off [CHAR LIMIT=20] -->
    <string name="screensaver_settings_summary_off">Off</string>
    <!-- Dream settings screen, action label, when to dream [CHAR LIMIT=20] -->
    <string name="screensaver_settings_when_to_dream">When to start</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=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">Wake screen for 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">When screen is dark, it turns on for new 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 show time and info</string>
    <!-- [CHAR LIMIT=NONE] Display settings screen, setting description for the always-on ambient display feature. -->
    <string name="doze_always_on_summary">Increased battery usage</string>
    <!-- [CHAR LIMIT=30] Display and accessibility settings screens, setting option name to force bold text. -->
    <string name="force_bold_text">Bold text</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 bigger or smaller</string>

    <!-- SIM lock settings title  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings">SIM lock settings</string>
    <!-- Security & screen lock settings screen, SIM lock setting option name  [CHAR LIMIT=40] -->
    <string name="sim_lock_settings_category">SIM lock</string>
    <!-- Security & screen lock settings screen, SIM card lock setting summary when on [CHAR LIMIT=NONE] -->
    <!-- SIM lock settings screen, setting check box label  [CHAR LIMIT=40] -->
    <string name="sim_pin_toggle">Lock SIM</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 lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_enable_sim_lock">Lock SIM</string>
    <!-- SIM lock settings screen, SIM PIN dialog message instruction  [CHAR LIMIT=40] -->
    <string name="sim_disable_sim_lock">Unlock SIM</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 invalid PIN is entered  [CHAR LIMIT=40] -->
    <string name="sim_invalid_pin_hint">Type a PIN that is 4 to 8 numbers</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, 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 disabling PIN failed from modem -->
    <string name="sim_pin_disable_failed">Can\'t disable PIN.</string>
    <!-- SIM card lock settings screen, toast after enabling PIN failed from modem -->
    <string name="sim_pin_enable_failed">Can\'t enable 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>
    <!-- Title asking user if they wish to change the default sim for cellular data.  [CHAR LIMIT=40] -->
    <string name="sim_change_data_title">
        Use <xliff:g id="carrier" example="Verizon">%1$s</xliff:g> for mobile data?
    </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">
        You\u0027re using <xliff:g id="carrier2" example="T-mobile">%2$s</xliff:g> for mobile data.
        If you switch to <xliff:g id="carrier1" example="Verizon">%1$s</xliff:g>,
        <xliff:g id="carrier2" example="T-mobile">%2$s</xliff:g> will no longer be used for mobile
        data.
    </string>
    <!-- Ok button label confirming the user wishes to change the default data SIM from one to
         another. [CHAR LIMIT=25] -->
    <string name="sim_change_data_ok">
        Use <xliff:g id="carrier" example="Verizon">%1$s</xliff:g>
    </string>
    <!-- Title for the dialog asking to user to change the preferred SIM  [CHAR LIMIT=30] -->
    <string name="sim_preferred_title">Update preferred SIM?</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>

    <!-- Title for the dialog asking user to enable auto data switch upon enabling multi-SIM  [CHAR LIMIT=30] -->
    <string name="enable_auto_data_switch_dialog_title">Improve mobile data coverage?</string>
    <!-- Message for the dialog asking user to enable auto data switch upon enabling multi-SIM  [CHAR LIMIT=NONE] -->
    <string name="enable_auto_data_switch_dialog_message">Allow your device to automatically switch to <xliff:g id="backup_carrier" example="T-mobile">%1$s</xliff:g> for mobile data when it has better availability.</string>
    <!-- Warning for the dialog asking user to enable auto data switch for switching data between work and personal profile  [CHAR LIMIT=NONE] -->
    <string name="auto_data_switch_dialog_managed_profile_warning">\n\nCalls, messages, and network traffic may be visible to your organization.</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] -->
    <string name="wrong_pin_code">{count, plural,
      =1      {Incorrect SIM PIN code, you have # remaining attempt before you must contact your carrier to unlock your device.}
      other   {Incorrect SIM PIN code, you have # remaining attempts.}
    }</string>

    <!-- This is instruction text to inform the user that they have entered the wrong SIM PIN while trying to unlock the keyguard.
         The variable will be replaced with a number. [CHAR LIMIT=NONE] -->
    <string name="wrong_pin_code_one">Incorrect SIM PIN code, you have 1 remaining attempt before you must contact your carrier to unlock your device.</string>
    <!-- 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>

    <!-- 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, status item label  [CHAR LIMIT=60] -->
    <string name="security_patch">Android security update</string>
    <!-- About phone screen, status item label  [CHAR LIMIT=40] -->
    <string name="model_info">Model</string>
    <!-- Label for device's hardware revision value [CHAR LIMIT=40] -->
    <string name="hardware_revision">Hardware version</string>
    <!-- Label for device's manufactured year value [CHAR LIMIT=40] -->
    <string name="manufactured_year">Manufactured year</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, tapping this button will take user to a seperate UI to check Google Play system update [CHAR LIMIT=60] -->
    <string name="module_version">Google Play system update</string>
    <!-- About phone screen, show a list of battery information  [CHAR LIMIT=60] -->
    <string name="battery_info">Battery information</string>

    <!-- About phone screen, show when a value of some status item is unavailable. -->
    <string name="device_info_not_available">Not available</string>
    <!-- Main settings screen item's title to go into the storage settings screen [CHAR LIMIT=25] -->
    <string name="storage_settings" >Storage</string>
    <!-- Settings title that shows user how much storage and cache space an App is taking [CHAR LIMIT=50] -->
    <string name="storage_settings_for_app" >Storage &amp; cache</string>
    <!-- Storage settings screen title -->
    <string name="storage_settings_title">Storage settings</string>
    <!-- About phone, title of EID -->
    <string name="status_eid">EID</string>
    <!-- About phone, title of EID for multi-sim devices -->
    <string name="eid_multi_sim">EID (sim slot <xliff:g id="eid_slot_id">%1$d</xliff:g>)</string>
    <!-- About phone screen, title for IMEI for multi-sim devices -->
    <string name="imei_multi_sim">IMEI (sim slot <xliff:g id="imei_slot_id">%1$d</xliff:g>)</string>
    <!-- About phone screen, title for primary IMEI for multi-sim devices -->
    <string name="imei_multi_sim_primary">IMEI (sim slot <xliff:g id="imei_slot_id_primary">%1$d</xliff:g>) (primary)</string>
    <!-- About phone screen, summary of the MAC address [CHAR LIMIT=80] -->
    <string name="view_saved_network">To view, choose saved network</string>
    <!-- About phone, status item title. This translation is for specific language only. Like: fr-CA -->
    <string name="status_imei">IMEI</string>
    <!-- About phone, status item title. This translation is for specific language only. Like: fr-CA -->
    <string name="status_imei_sv">IMEI SV</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_iccid">ICCID</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 <xliff:g id="meid_slot_id">%1$d</xliff:g>)</string>
    <!-- About phone screen, title for primary MEID for multi-sim devices -->
    <string name="meid_multi_sim_primary">MEID (sim slot <xliff:g id="meid_slot_id_primary">%1$d</xliff:g>) (primary)</string>
    <!-- The status text when (Wi-Fi or Bluetooth) scanning is on. [CHAR LIMIT=100] -->
    <string name="scanning_status_text_on">On</string>
    <!-- The status text when (Wi-Fi or Bluetooth) scanning is off. [CHAR LIMIT=100] -->
    <string name="scanning_status_text_off">Off</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 device's MAC address of the Wi-Fi network adapter. [CHAR LIMIT=50] -->
    <string name="status_device_wifi_mac_address">Device 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. The battery manufacture date. [CHAR LIMIT=60]-->
    <string name="battery_manufacture_date">Manufacture date</string>
    <!-- About phone, status item title. Date of first use of the battery. [CHAR LIMIT=60]-->
    <string name="battery_first_use_date">Date of first use</string>
    <!-- About phone, status item title. Count of battery full charge/discharge cycles [CHAR LIMIT=60]-->
    <string name="battery_cycle_count">Cycle count</string>
    <!-- About phone, status item title. The status summary for cycle count that's not available. [CHAR LIMIT=40] -->
    <string name="battery_cycle_count_not_available">Unavailable</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>

    <!-- 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=50]-->
    <string name="storage_menu_format">Format SD card for portable storage</string>
    <!-- Storage setting.  Button option for erasing and formatting a storage device [CHAR LIMIT=30]-->
    <string name="storage_menu_format_button">Format card</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=20]-->
    <string name="storage_menu_format_option">Format</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 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 storage free up option. [CHAR LIMIT=30] -->
    <string name="storage_free_up_space_title">Free up space</string>
    <!-- Storage setting. Summary for storage free up option. [CHAR LIMIT=NONE] -->
    <string name="storage_free_up_space_summary">Go to Files app to manage and free up space</string>

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

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

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

    <!-- Body of dialog informing user about consequences of formatting an internal storage device [CHAR LIMIT=NONE]-->
    <string name="storage_internal_format_details">You can format this SD card to store photos, videos, music,
        and more and access them on other devices.
        \n\n<b>All data on this SD card will be erased.</b>
        \n\n<b>Before formatting</b>
\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>

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

    <!-- Message to notify guest users as to why they can't set up the storage device [CHAR LIMIT=50]-->
    <string name="storage_wizard_guest">Guest mode users cannot format SD cards</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 formatted.</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"><xliff:g id="name" example="SD card">^1</xliff:g> formatted</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>

    <!-- 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>
    <!-- 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=50] -->
    <string name="storage_wizard_init_v2_external_title">Format SD card 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=NONE] -->
    <string name="storage_wizard_init_v2_external_summary">Store photos, videos, music, and more and access them from other devices. &lt;a href="https://support.google.com/android/answer/12153449"&gt;Learn more about setting up an SD card&lt;/a&gt;.</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">Format</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>
    <!-- Body of a dialog. This text is confirming that the user wants to use their SD card as portable 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_external">This <xliff:g id="name" example="SanDisk SD card">^1</xliff:g> needs to be formatted to store photos, videos, music, and more.
        \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>

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

    <!-- 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 start using your <xliff:g id="name" example="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">You can start using your <xliff:g id="name" example="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_moved_body">You can start using your <xliff:g id="name" example="SD card">^1</xliff:g></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>

    <!-- Communal Settings -->
    <!-- Title of the communal settings under Settings > Communal [CHAR LIMIT=30] -->
    <string name="communal_settings_title">Communal</string>
    <!-- Summary of the communal settings under Settings > Communal [CHAR LIMIT=50] -->
    <string name="communal_settings_summary">Communal settings</string>

    <!-- _satellite_setting_preference_layout -->
    <!-- _satellite_setting_preference_layout screen title-->
    <string name="satellite_setting">Satellite Messaging</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>
    <!-- Screen title after user selects add APNs setting -->
    <string name="apn_add">Add 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 label summary text when no value has been set for mvno value. [CHAR LIMIT=NONE]-->
    <string name="apn_not_set_for_mvno">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>
    <!-- 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 Network Type Info of APN -->
    <string name="network_type">Network type</string>
    <!-- Network type unspecified -->
    <string name="network_type_unspecified">Unspecified</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">Cancel</string>
    <!-- APN error dialog title -->
    <string name="error_title"></string>
    <!-- APN error dialog messages when the new apn is a duplicate: -->
    <string name="error_duplicate_apn_entry">Duplicate apn entry.</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>
    <!-- APN error messages: -->
    <string name="error_mmsc_valid">MMSC field must be valid.</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>

    <!-- Reset Mobile Network -->
    <!-- Button title to reset Mobile network setting -->
    <string name="reset_mobile_network_settings_title">Reset Mobile Network Settings</string>
    <!-- User selects Reset mobile network settings [CHAR LIMIT=NONE] -->
    <string name="reset_mobile_network_settings_desc">This will reset all mobile network settings</string>
    <!-- Reset Mobile network setting confirmation screen title [CHAR LIMIT=62] -->
    <string name="reset_mobile_network_settings_confirm_title">Reset Mobile Network Settings?</string>

    <!-- Reset Bluetooth and Wi-Fi Network -->
    <!-- Dialog title to reset Bluetooth and Wi-Fi settings -->
    <string name="reset_bluetooth_wifi_title">Reset Bluetooth &amp; Wi\u2011Fi</string>
    <!-- Dialog context when reset Bluetooth and Wi-Fi settings [CHAR LIMIT=NONE] -->
    <string name="reset_bluetooth_wifi_desc">This will reset all Wi\u2011Fi &amp; Bluetooth settings. You can\u2019t undo this action.</string>
    <!-- Confirmation button text when reset Bluetooth and Wi-Fi settings [CHAR LIMIT=NONE] -->
    <string name="reset_bluetooth_wifi_button_text">Reset</string>
    <!-- Reset Bluetooth and Wi-Fi complete toast text [CHAR LIMIT=75] -->
    <string name="reset_bluetooth_wifi_complete_toast">Bluetooth &amp; Wi\u2011Fi have been reset</string>

    <!-- Erase Euicc -->
    <!-- Erase Euicc dialog and SD card & phone storage settings screen, title for the menu option and checkbox to let user decide whether erase eSIM data together [CHAR LIMIT=50] -->
    <string name="reset_esim_title">Erase eSIMs</string>
    <!-- Erase Euicc dialog and 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">This won’t cancel your mobile service plan. To get a replacement SIM, contact your carrier.</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, message on screen after user selects Reset settings button [CHAR LIMIT=NONE] -->
    <string name="reset_network_final_desc_esim">Reset all network settings and erase eSIMs? 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">Can\u2019t erase eSIMs</string>
    <!-- Message of the error message shown when error happens during erase eSIM data [CHAR LIMIT=NONE] -->
    <string name="reset_esim_error_msg">Something went wrong and your eSIMs weren\u2019t erased.\n\nRestart your device and try again.</string>

    <!-- Main Clear -->
    <!-- Button title to factory data reset the entire device [CHAR LIMIT=NONE] -->
    <string name="main_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="main_clear_short_title">Erase all data (factory reset)</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="main_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="main_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="main_clear_desc_no_cancel_mobile_plan">"\n\nThis will not cancel your mobile service plan.</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button [CHAR LIMIT=NONE] -->
    <string name="main_clear_final_desc">All of your personal information and downloaded apps will be deleted. You can\u2019t undo this action.</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button [CHAR LIMIT=NONE] -->
    <string name="main_clear_final_desc_esim">All of your personal information, including downloaded apps &amp; eSIMs, will be deleted. You can\u2019t undo this action.</string>
    <!-- Main clear confirmation screen title [CHAR LIMIT=33] -->
    <string name="main_clear_confirm_title">Erase all data?</string>
    <!-- Error message for users that aren't allowed to factory reset [CHAR LIMIT=none] -->
    <string name="main_clear_not_available">Factory reset is not available for this user</string>
    <!-- Main clear progress screen title [CHAR LIMIT=30] -->
    <string name="main_clear_progress_title" >Erasing</string>
    <!-- Main clear progress screen text [CHAR LIMIT=75] -->
    <string name="main_clear_progress_text">Please wait\u2026</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>

    <!-- Tethering setting summary when only Wi-Fi hotspot is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_only">Hotspot only</string>
    <!-- Tethering setting summary when only USB tethering is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_usb_tethering_only">USB only</string>
    <!-- Tethering setting summary when only Bluetooth tethering is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_bluetooth_tethering_only">Bluetooth only</string>
    <!-- Tethering setting summary when only Ethernet tethering is on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_ethernet_tethering_only">Ethernet only</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and USB tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_usb">Hotspot, USB</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and Bluetooth tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_bluetooth">Hotspot, Bluetooth</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_ethernet">Hotspot, Ethernet</string>
    <!-- Tethering setting summary when USB and Bluetooth tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_usb_and_bluetooth">USB, Bluetooth</string>
    <!-- Tethering setting summary when USB and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_usb_and_ethernet">USB, Ethernet</string>
    <!-- Tethering setting summary when Bluetooth and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_bluetooth_and_ethernet">Bluetooth, Ethernet</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and USB and Bluetooth tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth">Hotspot, USB, Bluetooth</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and USB and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet">Hotspot, USB, Ethernet</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and Bluetooth and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet">Hotspot, Bluetooth, Ethernet</string>
    <!-- Tethering setting summary when USB and Bluetooth and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet">USB, Bluetooth, Ethernet</string>
    <!-- Tethering setting summary when Wi-Fi hotspot and USB and Bluetooth and Ethernet tethering are on [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_all">Hotspot, USB, Bluetooth, Ethernet</string>

    <!-- Tethering setting summary when hotspot and tethering are off [CHAR LIMIT=NONE]-->
    <string name="tether_settings_summary_off">Not sharing internet with other devices</string>
    <!-- Tethering preference summary when hotspot and tethering are off [CHAR LIMIT=NONE]-->
    <string name="tether_preference_summary_off">Off</string>

    <!-- USB Tethering options -->
    <!-- Label for USB tethering switch [CHAR LIMIT=NONE]-->
    <string name="usb_tethering_button_text">USB tethering</string>

    <!-- Bluetooth Tethering settings-->
    <!-- Label for bluetooth tether checkbox [CHAR LIMIT=25]-->
    <string name="bluetooth_tether_checkbox_text">Bluetooth tethering</string>

    <!-- Ethernet Tethering settings-->
    <!-- Label for ethernet tether checkbox [CHAR LIMIT=NONE]-->
    <string name="ethernet_tether_checkbox_text">Ethernet tethering</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 footer info for the device which supports Wi-Fi and Wi-Fi tethering enabled at the same time [CHAR LIMIT=NONE]-->
    <string name="tethering_footer_info_sta_ap_concurrency">Use hotspot and tethering to provide internet to other devices through your Wi\u2011Fi or 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>

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

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

    <!-- Location settings screen, sub category for recent location requests [CHAR LIMIT=42] -->
    <string name="location_category_recent_location_requests">Recent location requests</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 location permissions</string>
    <!-- Summary for app permission on Location settings page when location is off [CHAR LIMIT=NONE] -->
    <string name="location_app_permission_summary_location_off">Location is off</string>
    <!--
    Summary for Location settings when location is on, explaining how many apps have location
    permission.

    Please note that the distinction between singular and plural of this sentence only depends on
    the quantity of "permitted_location_app_count" ("has" vs "have"). The quantity of
    "total_location_app_count" is almost always greater than 1, so "apps" is always in plural form.

    [CHAR LIMIT=NONE]-->
    <string name="location_app_permission_summary_location_on">{count, plural,
      =1      {# of {total} apps has access to location}
      other   {# of {total} apps have access to location}
    }</string>
    <!-- [CHAR LIMIT=50] Location settings screen, sub category for recent location access -->
    <string name="location_category_recent_location_access">Recent access</string>
    <!-- Location settings screen, displayed when there're more than three recent location access apps [CHAR LIMIT=30] -->
    <string name="location_recent_location_access_see_all">See all</string>
    <!-- [CHAR LIMIT=30] Location settings screen, button to bring the user to view the details of recent location access -->
    <string name="location_recent_location_access_view_details">View details</string>
    <!-- Location settings screen, displayed when there's no recent app accessing location
      (for TV) [CHAR LIMIT=100] -->
    <string name="location_no_recent_apps">No apps have requested location recently</string>
    <!-- Location settings screen, displayed when there's no recent app accessing location
      (for phones and tablets) [CHAR LIMIT=100] -->
    <string name="location_no_recent_accesses">No apps recently accessed location</string>
    <!-- [CHAR LIMIT=30] Location settings screen, recent location requests high battery use-->
    <string name="location_high_battery_use">High battery use</string>
    <!-- [CHAR LIMIT=30] Location settings screen, recent location requests low battery use-->
    <string name="location_low_battery_use">Low battery use</string>
    <!-- [CHAR LIMIT=130] 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=60] Location Services preference title -->
    <string name="location_services_preference_title">Location services</string>
    <!-- [CHAR LIMIT=60] Location Services screen, screen title -->
    <string name="location_services_screen_title">Location services</string>

    <!-- [CHAR LIMIT=60] Date&Time settings screen, toggle button title -->
    <string name="location_time_zone_detection_toggle_title">Use location</string>
    <!-- [CHAR LIMIT=50] Date&Time settings screen, title of the dialog when AutoTimeZone is degraded -->
    <string name="location_time_zone_detection_status_title">Cannot set the time zone automatically</string>
    <!-- Date&Time settings screen, summary of the dialog when AutoTimeZone is degraded by settings-->
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" />
    <!-- [CHAR LIMIT=60] Date&Time settings screen, summary of the dialog when AutoTimeZone is blocked by settings -->
    <string name="location_time_zone_detection_status_summary_blocked_by_settings">Location or Location Services are off</string>
    <!-- Date&Time settings screen, summary of the dialog when AutoTimeZone is blocked by the environment-->
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" />
    <!-- Date&Time settings screen, summary of the dialog when AutoTimeZone is temporarily unavailable-->
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" />
    <!-- [CHAR LIMIT=60] Date&Time settings screen, title of the dialog shown when user tries to
         enable GeoTZ when Location toggle is off. -->
    <string name="location_time_zone_detection_location_is_off_dialog_title">Device location needed</string>
    <!-- [CHAR LIMIT=NONE] Date&Time settings screen, message on the dialog shown when user tries to
         enable GeoTZ when Location toggle is off. -->
    <string name="location_time_zone_detection_location_is_off_dialog_message">To set the time zone using your location, turn on location, then update time zone settings</string>
    <!-- [CHAR LIMIT=30] Date&Time settings screen, button on a dialog shown when user tries to
    enable GeoTZ, but Location toggle is off, which leads to Location settings page. -->
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button">Location settings</string>
    <!-- [CHAR LIMIT=30] Date&Time settings screen, button on a dialog shown when the LTZP needs to be fixed -->
    <string name="location_time_zone_provider_fix_dialog_ok_button">Fix this</string>
    <!-- [CHAR LIMIT=30] Date&Time settings screen, button on a dialog shown when user tries to
     enable GeoTZ, but Location toggle is off, which closes the dialog. -->
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button">Cancel</string>
    <!-- [CHAR LIMIT=NONE] Location settings screen, summary when location time zone detection is not
         applicable due to other settings like the "automatic time zone detection enabled" setting
         being set to "off". -->
    <string name="location_time_zone_detection_auto_is_off">Automatic time zone is off</string>
    <!-- [CHAR LIMIT=NONE] Location settings screen, summary when location time zone detection is not
         applicable for the user for unspecified reasons. More specific messages are used when there
         is a clear reason. -->
    <string name="location_time_zone_detection_not_applicable">Location time zone detection is disabled</string>
    <!-- [CHAR LIMIT=NONE] Location settings screen, summary when location time zone detection is not supported -->
    <string name="location_time_zone_detection_not_supported">Location time zone detection is not supported</string>
    <!-- [CHAR LIMIT=NONE] Location settings screen, summary when location time zone detection is not
         allowed for the user, e.g. because of device policy -->
    <string name="location_time_zone_detection_not_allowed">Location time zone detection changes are not allowed</string>
    <!-- [CHAR LIMIT=NONE] Location settings screen, summary when location time zone detection is enabled. -->
    <string name="location_time_zone_detection_auto_is_on">Location may be used to set time zone</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 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 licensing info for Google Play system updates [CHAR LIMIT=50] -->
    <string name="module_license_title">Google Play system update licenses</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">Wallpaper credits</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 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 device password flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_password_header">Set a password</string>
    <!-- Header on first screen of choose work profile password flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_profile_password_header">Set a work password</string>
    <!-- Header on first screen of choose device PIN flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pin_header">Set a PIN</string>
    <!-- Header on first screen of choose work profile PIN flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_profile_pin_header">Set a work PIN</string>
    <!-- Header on first screen of choose device pattern flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pattern_header">Set a pattern</string>
    <!-- Description on first screen of choose device pattern flow [CHAR LIMIT=NONE] -->
    <string name="lockpassword_choose_your_pattern_description">For added security, set a pattern to unlock the device</string>
    <!-- Header on first screen of choose work profile pattern flow [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_profile_pattern_header">Set a work pattern</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>
    <!-- Header on password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_password_header">Re-enter your password</string>
    <!-- Header on work profile password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_reenter_your_profile_password_header">Re-enter your work password</string>
    <!-- Header on password confirm screen for the work profile [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_work_password_header">Enter your work password</string>
    <!-- Header on pattern confirm screen [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_pattern_header">Confirm your pattern</string>
    <!-- Header on pattern confirm screen for the work profile [CHAR LIMIT=30] -->
    <string name="lockpassword_confirm_your_work_pattern_header">Enter your work pattern</string>
    <!-- Header on password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_pin_header">Re-enter your PIN</string>
    <!-- Header on work profile password confirm screen [CHAR LIMIT=40] -->
    <string name="lockpassword_reenter_your_profile_pin_header">Re-enter your work PIN</string>
    <!-- Header on password confirm screen for the work profile [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_your_work_pin_header">Enter your work 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>
    <!-- Header on first screen of choose password/PIN as backup for Face Unlock flow. If this string cannot be translated in under 40 characters, please translate "Set Face Unlock backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_password_header_for_face">To use Face Unlock, set password</string>
    <!-- Header on first screen of choose pattern as backup for Face Unlock flow. If this string cannot be translated in under 40 characters, please translate "Set Face Unlock backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pattern_header_for_face">To use Face Unlock, set pattern</string>
    <!-- Header on first screen of choose password/PIN as backup for Face Unlock flow. If this string cannot be translated in under 40 characters, please translate "Set Face Unlock backup" [CHAR LIMIT=40] -->
    <string name="lockpassword_choose_your_pin_header_for_face">To use Face Unlock, set PIN</string>

    <!-- Title of a screen that asks the user to set up a password as a backup for Face or Fingerprint Unlock. If this string can't be translated in 60 characters, please translate "Set a backup password". [CHAR LIMIT=60] -->
    <string name="lockpassword_choose_your_password_header_for_biometrics">Set a password to use face or fingerprint</string>
    <!-- Title of a screen that asks the user to set up a pattern as a backup for Face or Fingerprint Unlock. If this string can't be translated in 60 characters, please translate "Set a backup pattern". [CHAR LIMIT=60] -->
    <string name="lockpassword_choose_your_pattern_header_for_biometrics">Set a pattern to use face or fingerprint</string>
    <!-- Title of a screen that asks the user to set up a PIN as a backup for Face or Fingerprint Unlock. If this string can't be translated in 60 characters, please translate "Set a backup PIN". [CHAR LIMIT=60] -->
    <string name="lockpassword_choose_your_pin_header_for_biometrics">Set a PIN to use face or fingerprint</string>


    <!-- Text for button that the user should tap when they forgot their work profile password [CHAR LIMIT=40] -->
    <string name="lockpassword_forgot_password">Forgot your password?</string>
    <!-- Text for button that the user should tap when they forgot their work profile pattern [CHAR LIMIT=40] -->
    <string name="lockpassword_forgot_pattern">Forgot your pattern?</string>
    <!-- Text for button that the user should tap when they forgot their work profile PIN [CHAR LIMIT=40] -->
    <string name="lockpassword_forgot_pin">Forgot your PIN?</string>

    <!-- Message to be used to explain the users that they need to enter their pattern to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pattern_generic">Draw your pattern to continue</string>
    <!-- Message to be used to explain the users that they need to enter their PIN to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pin_generic">Enter your PIN to continue</string>
    <!-- Message to be used to explain the users that they need to enter their password to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_password_generic">Enter your password to continue</string>
    <!-- Message to be used to explain the users that they need to enter their work pattern to continue a
         particular operation. [CHAR LIMIT=70]-->
    <string name="lockpassword_confirm_your_pattern_generic_profile">Draw your work pattern to continue</string>
    <!-- Message to be used to explain the users that they need to enter their 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 users that they need to enter their 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>

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

    <!-- Header shown when prompted for remote device credential validation. [CHAR LIMIT=17] -->
    <string name="lockpassword_remote_validation_header">Verify it\u0027s you</string>

    <!-- Details shown when pattern is prompted for remote device credential validation. [CHAR LIMIT=160] -->
    <string name="lockpassword_remote_validation_pattern_details">To transfer Google Accounts, settings, and more, enter your other device\u0027s pattern. Your pattern is encrypted.</string>
    <!-- Details shown when PIN is prompted for remote device credential validation. [CHAR LIMIT=160] -->
    <string name="lockpassword_remote_validation_pin_details">To transfer Google Accounts, settings, and more, enter your other device\u0027s PIN. Your PIN is encrypted.</string>
    <!-- Details shown when password is prompted for remote device credential validation. [CHAR LIMIT=160] -->
    <string name="lockpassword_remote_validation_password_details">To transfer Google Accounts, settings, and more, enter your other device\u0027s password. Your password is encrypted.</string>

    <!-- Checkbox label to set pattern as new screen lock if remote device credential validation succeeds. [CHAR LIMIT=43] -->
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock">Also use pattern to unlock this device</string>
    <!-- Checkbox label to set PIN as new screen lock if remote device credential validation succeeds. [CHAR LIMIT=43] -->
    <string name="lockpassword_remote_validation_set_pin_as_screenlock">Also use PIN to unlock this device</string>
    <!-- Checkbox label to set password as new screen lock if remote device credential validation succeeds. [CHAR LIMIT=43] -->
    <string name="lockpassword_remote_validation_set_password_as_screenlock">Also use password to unlock this device</string>

    <!-- Header shown when pattern needs to be solved before the device exits repair mode. [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_repair_mode_pattern_header">Verify pattern</string>
    <!-- Header shown when the pin needs to be solved before the device exits repair mode. [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_repair_mode_pin_header">Verify PIN</string>
    <!-- Header shown when the password needs to be solved before the device exits repair mode. [CHAR LIMIT=40] -->
    <string name="lockpassword_confirm_repair_mode_password_header">Verify password</string>
    <!-- An explanation text that the pattern needs to be solved before the device exits repair mode. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_repair_mode_pattern_details">Use your device pattern to continue</string>
    <!-- An explanation text that the PIN needs to be solved before the device exits repair mode. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_repair_mode_pin_details">Enter your device PIN to continue</string>
    <!-- An explanation text that the password needs to be solved before the device exits repair mode. [CHAR LIMIT=100] -->
    <string name="lockpassword_confirm_repair_mode_password_details">Enter your device password to continue</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>
    <!-- Work challenge screen, this string is the label for an emergency call button, which opens the personal safety app to allow the user to make an emergency call. [CHAR LIMIT=20] -->
    <string name="work_challenge_emergency_button_text">Emergency</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 users move their finger around while drawing the unlock pattern.  If checked, this line is drawn.  If unchecked, there is nothing drawn so the users do not reveal their pattern while they unlock the phone.-->
    <string name="lockpattern_settings_enable_visible_pattern_title">Make pattern visible</string>
    <!-- Security & location settings screen, setting check box title. This setting disables animations when entering the PIN.-->
    <string name="lockpattern_settings_enhanced_pin_privacy_title">Enhanced PIN privacy</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary">Disable animations while entering the PIN</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether a visible green line is drawn as the users move their finger around while drawing the profile unlock pattern.  If checked, this line is drawn.  If unchecked, there is nothing drawn so the users do not reveal their pattern while they unlock 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 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 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">{count, plural,
      =1      {See all apps}
      other   {See all # apps}
    }</string>

    <!-- Title of the dialog that asks the user to contact the IT admin to reset password [CHAR LIMIT=40] -->
    <string name="forgot_password_title">Contact your IT admin</string>
    <!-- Content of the dialog that asks the user to contact the IT admin to reset password [CHAR LIMIT=100] -->
    <string name="forgot_password_text">They can help you reset your PIN, pattern, or password</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)-->
    <string name="uri_permissions_text">{count, plural,
      =1      {1 item}
      other   {# items}
    }</string>
    <!-- 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, text label for button to archive an application. Archiving means uninstalling the app without deleting user's personal data and replacing the app with a stub app with minimum size. So, the user can unarchive the app later and not lose any personal data. -->
    <string name="archive">Archive</string>
    <!-- Manage applications, text label for button to restore an application. Restoring means installing the archived app. -->
    <string name="restore">Restore</string>
    <!-- Manage applications, text label for button while the application is restoring. -->
    <string name="restoring_step_one">Restoring</string>
    <!-- Manage applications, text label for button while the application is restoring. -->
    <string name="restoring_step_two">Restoring.</string>
    <!-- Manage applications, text label for button while the application is restoring. -->
    <string name="restoring_step_three">Restoring..</string>
    <!-- Manage applications, text label for button while the application is restoring. -->
    <string name="restoring_step_four">Restoring...</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, 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>
    <!-- [CHAR LIMIT=50] Manage applications, unlock restricted setting from lock screen title -->
    <string name="app_restricted_settings_lockscreen_title">Allow restricted settings</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">Some activities you\u2019ve selected open in this app by default.</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 default preferences</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<li>Battery usage settings</li>\n\nYou 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>
    <!-- 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>
    <!-- [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>
    <!-- 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">This app\u2019s data, including files and settings, will be permanently deleted from this device</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. -->
    <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 screen, confirmation dialog button. Displays when user selects to "Clear data". Goes through with the clearing of the data. [CHAR LIMIT=25] -->
    <string name="dlg_delete">Delete</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>
    <string name="computing_size">Computing\u2026</string>
    <string name="invalid_size_value">Couldn\u2019t compute package size.</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>

    <!-- Toast message when archiving an app failed. -->
    <string name="archiving_failed">Archiving failed</string>
    <!-- Toast message when archiving an app succeeded. -->
    <string name="archiving_succeeded">Archived <xliff:g id="package_label" example="Translate">%1$s</xliff:g></string>
    <!-- Toast message when restoring an app failed. -->
    <string name="restoring_failed">Restoring failed</string>
    <!-- Toast message when restoring an app has started. -->
    <string name="restoring_in_progress">Restoring <xliff:g id="package_label" example="Translate">%1$s</xliff:g></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="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>
    <!-- [CHAR LIMIT=30] Manage applications, title for dialog when killing persistent apps-->
    <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>
    <!-- [CHAR LIMIT=30] Manage applications, label for option to disable app -->
    <string name="app_disable_dlg_positive">Disable app</string>
    <!-- [CHAR LIMIT=NONE] 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. Keep in mind, you can\u2019t delete this app since it came pre-installed on your device. By disabling, you turn this app off and hide it on your device.</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] 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>

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

    <!-- Languages Settings --> <skip />
    <!-- Title of Language, input & gestures setting on main settings screen. -->
    <string name="language_input_gesture_title">Languages, input &amp; gestures</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>
    <!-- Title of setting on main settings screen.  This item will take the user to the screen to tweak settings related to languages -->
    <string name="languages_settings">Languages</string>
    <!-- Title of setting on main settings screen.  This item will take the user to the screen to tweak settings related to keyboards -->
    <string name="keyboard_settings">Keyboard</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">Tools</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 Languages settings screen, setting option name. title of the setting to take the user to a screen to select the locale. -->
    <string name="system_language">System Languages</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 users finish a sentence, the next letter they type will automatically be capitalized. [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">Keyboards</string>
    <!-- Title for the 'virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="virtual_keyboard_category">On-screen keyboard</string>
    <!-- Keywords for the 'virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="keywords_virtual_keyboard">Gboard</string>
    <!-- Title for the 'available virtual keyboard' preference sub-screen. [CHAR LIMIT=35] -->
    <string name="available_virtual_keyboard_category">Available On-screen 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 on-screen keyboards</string>
    <!-- Title for the 'keyboard options' preference category. [CHAR LIMIT=35] -->
    <string name="keyboard_options_category">Options</string>
    <!-- Title for the 'keyboard accessibility options' preference category. [CHAR LIMIT=35] -->
    <string name="keyboard_a11y_category">Accessibility</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">Use on-screen 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 'Bounce keys' preference switch. [CHAR LIMIT=35] -->
    <string name="bounce_keys">Bounce keys</string>
    <!-- Summary text for the 'Bounce keys' preference sub-screen. [CHAR LIMIT=100] -->
    <string name="bounce_keys_summary">Enable Bounce keys for physical keyboard accessibility</string>
    <!-- Title for the 'Slow keys' preference switch. [CHAR LIMIT=35] -->
    <string name="slow_keys">Slow keys</string>
    <!-- Summary text for the 'Slow keys' preference sub-screen. [CHAR LIMIT=100] -->
    <string name="slow_keys_summary">Enable Slow keys for physical keyboard accessibility</string>
    <!-- Title for the 'Sticky keys' preference switch. [CHAR LIMIT=35] -->
    <string name="sticky_keys">Sticky keys</string>
    <!-- Summary text for the 'Sticky keys' preference sub-screen. [CHAR LIMIT=100] -->
    <string name="sticky_keys_summary">Enable Sticky keys for physical keyboard accessibility</string>
    <!-- Title for the button to trigger the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=35] -->
    <string name="keyboard_shortcuts_helper">Keyboard shortcuts</string>
    <!-- Summary text for the 'keyboard shortcuts helper' dialog. [CHAR LIMIT=100] -->
    <string name="keyboard_shortcuts_helper_summary">Show list of shortcuts</string>
    <!-- Title for the 'Work profile keyboards & tools' preference category inside Languages and inputs'. [CHAR LIMIT=50] -->
    <string name="language_and_input_for_work_category_title">Work profile keyboards &amp; tools</string>
    <!-- Title for the 'Virtual keyboards for work' preference. [CHAR LIMIT=45] -->
    <string name="virtual_keyboards_for_work_title">On-screen keyboard for work</string>
    <!-- Summary text for none selected keyboard default layout -->
    <string name="keyboard_default_layout">Default</string>

    <!-- Title for the button to trigger the 'trackpad settings' page if only connect with a touchpad. [CHAR LIMIT=35] -->
    <string name="trackpad_settings">Touchpad</string>
    <!-- Title for the button to trigger the 'trackpad settings' page if connect with a touchpad and a mouse. [CHAR LIMIT=35] -->
    <string name="trackpad_mouse_settings">Touchpad &amp; mouse</string>
    <!-- Summary text for the 'trackpad settings' page. [CHAR LIMIT=100] -->
    <string name="trackpad_settings_summary">Pointer speed, gestures</string>

    <!-- Title text for 'Tap to click'. [CHAR LIMIT=35] -->
    <string name="trackpad_tap_to_click">Tap to click</string>
    <!-- Title text for 'Touchpad gestures' [CHAR LIMIT=35] -->
    <string name="trackpad_touchpad_gesture_title">Touchpad gestures</string>
    <!-- Summary text for 'Touchpad gestures' [CHAR LIMIT=60] -->
    <string name="trackpad_touchpad_gesture_summary">Customize individual touchpad navigation gestures</string>
    <!-- Title text for 'Reverse scrolling' [CHAR LIMIT=35] -->
    <string name="trackpad_reverse_scrolling_title">Reverse scrolling</string>
    <!-- Summary text for 'Reverse scrolling' [CHAR LIMIT=60] -->
    <string name="trackpad_reverse_scrolling_summary">Content moves up when you scroll down</string>
    <!-- Title text for 'Bottom-right tap' [CHAR LIMIT=35] -->
    <string name="trackpad_bottom_right_tap_title">Bottom-right tap</string>
    <!-- Summary text for 'Bottom-right tap' [CHAR LIMIT=60] -->
    <string name="trackpad_bottom_right_tap_summary">Tap the bottom right corner of the touchpad for more options</string>
    <!-- Title text for 'Pointer speed'. [CHAR LIMIT=35] -->
    <string name="trackpad_pointer_speed">Pointer speed</string>
    <!-- Title for the button to trigger the 'touch gesture' education. [CHAR LIMIT=35] -->
    <string name="trackpad_touch_gesture">Learn touchpad gestures</string>

    <!-- Title text for 'Go home' gesture education [CHAR LIMIT=35] -->
    <string name="gesture_title_go_home">Go home</string>
    <!-- Summary text for 'Go home' gesture education [CHAR LIMIT=60] -->
    <string name="gesture_summary_go_home">Swipe up with three fingers anywhere on your touchpad</string>
    <!-- Title text for 'Go back' gesture education [CHAR LIMIT=35] -->
    <string name="gesture_title_go_back">Go back</string>
    <!-- Summary text for 'Go back' gesture education [CHAR LIMIT=60] -->
    <string name="gesture_summary_go_back">Swipe from the left or right with three fingers</string>
    <!-- Title text for 'View recent apps' gesture education [CHAR LIMIT=35] -->
    <string name="gesture_title_recent_apps">View recent apps</string>
    <!-- Summary text for 'View recent apps' gesture education [CHAR LIMIT=60] -->
    <string name="gesture_summary_recent_apps">Swipe up with three fingers, hold, then release</string>
    <!-- Title text for 'View notifications' gesture education [CHAR LIMIT=35] -->
    <string name="gesture_title_notifications">View notifications &amp; Quick Settings</string>
    <!-- Summary text for 'View notifications' gesture education [CHAR LIMIT=60] -->
    <string name="gesture_summary_notifications">Swipe down with three fingers on your home screen</string>
    <!-- Title text for 'Switch apps' gesture education [CHAR LIMIT=35] -->
    <string name="gesture_title_switch_apps">Switch apps</string>
    <!-- Summary text for 'Switch apps' gesture education [CHAR LIMIT=60] -->
    <string name="gesture_summary_switch_apps">Swipe left or right with four fingers</string>

    <!-- Text for 'Skip' button in gesture education [CHAR LIMIT=10] -->
    <string name="gesture_button_skip">Skip</string>
    <!-- Text for 'Next' button in gesture education [CHAR LIMIT=10] -->
    <string name="gesture_button_next">Next</string>
    <!-- Text for 'Restart' button in gesture education [CHAR LIMIT=10] -->
    <string name="gesture_button_restart">Restart</string>
    <!-- Text for 'Done' button in gesture education [CHAR LIMIT=10] -->
    <string name="gesture_button_done">Done</string>

    <!-- Title text for 'Go back' [CHAR LIMIT=35] -->
    <string name="trackpad_go_back_title">Go back</string>
    <!-- Summary text for 'Go back' [CHAR LIMIT=60] -->
    <string name="trackpad_go_back_summary">Swipe left or right with three fingers</string>
    <!-- Title text for 'Go home' [CHAR LIMIT=35] -->
    <string name="trackpad_go_home_title">Go home</string>
    <!-- Summary text for 'Go home' [CHAR LIMIT=60] -->
    <string name="trackpad_go_home_summary">Swipe up with three fingers</string>
    <!-- Title text for 'Recent apps' [CHAR LIMIT=35] -->
    <string name="trackpad_recent_apps_title">Recent apps</string>
    <!-- Summary text for 'Recent apps' [CHAR LIMIT=60] -->
    <string name="trackpad_recent_apps_summary">Swipe up with three fingers, then hold</string>
    <!-- Title text for 'Notifications' [CHAR LIMIT=35] -->
    <string name="trackpad_notifications_title">Notifications</string>
    <!-- Summary text for 'Notifications' [CHAR LIMIT=60] -->
    <string name="trackpad_notifications_summary">Swipe down with three fingers</string>
    <!-- Title text for 'Switch apps' [CHAR LIMIT=35] -->
    <string name="trackpad_switch_apps_title">Switch apps</string>
    <!-- Summary text for 'Switch apps' [CHAR LIMIT=60] -->
    <string name="trackpad_switch_apps_summary">Swipe left or right with four fingers</string>

    <!-- Title for the button to trigger the 'modifier keys settings' page. [CHAR LIMIT=35] -->
    <string name="modifier_keys_settings">Modifier keys</string>
    <!-- Summary text for the 'modifier_keys_settings' page. [CHAR LIMIT=100] -->
    <string name="modifier_keys_settings_summary">Change the behavior of keys</string>

    <!-- Title for the button to trigger the 'modifier keys caps lock'. [CHAR LIMIT=15] -->
    <string name="modifier_keys_caps_lock" translatable="false">Caps lock</string>
    <!-- Title for the button to trigger the 'modifier keys ctrl'. [CHAR LIMIT=15] -->
    <string name="modifier_keys_ctrl" translatable="false">Ctrl</string>
    <!-- Title for the button to trigger the 'modifier keys action key'. [CHAR LIMIT=15] -->
    <string name="modifier_keys_meta" translatable="false">Action key</string>
    <!-- Title for the button to trigger the 'modifier keys alt'. [CHAR LIMIT=15] -->
    <string name="modifier_keys_alt" translatable="false">Alt</string>

    <!-- Title for the button to trigger the 'modifier keys reset all'. [CHAR LIMIT=35] -->
    <string name="modifier_keys_reset_title">Reset all</string>
    <!-- Summary text for the buttons. [CHAR LIMIT=35] -->
    <string name="modifier_keys_default_summary">Default</string>
    <!-- Message for the 'Reset all' page. [CHAR LIMIT=100] -->
    <string name="modifier_keys_reset_message">Are you sure you would like to reset all the modifier keys to their default?</string>
    <!-- Text of the done button. [CHAR LIMIT=15] -->
    <string name="modifier_keys_done">Done</string>
    <!-- Text of the cancel button. [CHAR LIMIT=15] -->
    <string name="modifier_keys_cancel">Cancel</string>
    <!-- Text of the restore button. [CHAR LIMIT=15] -->
    <string name="modifier_keys_reset">Reset</string>
    <!-- Title for the modifier key picker dialog page [CHAR LIMIT=35] -->
    <string name="modifier_keys_picker_title">Choose modifier key</string>
    <!-- Summary for the modifier key picker dialog page [CHAR LIMIT=35] -->
    <string name="modifier_keys_picker_summary">Choose a new key for <xliff:g id="modifier_key_default_name">%1$s</xliff:g>:</string>

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

    <!-- Title for the 'Speech' preference category. [CHAR LIMIT=45] -->
    <string name="speech_category_title">Speech</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>
    <!-- Category title for the keyboard layout picker activity. [CHAR LIMIT=35] -->
    <string name="keyboard_layout_picker_category_title">Physical 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>
    <!-- Title for the 'Spell checker for work' preference. [CHAR LIMIT=45] -->
    <string name="user_dict_settings_for_work_title">Personal dictionary for work</string>
    <!-- User dictionary settings.  The summary of the list item to go into the Personal dictionary settings screen. -->
    <string name="user_dict_settings_summary">Add words to be used in apps such as Spell checker</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>
    <!-- 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>

    <!-- Summary for default keyboard settings -->
    <string name="keyboard_settings_summary">On-screen keyboard, tools</string>
    <!-- Summary for keyboard settings attaching physical_keyboard  -->
    <string name="keyboard_settings_with_physical_keyboard_summary">On-screen keyboard, physical keyboard, tools</string>
    <!-- Title for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_title">Physical keyboard</string>

    <!-- Title for enabled locales keyboard layout page -->
    <string name="enabled_locales_keyboard_layout">Layout</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, the application can access everything displayed.\n\nApplication: <xliff:g id="widget_host_name">%1$s</xliff:g>\nWidget: <xliff:g id="widget_label">%2$s</xliff:g>\n</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>

    <!-- In the Testing screen. The item title of the activity that shows usage statistics.  -->
    <string name="testing_usage_stats">Usage statistics</string>
    <!-- Spinner label to indicate sort by usage time. [CHAR LIMIT=30] -->
    <string name="usage_stats_sort_by_usage_time">Sort by usage time</string>
    <!-- Spinner label to indicate sort by last time used. [CHAR LIMIT=30] -->
    <string name="usage_stats_sort_by_last_time_used">Sort by last time used</string>
    <!-- Spinner label to indicate sort by app name. [CHAR LIMIT=30] -->
    <string name="usage_stats_sort_by_app_name">Sort by app name</string>
    <!-- label for last time used -->
    <string name="last_time_used_label">Last used</string>
    <!-- label for last time used of never opened apps -->
    <string name="last_time_used_never">never</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">Display, interaction, audio</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 reader</string>
    <!-- Title for the accessibility preference category of caption services and settings. [CHAR LIMIT=50] -->
    <string name="captions_category_title">Captions</string>
    <!-- Title for the accessibility preference category of audio services and settings. [CHAR LIMIT=50] -->
    <string name="audio_category_title">Audio</string>
    <!-- Title for the accessibility preference category of general services and settings. [CHAR LIMIT=50] -->
    <string name="general_category_title">General</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 color and motion page. [CHAR LIMIT=50] -->
    <string name="accessibility_color_and_motion_title">Color and motion</string>
    <!-- Title for the accessibility text options page. [CHAR LIMIT=50] -->
    <string name="accessibility_turn_screen_darker_title">Turn screen darker</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 tap assistance page. [CHAR LIMIT=50] -->
    <string name="accessibility_tap_assistance_title">Timing controls</string>
    <!-- Title for the accessibility system controls page. [CHAR LIMIT=50] -->
    <string name="accessibility_system_controls_title">System 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 apps</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 where developers can turn on experimental features [CHAR LIMIT=50] -->
    <string name="feature_flags_dashboard_title">Feature flags</string>
    <!-- Title for snoop logger filters dashboard where developers can turn on filters [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filters_dashboard_title">Bluetooth HCI snoop log filtering</string>
    <!-- Summary for the snoop logger filters [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filters_dashboard_summary">Set filters</string>
    <!-- Summary for the snoop logger filters [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filters_dashboard_footer">Disable and enable Bluetooth for the changes to take effect</string>
    <!-- Title for the snoop logger pbap filter [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filter_pbap_title">Bluetooth HCI snoop log filtering PBAP</string>
    <!-- Title for the snoop logger map filter [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filter_map_title">Bluetooth HCI snoop log filtering MAP</string>
    <!-- Summary for the snoop logger filters [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filter_summary">Set filtering mode. (Disable and enable Bluetooth for the changes to take effect)</string>
    <!-- Summary for the snoop logger profile filters while disabled [CHAR LIMIT=100] -->
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary">Set Bluetooth HCI snoop log mode to Enabled Filtered to change this option</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">Caption preferences</string>
    <!-- Title for accessibility captioning footer. [CHAR LIMIT=60] -->
    <string name="accessibility_captioning_about_title">About caption preferences</string>
    <!-- Accessibility captioning footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_captioning_footer_learn_more_content_description">Learn more about caption preferences</string>
    <!-- Title for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_title">Magnification</string>
    <!-- Title for accessibility shortcut preference for magnification. [CHAR LIMIT=60] -->
    <string name="accessibility_screen_magnification_shortcut_title">Magnification shortcut</string>
    <!-- Title for accessibility follow typing preference for magnification. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_follow_typing_title">Magnify typing</string>
    <!-- Summary for accessibility follow typing preference for magnification. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_follow_typing_summary">Magnifier follows text as you type</string>
    <!-- Title for accessibility magnifier preference where the magnifier never turns off while switching apps. [CHAR LIMIT=60] -->
    <string name="accessibility_screen_magnification_always_on_title">Keep on while switching apps</string>
    <!-- Summary for accessibility magnifier preference where the magnifier never turns off while switching apps. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_always_on_summary">Magnifier stays on and zooms out when you switch apps</string>
    <!-- Title for accessibility on-screen joystick controller preference that controls magnification position. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_magnification_joystick_title">Joystick</string>
    <!-- Summary for accessibility on-screen joystick controller preference that controls magnification position. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_joystick_summary">Activate and move the magnifier with an on-screen joystick. Tap and hold, then drag on the joystick to control the magnifier. Tap and drag to move the joystick itself.</string>
    <!-- Title for screen magnification footer. [CHAR LIMIT=60] -->
    <string name="accessibility_screen_magnification_about_title">About magnification</string>
    <!-- Screen magnification footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_screen_magnification_footer_learn_more_content_description">Learn more about magnification</string>
    <!-- Title for the accessibility preference screen to edit magnification area. [CHAR LIMIT=35] -->
    <string name="accessibility_magnification_mode_title">Magnification type</string>
    <!-- Message for the accessibility preference screen to edit magnification area dialog. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_message">Magnify your full screen, a specific area, or switch between both options</string>
    <!-- Summary for the accessibility preference screen to edit full screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_full_screen_summary">Full screen</string>
    <!-- Summary for the accessibility preference screen to edit partial screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_window_screen_summary">Partial screen</string>
    <!-- Summary for the accessibility preference screen to edit full and partial screen. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_all_summary">Switch between full and partial screen</string>
    <!-- dialog title for magnification mode  selection. [CHAR LIMIT=35] -->
    <string name="accessibility_magnification_mode_dialog_title">Choose how to magnify</string>
    <!-- Option title of full-screen magnification mode in the mode selection dialog. [CHAR LIMIT=50] -->
    <string name="accessibility_magnification_mode_dialog_option_full_screen">Magnify full screen</string>
    <!-- Option title of window magnification mode in the mode selection dialog. [CHAR LIMIT=50] -->
    <string name="accessibility_magnification_mode_dialog_option_window">Magnify part of screen</string>
    <!-- Option title of full magnification mode in the mode selection dialog. [CHAR LIMIT=50] -->
    <string name="accessibility_magnification_mode_dialog_option_switch">Switch between full and partial screen</string>
    <!-- Message of the magnification mode option to choose the magnification mode. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_area_settings_mode_switch_summary">Tap the switch button to move between both options</string>
    <!-- Title for the accessibility magnification switch shortcut dialog. [CHAR LIMIT=48] -->
    <string name="accessibility_magnification_switch_shortcut_title">Switch to accessibility button?</string>
    <!-- Message for the accessibility magnification switch shortcut dialog. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_switch_shortcut_message">Using triple-tap to magnify part of your screen causes typing and other delays.\n\nThe accessibility button floats on your screen over other apps. Tap it to magnify.</string>
    <!-- Title for the switch shortcut button in accessibility switch shortcut dialog to change the config shortcut value. [CHAR LIMIT=45] -->
    <string name="accessibility_magnification_switch_shortcut_positive_button">Switch to accessibility button</string>
    <!-- Title for the cancel button in accessibility switch shortcut dialog to keep the config shortcut value. [CHAR LIMIT=54] -->
    <string name="accessibility_magnification_switch_shortcut_negative_button">Use triple-tap</string>
    <!-- Title for the accessibility magnification triple tap warning dialog. [CHAR LIMIT=48] -->
    <string name="accessibility_magnification_triple_tap_warning_title">This may slow down your keyboard</string>
    <!-- Message for the accessibility magnification triple tap warning dialog. [CHAR LIMIT=none] -->
    <string name="accessibility_magnification_triple_tap_warning_message">When using triple-tap to magnify part of your screen, you may notice issues over the keyboard.\n\nTo avoid this, you can change your magnification shortcut from triple-tap to another option.\n<annotation id="link">Change setting</annotation></string>
    <!-- Title for the continue button in accessibility triple tap warning dialog to confirm the action. [CHAR LIMIT=30] -->
    <string name="accessibility_magnification_triple_tap_warning_positive_button">Continue anyway</string>
    <!-- Title for the cancel button in accessibility triple tap warning dialog to go back to edit. [CHAR LIMIT=12] -->
    <string name="accessibility_magnification_triple_tap_warning_negative_button">Cancel</string>
    <!-- Title for the accessibility preference screen to enable screen magnification settings. [CHAR LIMIT=35] -->
    <string name="accessibility_magnification_service_settings_title">Magnification settings</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 shortcut</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 shortcut &amp; triple-tap</string>
    <!-- Title for the footer text to explain what accessibility service does. [CHAR LIMIT=35] -->
    <string name="accessibility_introduction_title">About <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
    <!-- Title for the accessibility preference to adjust the display size, font size, bold text, and high contrast text features. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_options_title">Display size and text</string>
    <!-- Title for the entry of the text reading options. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_options_suggestion_title">Change how text displays</string>
    <!-- Subject for the mail content of the accessibility text reading preview. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_preview_mail_subject">Subject: Hot air balloon designs</string>
    <!-- Message for the mail content of the accessibility text reading preview. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_preview_mail_from">From: Bill</string>
    <!-- Content for the mail content of the accessibility text reading preview. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_preview_mail_content">Good morning!\n\nI just wanted to check how the designs are coming. Will they be ready before we start building the new balloons?</string>
    <!-- Title for the reset button of the accessibility text reading page to reset all preferences state. [CHAR LIMIT=25] -->
    <string name="accessibility_text_reading_reset_button_title">Reset settings</string>
    <!-- Message for the toast after clicking the reset button of the dialog of the accessibility text reading page. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_reset_message">Display size and text settings have been reset</string>
    <!-- Title for the confirm dialog of reset settings. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_confirm_dialog_title">Reset display size and text?</string>
    <!-- Title for the reset button of the confirm dialog of reset settings. [CHAR LIMIT=25] -->
    <string name="accessibility_text_reading_confirm_dialog_reset_button">Reset</string>
    <!-- Conversation message for the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_conversation_message_1">Any weekend plans?</string>
    <!-- Conversation message for the messaging app preview screen. [CHAR LIMIT=NONE] -->
    <string name="accessibility_text_reading_conversation_message_2">Heading to the beach. Want to join?</string>
    <!-- Title for the footer text to explain what option accessibility service does. [CHAR LIMIT=35] -->
    <string name="accessibility_screen_option">Options</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>
    <!-- Intro for the accessibility preference screen to enable screen magnification gestures. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_intro_text">Quickly zoom in on the screen to make content larger</string>
    <!-- Instructions on the accessibility preference screen teaching the user how to enable screen magnification gestures. [CHAR LIMIT=none] -->
    <string name="accessibility_screen_magnification_summary">
        <![CDATA[
        <b>To zoom in:</b><br/>
        {0,number,integer}. Use shortcut to start magnification<br/>
        {1,number,integer}. Tap the screen<br/>
        {2,number,integer}. Drag 2 fingers to move around screen<br/>
        {3,number,integer}. Pinch with 2 fingers to adjust zoom<br/>
        {4,number,integer}. Use shortcut to stop magnification<br/><br/>
        <b>To zoom in temporarily:</b><br/>
        {0,number,integer}. Make sure your magnification type is set to full screen<br/>
        {1,number,integer}. Use shortcut to start magnification<br/>
        {2,number,integer}. Touch & hold anywhere on the screen<br/>
        {3,number,integer}. Drag finger to move around screen<br/>
        {4,number,integer}. Lift finger to stop magnification
        ]]>
    </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, you can zoom in on your screen.\n\n<b>To zoom</b>, start magnification, 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>, start magnification, 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>
    <!-- Accessibility label for paging indicator in accessibility tutorial page. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_pager">Page <xliff:g id="current_page" example="2">%1$d</xliff:g> of <xliff:g id="num_pages" example="3">%2$d</xliff:g></string>
    <!-- Title for the accessibility tutorial dialog in accessibility service with button. [CHAR LIMIT=50] -->
    <string name="accessibility_tutorial_dialog_title_button">Use accessibility button to open</string>
    <!-- Title for the accessibility tutorial dialog in accessibility service with volume keys. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_title_volume">Hold volume keys to open</string>
    <!-- Title for the accessibility tutorial dialog in accessibility service with triple tap. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_title_triple">Triple tap screen to open</string>
    <!-- Title for the accessibility tutorial dialog in accessibility service with two finger double tap. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_title_two_finger_double">Two finger double tap screen to open</string>
    <!-- Title for the accessibility tutorial dialog in accessibility service with gesture. [CHAR LIMIT=50] -->
    <string name="accessibility_tutorial_dialog_title_gesture">Use gesture to open</string>
    <!-- Title for the accessibility tutorial dialog in gesture navigation settings. [CHAR LIMIT=50] -->
    <string name="accessibility_tutorial_dialog_title_gesture_settings">Use accessibility gesture</string>
    <!-- Message for the accessibility tutorial dialog when user enables an accessibility service while using the 3-button nav bar. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_button">To use this feature, tap the accessibility button <xliff:g id="accessibility_icon" example="[Icon]">%s</xliff:g> on the bottom of your screen.\n\nTo switch between features, touch &amp; hold the accessibility button.</string>
    <!-- Message for the accessibility tutorial dialog when user enables an accessibility service while using the accessibility floating button. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_message_floating_button">To use this feature, tap the accessibility button on your screen.</string>
    <!-- Instruction for the accessibility tutorial dialog in accessibility service with volume keys. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_message_volume">To use this feature, press &amp; hold both volume keys.</string>
    <!-- Instruction for the accessibility tutorial dialog in accessibility service with triple tap. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_message_triple">To start and stop magnification, triple-tap anywhere on your screen.</string>
    <!-- Instruction for the accessibility tutorial dialog in accessibility service with two finger double tap. [CHAR LIMIT=100] -->
    <string name="accessibility_tutorial_dialog_message_two_finger_triple">To start and stop magnification, double-tap anywhere on your screen with two fingers.</string>
    <!-- Message for the accessibility tutorial dialog when user enables an accessibility service while using gesture navigation and touch exploration is not enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture">To use this feature, swipe up from the bottom of the screen with 2 fingers.\n\nTo switch between features, swipe up with 2 fingers and hold.</string>
    <!-- Message for the accessibility tutorial dialog when user enables an accessibility service while using gesture navigation and touch exploration is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture_talkback">To use this feature, swipe up from the bottom of the screen with 3 fingers.\n\nTo switch between features, swipe up with 3 fingers and hold.</string>
    <!-- Message for the accessibility tutorial dialog when user chooses gesture navigation in navigation settings, an accessibility service is using the accessibility button, and touch exploration is disabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture_settings">To use an accessibility feature, swipe up from the bottom of the screen with 2 fingers.\n\nTo switch between features, swipe up with 2 fingers and hold.</string>
    <!-- Message for the accessibility tutorial dialog when user chooses gesture navigation in navigation settings, an accessibility service is using the accessibility button, and touch exploration is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback">To use an accessibility feature, swipe up from the bottom of the screen with 3 fingers.\n\nTo switch between features, swipe up with 3 fingers and hold.</string>
    <!-- Button for the accessibility tutorial dialog to dismiss the dialog when user clicks it. [CHAR LIMIT=10] -->
    <string name="accessibility_tutorial_dialog_button">Got it</string>
    <!-- Button for the accessibility tutorial dialog to open the Accessibility button settings page. [CHAR LIMIT=30] -->
    <string name="accessibility_tutorial_dialog_link_button">Button settings</string>
    <!-- Title for accessibility shortcut preference for accessibility apps. [CHAR LIMIT=40] -->
    <string name="accessibility_shortcut_title"><xliff:g id="service" example="Select to Speak">%1$s</xliff:g> shortcut</string>
    <!-- Title for software shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_summary_software">Accessibility button</string>
    <!-- Title for software shortcut gesture in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_summary_software_gesture">Accessibility gesture</string>
    <!-- Title for software shortcut in gesture mode in accessibility edit shortcut dialog while using gesture navigation is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture">Swipe up with 2 fingers</string>
    <!-- Title for software shortcut in gesture mode in accessibility edit shortcut dialog while using gesture navigation and touch exploration are enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback">Swipe up with 3 fingers</string>
    <!-- Summary for accessibility shortcut preference for software shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software">Tap accessibility button</string>
    <!-- Summary for accessibility shortcut preference for software shortcut gesture type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture">Use accessibility gesture</string>
    <!-- Summary for software shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software">Tap the accessibility button <xliff:g id="accessibility_icon" example="[Icon]">%s</xliff:g> at the bottom of your screen.\n\nTo switch between features, touch &amp; hold the accessibility button.</string>
    <!-- Summary for software shortcut in gesture mode in accessibility edit shortcut dialog while using gesture navigation is enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture">Swipe up from the bottom of the screen with 2 fingers.\n\nTo switch between features, swipe up with 2 fingers and hold.</string>
    <!-- Summary for software shortcut in gesture mode in accessibility edit shortcut dialog while using gesture navigation and touch exploration are enabled [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback">Swipe up from the bottom of the screen with 3 fingers.\n\nTo switch between features, swipe up with 3 fingers and hold.</string>
    <!-- Summary for software shortcut in accessibility edit shortcut dialog when user had enabled the accessibility floating button mode (Floating over other apps). [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating"><annotation id="link">More options</annotation></string>
    <!-- Footer to show help link content description. [CHAR LIMIT=NONE] -->
    <string name="footer_learn_more_content_description">Learn more about <xliff:g id="service" example="Select to Speak">%1$s</xliff:g></string>
    <!-- Title for hardware shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_hardware">Hold volume keys</string>
    <!-- Part of list to compose user's accessibility shortcut list. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_hardware_keyword">hold volume keys</string>
    <!-- Summary for hardware shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_hardware">Press &amp; hold both volume keys</string>
    <!-- Title for two finger double tap shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap">Two-finger double-tap screen</string>
    <!-- Part of list to compose user's accessibility shortcut list. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_two_finger_double_tap_keyword">two-finger double-tap screen</string>
    <!-- Summary for two finger double tap shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap">Quickly tap screen {0,number,integer} times with two fingers</string>
    <!-- Title for triple tap shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap">Triple-tap screen</string>
    <!-- Part of list to compose user's accessibility shortcut list. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_triple_tap_keyword">triple-tap screen</string>
    <!-- Summary for triple tap shortcut in accessibility edit shortcut dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap">Quickly tap screen {0,number,integer} times. This shortcut may slow down your device</string>
    <!-- Title for the accessibility edit shortcut dialog to save the preference when user clicks it. [CHAR LIMIT=20] -->
    <string name="accessibility_shortcut_edit_dialog_title_advance">Advanced</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>
    <!-- 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_gesture_navigation_warning">The accessibility gesture is set to the <xliff:g id="service" example="Select to Speak">%1$s</xliff:g>. To use magnification, swipe up with two fingers from the bottom of the screen and hold. 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>
    <!-- Label for shortcut settings button. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_settings">Shortcut settings</string>
    <!-- Title for the switch preference that controls whether or not the accessibility shortcut works on the lock screen. [CHAR LIMIT=50] -->
    <string name="accessibility_shortcut_service_on_lock_screen_title">Shortcut from lock screen</string>
    <!-- Description of accessibility shortcut. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_description">Allow feature shortcut to turn on from the lock screen. Hold both volume keys for a few seconds.</string>
    <!-- Title for the accessibility button page. [CHAR LIMIT=35] -->
    <string name="accessibility_button_title">Accessibility button</string>
    <!-- Title for the accessibility button & gesture page. [CHAR LIMIT=35] -->
    <string name="accessibility_button_gesture_title">Accessibility button &amp; gesture</string>
    <!-- Introduction for the accessibility button page. [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_intro_text">Quickly access accessibility features from any screen</string>
    <!-- Title for the accessibility button footer. [CHAR LIMIT=35] -->
    <string name="accessibility_button_about_title">About accessibility button</string>
    <!-- Title for the accessibility button & gesture footer. [CHAR LIMIT=55] -->
    <string name="accessibility_button_gesture_about_title">About accessibility button &amp; gesture</string>
    <!-- Accessibility button & gestures footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_gesture_footer_learn_more_content_description">Learn more about accessibility button &amp; gesture</string>
    <!-- Intro for the accessibility button page. [CHAR LIMIT=100] -->
    <string name="accessibility_button_intro">Using the accessibility button. The gesture isn\u2019t available with 3-button navigation.</string>
    <!-- Summary text for the accessibility button preference. [CHAR LIMIT=50] -->
    <string name="accessibility_button_summary">Quickly access accessibility features</string>
    <!-- Description for the accessibility button in gesture navigation. Explain how this page works in numbered ordered list. [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_gesture_description">
        <![CDATA[
        <b>To get started</b><br/>
        {0,number,integer}. Go to accessibility settings<br/>
        {1,number,integer}. Select a feature and tap the shortcut<br/>
        {2,number,integer}. Choose whether you want to use a button or gesture to access the feature<br/>
        ]]>
    </string>
    <!-- Description for the accessibility button page. Explain how this page works in numbered ordered list. [CHAR LIMIT=NONE] -->
    <string name="accessibility_button_description">
        <![CDATA[
        <b>To get started</b><br/>
        {0,number,integer}. Go to accessibility settings<br/>
        {1,number,integer}. Select a feature and tap the shortcut<br/>
        {2,number,integer}. Choose the button to access the feature<br/>
        ]]>
    </string>
    <!-- Title for the button or gesture of the accessibility button. [CHAR LIMIT=35] -->
    <string name="accessibility_button_or_gesture_title">Use button or gesture</string>
    <!-- Title for the location of the accessibility button. [CHAR LIMIT=35] -->
    <string name="accessibility_button_location_title">Location</string>
    <!-- Title for the size of the accessibility button. [CHAR LIMIT=35] -->
    <string name="accessibility_button_size_title">Size</string>
    <!-- Title for the fade of the accessibility button. [CHAR LIMIT=35] -->
    <string name="accessibility_button_fade_title">Fade when not in use</string>
    <!-- Summary for the fade of the accessibility button. [CHAR LIMIT=80] -->
    <string name="accessibility_button_fade_summary">Fades after a few seconds so it\u2019s easier to see your screen</string>
    <!-- Title for the transparency of the accessibility button. Will become fade when not interact with the accessibility button. [CHAR LIMIT=40] -->
    <string name="accessibility_button_opacity_title">Transparency when not in use</string>
    <!-- Label on the left side of transparency adjustment slider [CHAR LIMIT=30] -->
    <string name="accessibility_button_low_label">Transparent</string>
    <!-- Label on the right side of transparency adjustment slider [CHAR LIMIT=30] -->
    <string name="accessibility_button_high_label">Non-transparent</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>
    <!-- Summary for the accessibility preference to high contrast text. [CHAR LIMIT=NONE] -->
    <string name="accessibility_toggle_high_text_contrast_preference_summary">Change text color to black or white. Maximizes contrast with the background.</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>
    <!-- Summary for the accessibility preference for enabling/disabling large icons for mouse/trackpad pointers. [CHAR LIMIT=60] -->
    <string name="accessibility_toggle_large_pointer_icon_summary">Make the mouse pointer more noticeable</string>
    <!-- Title for the accessibility preference for forcing all apps to use dark theme. [CHAR LIMIT=35] -->
    <string name="accessibility_force_invert_title">Make all apps dark</string>
    <!-- Summary for the accessibility preference for forcing all apps to use dark theme. [CHAR LIMIT=100] -->
    <string name="accessibility_force_invert_summary">Applies to apps without their own dark theme. Some apps may have display issues, like inverted colors.</string>
    <!-- Title for the accessibility preference for disabling animations. [CHAR LIMIT=35] -->
    <string name="accessibility_disable_animations">Remove animations</string>
    <!-- Summary for the accessibility preference for disabling animations. [CHAR LIMIT=60] -->
    <string name="accessibility_disable_animations_summary">Reduce movement on the screen</string>
    <!-- Title for the accessibility preference for primary mono. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_primary_mono_title">Mono audio</string>
    <!-- Summary for the accessibility preference for primary mono. [CHAR LIMIT=60] -->
    <string name="accessibility_toggle_primary_mono_summary">Combine channels when playing audio</string>
    <!-- Title for the accessibility preference for primary balance. [CHAR LIMIT=35] -->
    <string name="accessibility_toggle_primary_balance_title">Audio balance</string>
    <!-- 'Left' balance text for the accessibility preference for primary balance. [CHAR LIMIT=20] -->
    <string name="accessibility_toggle_primary_balance_left_label">Left</string>
    <!-- 'Right' balance text for the accessibility preference for primary balance. [CHAR LIMIT=20] -->
    <string name="accessibility_toggle_primary_balance_right_label">Right</string>

    <!-- Option heading to leave the timeout requirement for accessibility users at its default level. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_default">Default</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 10 secs. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_10secs">10 seconds</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 30 secs. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_30secs">30 seconds</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 1 min. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_1min">1 minute</string>
    <!-- Option heading to leave the timeout requirement for accessibility users at 2 mins. [CHAR LIMIT=35] -->
    <string name="accessibility_timeout_2mins">2 minutes</string>
    <!-- Title for accessibility settings timeout item. [CHAR LIMIT=43] -->
    <string name="accessibility_setting_item_control_timeout_title">Time to take action (Accessibility timeout)</string>
    <!-- Title for accessibility timeout footer. [CHAR LIMIT=65] -->
    <string name="accessibility_control_timeout_about_title">About time to take action (Accessibility timeout)</string>
    <!-- Accessibility timeout footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_control_timeout_footer_learn_more_content_description">Learn more about time to take action (Accessibility timeout)</string>
    <!-- Title for accessibility preference to accessibility timeout. [CHAR LIMIT=35] -->
    <string name="accessibility_control_timeout_preference_title">Time to take action</string>
    <!-- Descriptive text for accessibility preference to accessibility control timeout. [CHAR LIMIT=NONE] -->
    <string name="accessibility_control_timeout_preference_summary">This timing preference isn\u2019t supported by all apps</string>
    <!-- Intro text for accessibility preference to accessibility control timeout. [CHAR LIMIT=NONE] -->
    <string name="accessibility_control_timeout_preference_intro_text">Choose how long to show temporary messages that ask you to take action</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>
    <!-- Used in the accessibility service settings to control turning display color inversion on/off entirely. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_switch_title">Use color inversion</string>
    <!-- Title for accessibility shortcut preference for color inversion. [CHAR LIMIT=60] -->
    <string name="accessibility_display_inversion_shortcut_title">Color inversion shortcut</string>
    <!-- Intro for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_intro_text">Color inversion turns light screens dark. It also turns dark screens light.</string>
    <!-- Subtitle for the accessibility preference to configure display color inversion. [CHAR LIMIT=NONE] -->
    <string name="accessibility_display_inversion_preference_subtitle">
        <![CDATA[<b>Keep in mind</b><br/>
        <ol>
            <li>\u00a0Colors will change in media and images</li>
            <li>\u00a0Color inversion works on all apps</li>
            <li>\u00a0To display a dark background, Dark theme can be used instead</li>
        </ol>
        ]]>
    </string>
    <!-- suffixed to click action texts "Double-tap to " -->
    <string name="accessibility_action_label_panel_slice">enter settings</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">Autoclick (dwell timing)</string>
    <!-- Title for accessibility dwell timing footer. [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_about_title">About autoclick (dwell timing)</string>
    <!-- Accessibility dwell timing footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_footer_learn_more_content_description">Learn more about autoclick (dwell timing)</string>
    <!-- Intro text to explain what autoclick does. [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_intro_text">You can set a connected mouse to click automatically when the cursor stops moving for a certain amount of time</string>
    <!-- Footer text to explain what autoclick does. [CHAR LIMIT=NONE] -->
    <string name="accessibility_autoclick_description">Autoclick can be helpful if clicking the mouse is difficult</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its default level. [CHAR LIMIT=50] -->
    <string name="accessibility_autoclick_default_title">Autoclick off</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its short level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_short_title">Short</string>
    <!-- Option summary text for the auto click delay 0.2 seconds radio button. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_short_summary">0.2 seconds</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its medium level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_medium_title">Medium</string>
    <!-- Option summary text for the auto click delay 0.6 seconds radio button. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_medium_summary">0.6 seconds</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its long level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_long_title">Long</string>
    <!-- Option summary text for the auto click delay 1 second radio button. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_long_summary">1 second</string>
    <!-- Option heading to leave the auto click requirement for accessibility users at its custom level. [CHAR LIMIT=35] -->
    <string name="accessibility_autoclick_custom_title">Custom</string>
    <!-- Description for the button that shorter auto click time. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_autoclick_shorter_desc">Shorter</string>
    <!-- Description for the button that longer auto click time. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_autoclick_longer_desc">Longer</string>
    <!-- Description for the seekbar that adjust auto click time. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_autoclick_seekbar_desc">Auto click time</string>
    <!-- Title for preference screen for configuring vibrations. [CHAR LIMIT=NONE] -->
    <string name="accessibility_vibration_settings_title">Vibration &amp; haptics</string>
    <!-- Summary for preference screen for configuring vibrations. [CHAR LIMIT=NONE] -->
    <string name="accessibility_vibration_settings_summary">Control the vibration strength for different usages</string>
    <!-- "Vibration & haptics" preference's state when enabled. This text is shown next to the "Vibration & haptics" preference title. [CHAR LIMIT=NONE] -->
    <string name="accessibility_vibration_settings_state_on">On</string>
    <!-- "Vibration & haptics" preference's state when disabled. This text is shown next to the "Vibration & haptics" preference title. [CHAR LIMIT=NONE] -->
    <string name="accessibility_vibration_settings_state_off">Off</string>
    <!-- Summary for vibration preference shown when it is disabled because the device is in silent mode. [CHAR LIMIT=NONE] -->
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary">Setting disabled because device is set to silent</string>
    <!-- Title for the category of preferences to configure device vibrations related to calls. [CHAR LIMIT=NONE] -->
    <string name="accessibility_call_vibration_category_title">Calls</string>
    <!-- Title for the category of preferences to configure device vibrations related to notifications and alarms. [CHAR LIMIT=NONE] -->
    <string name="accessibility_notification_alarm_vibration_category_title">Notifications and alarms</string>
    <!-- Title for the category of preferences to configure device vibrations triggered by user interaction with the device. [CHAR LIMIT=NONE] -->
    <string name="accessibility_interactive_haptics_category_title">Interactive haptics</string>
    <!-- Title for primary switch preference for enabling device vibrations. [CHAR LIMIT=NONE] -->
    <string name="accessibility_vibration_primary_switch_title">Use vibration &amp; haptics</string>
    <!-- Title for preference for configuring alarm vibrations. [CHAR LIMIT=NONE] -->
    <string name="accessibility_alarm_vibration_title">Alarm vibration</string>
    <!-- Title for preference for configuring media vibrations (e.g. vibrations played together with animations, music, videos, etc). [CHAR LIMIT=NONE] -->
    <string name="accessibility_media_vibration_title">Media vibration</string>
    <!-- Toggle for keyboard vibration. [CHAR LIMIT=NONE]-->
    <string name="accessibility_keyboard_vibration_title">Keyboard vibration</string>
    <!-- Title for accessibility preference for configuring ring vibrations. [CHAR LIMIT=NONE] -->
    <string name="accessibility_ring_vibration_title">Ring vibration</string>
    <!-- Title for accessibility preference for configuring notification vibrations. -->
    <string name="accessibility_notification_vibration_title">Notification vibration</string>
    <!-- Title for accessibility preference for configuring touch feedback vibrations. -->
    <string name="accessibility_touch_vibration_title">Touch feedback</string>
    <!-- Used in the accessibility service settings to control turning on/off the service entirely [CHAR LIMIT=60] -->
    <string name="accessibility_service_primary_switch_title">Use <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g></string>
    <!-- Used in the accessibility service settings to open the activity. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_primary_open_title">Open <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g></string>
    <!-- Used in the accessibility service settings to show quick settings tooltip for auto-added feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_auto_added_qs_tooltip_content"><xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g> added to Quick Settings. Swipe down to turn it on or off anytime.</string>
    <!-- Used in the accessibility service settings to show quick settings tooltip. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_qs_tooltip_content">You can also add <xliff:g id="accessibility_app_name" example="TalkBack">%1$s</xliff:g> to Quick Settings from the top of your screen</string>
    <!-- Used in the color correction settings to show quick settings tooltip for auto-added feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content">Color correction added to Quick Settings. Swipe down to turn it on or off anytime.</string>
    <!-- Used in the color correction settings to show quick settings tooltip. [CHAR LIMIT=NONE] -->
    <string name="accessibility_color_correction_qs_tooltip_content">You can also add color correction to Quick Settings from the top of your screen</string>
    <!-- Used in the color inversion settings to show quick settings tooltip for auto-added feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content">Color inversion added to Quick Settings. Swipe down to turn it on or off anytime.</string>
    <!-- Used in the color inversion settings to show quick settings tooltip. [CHAR LIMIT=NONE] -->
    <string name="accessibility_color_inversion_qs_tooltip_content">You can also add color inversion to Quick Settings from the top of your screen</string>
    <!-- Used in the reduce bright colors settings to show quick settings tooltip for auto-added feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content">Extra dim added to Quick Settings. Swipe down to turn it on or off anytime.</string>
    <!-- Used in the reduce bright colors settings to show quick settings tooltip. [CHAR LIMIT=NONE] -->
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content">You can also add extra dim to Quick Settings from the top of your screen</string>
    <!-- Used in the One-hand mode color to show quick settings tooltip for auto-added feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content">One-handed mode added to Quick Settings. Swipe down to turn it on or off anytime.</string>
    <!-- Used in the One-hand mode settings to show quick settings tooltip. [CHAR LIMIT=NONE] -->
    <string name="accessibility_one_handed_mode_qs_tooltip_content">You can also add one-handed mode to Quick Settings from the top of your screen</string>
    <!-- Used in the font size settings to show quick settings tooltip for auto-added feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content">Font size added to Quick Settings. Swipe down to change the font size anytime.</string>
    <!-- Used in the accessibility action for accessibility quick settings tooltip to dismiss. [CHAR LIMIT=NONE] -->
    <string name="accessibility_quick_settings_tooltip_dismiss">Dismiss</string>
    <!-- Used in the Color correction settings screen to control turning on/off the feature entirely [CHAR LIMIT=60] -->
    <string name="accessibility_daltonizer_primary_switch_title">Use color correction</string>
    <!-- Title for accessibility shortcut preference for color correction. [CHAR LIMIT=60] -->
    <string name="accessibility_daltonizer_shortcut_title">Color correction shortcut</string>
    <!-- Title for Color correction footer. [CHAR LIMIT=35] -->
    <string name="accessibility_daltonizer_about_title">About color correction</string>
    <!-- Color inversion footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_daltonizer_footer_learn_more_content_description">Learn more about color correction</string>
    <!-- Title for Color inversion footer. [CHAR LIMIT=35] -->
    <string name="accessibility_color_inversion_about_title">About color inversion</string>
    <!-- Color correction footer link content description [CHAR LIMIT=NONE] -->
    <string name="accessibility_color_inversion_footer_learn_more_content_description">Learn more about color inversion</string>
    <!-- Title for captioning settings screen to control turning on/off the feature entirely [CHAR LIMIT=60] -->
    <string name="accessibility_captioning_primary_switch_title">Show captions</string>
    <!-- Summary for captioning settings screen to control turning on/off the feature entirely [CHAR LIMIT=NONE] -->
    <string name="accessibility_captioning_primary_switch_summary">For supported app only</string>
    <!-- Title for captioning preference settings screen for configuring font style. [CHAR LIMIT=NONE] -->
    <string name="captioning_appearance_title">Caption size and style</string>
    <!-- Summary for captioning settings, explaining important settings under it. [CHAR LIMIT=NONE] -->
    <string name="captioning_appearance_summary"><xliff:g id="accessibility_font_size" example="Large">%1$s</xliff:g> text size</string>
    <!-- Title for captioning preference settings screen for configuring language. [CHAR LIMIT=NONE] -->
    <string name="captioning_more_options_title">More options</string>
    <!-- Introduction for the captioning preference page. [CHAR LIMIT=NONE] -->
    <string name="accessibility_captioning_preference_intro">Customize caption size and style to make them easier to read</string>
    <!-- Summary for the captioning preference page. [CHAR LIMIT=NONE] -->
    <string name="accessibility_captioning_preference_summary">These caption preferences aren\u2019t supported by all media apps</string>
    <!-- Summary for accessibility shortcut preference for software shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_software">Accessibility button</string>
    <!-- Summary for accessibility shortcut preference for software shortcut type when gesture mode is on. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_software_gesture">2-finger swipe up from bottom</string>
    <!-- Summary for accessibility shortcut preference for hardware shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_hardware">Hold volume keys</string>
    <!-- Summary for accessibility shortcut preference for magnification triple tap shortcut type. [CHAR LIMIT=NONE] -->
    <string name="accessibility_shortcut_type_triple_tap">Triple tap screen</string>

    <!-- Button text for the accessibility dialog continue to the next screen for hearing aid. [CHAR LIMIT=32] -->
    <string name="accessibility_hearingaid_instruction_continue_button">Continue</string>
    <!-- Title for the accessibility preference for hearing devices. [CHAR LIMIT=35] -->
    <string name="accessibility_hearingaid_title">Hearing devices</string>
    <!-- Introduction for the Hearing devices page to introduce feature. [CHAR LIMIT=NONE] -->
    <string name="accessibility_hearingaid_intro">You can use hearing aids, cochlear implants, and other amplification devices with your phone</string>
    <!-- Summary for the accessibility preference for hearing aid when not connected. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_not_connected_summary">No hearing devices 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 aids</string>
    <!-- Title of the pair instruction dialog. Dialog shows to ask the user to make sure that their hearing aid devices are in pairing mode. [CHAR LIMIT=25] -->
    <string name="accessibility_hearingaid_pair_instructions_title">Pair hearing aids</string>
    <!-- Message of the pair instruction dialog. Dialog shows 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_message">On the next screen, tap on your hearing aids. You may need to pair the left and right ears separately.\n\nMake sure your hearing aids are turned on and ready to pair.</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"  example="GN Hearing Aids">%1$s</xliff:g> active</string>
    <!-- Summary for the accessibility preference for hearing aid when there is only left side active. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_left_side_device_summary"><xliff:g id="device_name"  example="GN Hearing Aids">%1$s</xliff:g>, left only</string>
    <!-- Summary for the accessibility preference for hearing aid when there is only right side active. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_right_side_device_summary"><xliff:g id="device_name"  example="GN Hearing Aids">%1$s</xliff:g>, right only</string>
    <!-- Summary for the accessibility preference for hearing aid when both left side and right side are active. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_left_and_right_side_device_summary"><xliff:g id="device_name"  example="GN Hearing Aids">%1$s</xliff:g>, left and right</string>
    <!-- Summary for the accessibility preference for hearing aid when there are more than one set of devices are active. [CHAR LIMIT=50] -->
    <string name="accessibility_hearingaid_more_device_summary"><xliff:g id="device_name" example="GN Hearing Aids">%1$s</xliff:g> +1 more</string>
    <!-- Title for the hearing device pairing preference. [CHAR LIMIT=20] -->
    <string name="accessibility_hearing_device_pairing_title">Pair new device</string>
    <!-- Title for accessibility pair new hearing device page footer. [CHAR LIMIT=60] -->
    <string name="accessibility_pair_hearing_device_about_title">About Pair new device</string>
    <!-- Title for the preference category containing the connected hearing device group. [CHAR LIMIT=20]-->
    <string name="accessibility_hearing_device_connected_title">Hearing devices</string>
    <!-- Title for the preference category containing the previously connected hearing device group. [CHAR LIMIT=20]-->
    <string name="accessibility_hearing_device_saved_title">Saved devices</string>
    <!-- Title for the preference category containing the controls of the hearing device. [CHAR LIMIT=35] -->
    <string name="accessibility_hearing_device_control">Hearing device controls</string>
    <!-- Title for the accessibility preference for hearing devices. [CHAR LIMIT=35] -->
    <string name="accessibility_hearing_device_shortcut_title">Hearing device shortcut</string>
    <!-- Title for the Hearing Aid Compatibility preference in the accessibility page. [CHAR LIMIT=35] -->
    <string name="accessibility_hac_mode_title">Hearing aid compatibility</string>
    <!--Summary for the Hearing Aid Compatibility preference in the accessibility page. [CHAR LIMIT=NONE] -->
    <string name="accessibility_hac_mode_summary">Improves compatibility with telecoils and reduces unwanted noise</string>
    <!-- Title for accessibility hearing device page footer. [CHAR LIMIT=40] -->
    <string name="accessibility_hearing_device_about_title">About hearing devices</string>
    <!-- Description for text in accessibility hearing aids footer. [CHAR LIMIT=NONE] -->
    <string name="accessibility_hearing_device_footer_summary">Make sure your hearing device is turned on and ready to pair</string>
    <!-- Title for the pair hearing device page. [CHAR LIMIT=25] -->
    <string name="accessibility_hearing_device_pairing_page_title">Pair hearing device</string>
    <!-- Title for the preference category containing the list of the available hearing during and after bluetooth scanning devices. [CHAR LIMIT=30] -->
    <string name="accessibility_found_hearing_devices">Available hearing devices</string>
    <!-- Title for the preference category containing the all bluetooth devices during and after bluetooth scanning devices. Used when people can not find their hearing device in hearing device pairing list. [CHAR LIMIT=45] -->
    <string name="accessibility_found_all_devices">Don\u2019t see your hearing device?</string>
    <!-- Title for listing all bluetooth devices preference in the accessibility page. [CHAR LIMIT=40] -->
    <string name="accessibility_list_all_devices_title">See more devices</string>

    <!-- Title for the accessibility audio adjustment page. [CHAR LIMIT=50] -->
    <string name="accessibility_audio_adjustment_title">Audio adjustment</string>
    <!-- Title for control audio description preference. [CHAR LIMIT=50] -->
    <string name="accessibility_toggle_audio_description_preference_title">Audio description</string>
    <!-- Summary for accessibility preference for audio description when need
    audio description in adopted apps. [CHAR_LIMIT=NONE] -->
    <string name="accessibility_audio_description_summary">Hear a description of what\u2019s happening on screen in supported movies and shows</string>
    <!-- List of synonyms used in the settings search bar to find the "Audio Description. [CHAR LIMIT=NONE] -->
    <string name="keywords_audio_description">audio description, audio, description, low vision,</string>

    <!-- Shows when the shortcut of an accessibility feature is turned on. The accessibility feature could refer to any accessibility feature installed on the device. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_shortcut_enabled">Shortcut on</string>
    <!-- Preference's shortcut when disabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_shortcut_disabled">Off</string>
    <!-- Preference's state when enabled. [CHAR LIMIT=NONE] -->
    <string name="accessibility_summary_state_enabled">On</string>
    <!-- Preference's state when disabled. [CHAR LIMIT=NONE] -->
    <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 accessibility shortcuts settings page. [CHAR LIMIT=50] -->
    <string name="accessibility_shortcuts_settings_title">Accessibility shortcuts</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 shown for deuteranomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_deuteranomaly_title">Red-green</string>
    <!-- Title shown for protanomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_protanomaly_title">Red-green</string>
    <!-- Title shown for tritanomaly (blue-yellow color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_tritanomaly_title">Blue-yellow</string>
    <!-- Title shown for grayscale [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_grayscale_title">Grayscale</string>
    <!-- Summary shown for deuteranomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_deuteranomaly_summary">Green weak, deuteranomaly</string>
    <!-- Summary shown for protanomaly (red-green color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_protanomaly_summary">Red weak, protanomaly</string>
    <!-- Summary shown for tritanomaly (blue-yellow color blindness) [CHAR LIMIT=45] -->
    <string name="daltonizer_mode_tritanomaly_summary">Tritanomaly</string>

    <!-- Title for the accessibility preference of the Extra Dim/Reduce Brightness feature that dims your screen. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_preference_title">Extra dim</string>
    <!-- Title for the activation switch of the Reduce Brightness feature. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_switch_title">Make screen extra dim</string>
    <!-- Title for accessibility shortcut preference for Reduce Brightness. [CHAR LIMIT=60] -->
    <string name="reduce_bright_colors_shortcut_title">Extra dim shortcut</string>
    <!-- Title for Reduce Brightness feature footer. [CHAR LIMIT=35] -->
    <string name="reduce_bright_colors_about_title">About extra dim</string>
    <!-- Intro that describes Reduce Brightness. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_preference_intro_text">Make your screen dimmer so it\u2019s more comfortable to read</string>
    <!-- Title for setting the brightness intensity of the display using Reduce Brightness. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_intensity_preference_title">Intensity</string>
    <!-- Start label for slider that reduces the brightness intensity of the display using Extra Dim. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_intensity_start_label">Dimmer</string>
    <!-- End label for slider that reduces the brightness intensity of the display using Extra Dim. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_intensity_end_label">Brighter</string>
    <!-- Title for setting whether the Reduce Brightness activation state persists across reboots. [CHAR LIMIT=NONE] -->
    <string name="reduce_bright_colors_persist_preference_title">Keep on after device restarts</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] -->
    <string name="accessibilty_autoclick_preference_subtitle_short_delay">{count, plural,
      =1      {Short ({time} second)}
      other   {Short ({time} seconds)}
    }</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] -->
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay">{count, plural,
      =1      {Medium ({time} second)}
      other   {Medium ({time} seconds)}
    }</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] -->
    <string name="accessibilty_autoclick_preference_subtitle_long_delay">{count, plural,
      =1      {Long ({time} second)}
      other   {Long ({time} seconds)}
    }</string>

    <!-- Summary for autoclick seekbar settings preference when user selected custom item. [CHAR LIMIT=35] -->
    <string name="accessibilty_autoclick_delay_unit_second">{count, plural,
      =1      {{time} second}
      other   {{time} seconds}
    }</string>

    <!-- Title for accessibility menu item to launch 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 captioning 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">Allow
         <xliff:g id="service" example="TalkBack">%1$s</xliff:g> to have full control of your
        device?</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 explains that accessibility services have a lot of access to user data [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_warning"><xliff:g id="service"
        example="TalkBack">%1$s</xliff:g> is requesting full control of this device. The service
        can read the screen and act on behalf of users with accessibility needs.
        This level of control is not appropriate for most apps.
    </string>

    <!-- Warning description that explains that it's appropriate for accessibility
         services to have full control to help users with accessibility needs. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_warning_description">Full control is appropriate for apps
        that help you with accessibility needs, but not for most apps.
    </string>

    <!-- Title for the screen control in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_screen_control_title">View and control screen</string>

    <!-- Description for the screen control in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_screen_control_description">It can read all content on the
        screen and display content over other apps.
    </string>

    <!-- Title for the action perform in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_action_perform_title">View and perform actions</string>

    <!-- Description for the action perform in accessibility dialog. [CHAR LIMIT=NONE] -->
    <string name="accessibility_service_action_perform_description">It can track your interactions
        with an app or a hardware sensor, and interact with apps on your behalf.
    </string>

    <!-- String for the allow button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_allow">Allow</string>
    <!-- String for the deny button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_deny">Deny</string>

    <!-- String for the allow button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_stop">Turn off</string>
    <!-- String for the deny button in accessibility permission dialog. [CHAR LIMIT=10] -->
    <string name="accessibility_dialog_button_cancel">Keep on</string>

    <!-- Title for a warning about disabling an accessibility service. [CHAR LIMIT=NONE] -->
    <string name="disable_service_title">Turn off <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 accessibility 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 launching settings for an accessibility service -->
    <string name="settings_button">Settings</string>

    <!-- List of synonyms used in the settings search bar to find the “Extra Dim” setting, which dims your screen. Title name is located at strings/reduce_bright_colors_preference_title. [CHAR LIMIT=NONE] -->
    <string name="keywords_reduce_bright_colors">light sensitivity, photophobia, dark theme, migraine, headache, reading mode, night mode, reduce brightness, white point</string>
    <!-- List of synonyms used in the settings search bar to find the “Accessibility”. [CHAR LIMIT=NONE] -->
    <string name="keywords_accessibility">vision, hearing, blind, deaf, motor, dexterity, assistive, assistance, ease of use, ease of access, hand, help</string>
    <!-- List of synonyms used in the settings search bar to find the “Magnification”. [CHAR LIMIT=NONE] -->
    <string name="keywords_magnification">Window Magnifier, Zoom, Magnification, Low vision, Enlarge, make bigger</string>
    <!-- List of synonyms used in the settings search bar to find the “TalkBack”. [CHAR LIMIT=NONE] -->
    <string name="keywords_talkback"></string>
    <!-- List of synonyms used in the settings search bar to find the “Live Caption”. [CHAR LIMIT=NONE] -->
    <string name="keywords_live_caption">Captions, closed captions, CC, Live Transcribe, hard of hearing, hearing loss, CART, speech to text, subtitle</string>
    <!-- List of synonyms used in the settings search bar to find the “Live Transcribe”. [CHAR LIMIT=NONE] -->
    <string name="keywords_live_transcribe"></string>
    <!-- List of synonyms used in the settings search bar to find the “Sound Notifications”. [CHAR LIMIT=NONE] -->
    <string name="keywords_sound_notifications"></string>
    <!-- List of synonyms used in the settings search bar to find the “Sound Amplifier”. [CHAR LIMIT=NONE] -->
    <string name="keywords_sound_amplifier"></string>
    <!-- List of synonyms used in the settings search bar to find the “Display size”. [CHAR LIMIT=NONE] -->
    <string name="keywords_display_size">screen size, large screen</string>
    <!-- List of synonyms used in the settings search bar to find the “Bold text”. [CHAR LIMIT=NONE] -->
    <string name="keywords_bold_text">High contrast, low vision, bold font, bold face</string>
    <!-- List of synonyms used in the settings search bar to find the “Select to Speak”. [CHAR LIMIT=NONE] -->
    <string name="keywords_select_to_speak"></string>
    <!-- List of synonyms used in the settings search bar to find the “Color correction”. [CHAR LIMIT=NONE] -->
    <string name="keywords_color_correction">adjust color </string>
    <!-- List of synonyms used in the settings search bar to find the “Color inversion”. [CHAR LIMIT=NONE] -->
    <string name="keywords_color_inversion">turn screen dark, turn screen light</string>
    <!-- List of synonyms used in the settings search bar to find the “Contrast”. [CHAR LIMIT=NONE] -->
    <string name="keywords_contrast">color contrast</string>
    <!-- List of synonyms used in the settings search bar to find the “Accessibility Menu”. [CHAR LIMIT=NONE] -->
    <string name="keywords_accessibility_menu"></string>
    <!-- List of synonyms used in the settings search bar to find the “Switch Access”. [CHAR LIMIT=NONE] -->
    <string name="keywords_switch_access"></string>
    <!-- List of synonyms used in the settings search bar to find the “Autoclick(dwell timing)”. [CHAR LIMIT=NONE] -->
    <string name="keywords_auto_click">motor, mouse, external mouse, head mouse, adaptive mouse, wheelchair, joystick</string>
    <!-- List of synonyms used in the settings search bar to find the “Hearing aids”. [CHAR LIMIT=NONE] -->
    <string name="keywords_hearing_aids">hearing aids, hard of hearing, hearing loss, cochlear implants, amplification devices, sound processors, PSAP</string>
    <!-- List of synonyms used in the settings search bar to find the “Real-time text (RTT)”. [CHAR LIMIT=NONE] -->
    <string name="keywords_rtt">hard of hearing, hearing loss, captions, Teletype, tty</string>
    <!-- List of synonyms used in the settings search bar to find the “Voice Access”. [CHAR LIMIT=NONE] -->
    <string name="keywords_voice_access"></string>
    <!-- List of synonyms used in the settings search bar to find the “3-button navigation”. [CHAR LIMIT=NONE] -->
    <string name="keywords_3_button_navigation">three buttons</string>
    <!-- List of synonyms used in the settings search bar to find the “Touch & hold delay”. [CHAR LIMIT=NONE] -->
    <string name="keywords_touch_and_hold_delay">dexterity, motor, senior, arthritis, rsi, stroke, tremor, multiple sclerosis, cerebral palsy, shaking, repetitive strain injury, hand</string>
    <!-- List of synonyms used in the settings search bar to find the “Time to take action (Accessibility timeout)”. [CHAR LIMIT=NONE] -->
    <string name="keywords_accessibility_timeout">delay, dexterity, senior</string>

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

    <string name="print_settings_summary">{count, plural,
      =1      {1 print service on}
      other   {# print services on}
    }</string>

    <!-- Print setting summary in settings screenm indicating how many print jobs are active [CHAR LIMIT=None] -->
    <string name="print_jobs_summary">{count, plural,
      =1      {1 print job}
      other   {# print jobs}
    }</string>

    <!-- 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>
    <!-- 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 app screen time in power usage detail page [CHAR LIMIT=NONE] -->
    <string name="power_usage_detail_screen_time">Screen time</string>
    <!-- Title for app background time in power usage detail page [CHAR LIMIT=NONE] -->
    <string name="power_usage_detail_background_time">Background time</string>

    <!-- Description of battery state and remaining time (e.g. Charging rapidly • 1hr 23 min left until full)-->
    <string name="battery_state_and_duration" translatable="false"><xliff:g id="state">%1$s</xliff:g> • <xliff:g id="time">%2$s</xliff:g></string>
    <!-- Summary for the low battery state [CHAR LIMIT=NONE] -->
    <string name="low_battery_summary">Low battery</string>

    <!-- Summary for the background activity [CHAR_LIMIT=120] -->
    <string name="background_activity_summary">Allow the app to run in the background</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>

    <!-- Category title for battery background settings in power usage detail page [CHAR LIMIT=NONE] -->
    <string name="manager_battery_usage_category_title">Manage battery usage</string>
    <!-- Title for allow background usage [CHAR LIMIT=NONE] -->
    <string name="manager_battery_usage_allow_background_usage_title">Allow background usage</string>
    <!-- Summary for allow background usage [CHAR LIMIT=NONE] -->
    <string name="manager_battery_usage_allow_background_usage_summary">Enable for real-time updates, disable to save battery</string>
    <!-- Title for the battery unrestricted settings [CHAR_LIMIT=40] -->
    <string name="manager_battery_usage_unrestricted_title">Unrestricted</string>
    <!-- Title for the battery optimized settings [CHAR_LIMIT=40] -->
    <string name="manager_battery_usage_optimized_title">Optimized</string>
    <!-- Title for the battery restricted settings [CHAR_LIMIT=40] -->
    <string name="manager_battery_usage_restricted_title">Restricted</string>
    <!-- Summary for the battery unrestricted settings [CHAR_LIMIT=NONE] -->
    <string name="manager_battery_usage_unrestricted_summary">Allow battery usage in background without restrictions. May use more battery.</string>
    <!-- Summary for the battery optimized settings [CHAR_LIMIT=NONE] -->
    <string name="manager_battery_usage_optimized_summary">Optimize based on your usage. Recommended for most apps.</string>
    <!-- Summary for the battery restricted settings [CHAR_LIMIT=NONE] -->
    <string name="manager_battery_usage_restricted_summary">Restrict battery usage while in background. App may not work as expected. Notifications may be delayed.</string>
    <!-- Footer for the manage battery usage page [CHAR_LIMIT=NONE] -->
    <string name="manager_battery_usage_footer">Changing how an app uses your battery can affect its performance.</string>
    <!-- Footer for the manage battery usage page when app is limited to specific option (e.g This app requires restricted battery usage) [CHAR_LIMIT=NONE] -->
    <string name="manager_battery_usage_footer_limited">This app requires <xliff:g id="state" example="restricted">%1$s</xliff:g> battery usage.</string>
    <!-- The state when app is limited to unrestricted option only (e.g This app requires unrestricted battery usage) [CHAR_LIMIT=40] -->
    <string name="manager_battery_usage_unrestricted_only">unrestricted</string>
    <!-- The state when app is limited to optimized option only (e.g This app requires optimized battery usage) [CHAR_LIMIT=40] -->
    <string name="manager_battery_usage_optimized_only">optimized</string>
    <!-- Accessibility description for battery usage learn more link [CHAR LIMIT=NONE] -->
    <string name="manager_battery_usage_link_a11y">Learn more about battery usage options</string>

    <!-- Title for the screen usage in power use UI [CHAR_LIMIT=60] -->
    <string name="device_screen_usage">Screen 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>

    <!-- 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>
    <!-- Preference title for advanced battery usage [CHAR LIMIT=40] -->
    <string name="advanced_battery_preference_title">Battery usage</string>
    <!-- Preference summary for advanced battery usage, for past 24 hours [CHAR LIMIT=40] -->
    <string name="advanced_battery_preference_summary_with_hours">View usage for past 24 hours</string>
    <!-- Preference summary for advanced battery usage, since last full charge [CHAR LIMIT=40] -->
    <string name="advanced_battery_preference_summary">View usage since last full charge</string>

    <!-- Activity title for battery usage details for an app. or power consumer -->
    <string name="battery_details_title">App 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>

    <!-- Title for the battery summary tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_summary_title">Apps are running normally</string>
    <!-- Title for the low battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_low_battery_title">Battery level low</string>
    <!-- Summary for the low battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_low_battery_summary">Turn on Battery Saver to extend battery life</string>
    <!-- Title for the smart battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_smart_battery_title">Improve 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 on</string>
    <!-- Accessibility description for battery saver learn more link [CHAR LIMIT=NONE] -->
    <string name="battery_saver_link_a11y">Learn more about Battery Saver</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">Higher battery usage</string>
    <!-- Summary for the battery high usage tip, which presents apps with highest usage [CHAR LIMIT=NONE] -->
    <string name="battery_tip_high_usage_summary">See apps with highest usage</string>
    <!-- Title for the battery limited temporarily tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_limited_temporarily_title">Charging optimized to protect your battery</string>
    <!-- Summary for the battery limited temporarily tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_limited_temporarily_summary">To help extend your battery\'s lifespan, charging is optimized</string>
    <!-- Content description for the battery limited temporarily tip secondary button [CHAR LIMIT=NONE] -->
    <string name="battery_tip_limited_temporarily_sec_button_content_description">Learn more about charging is paused</string>
    <!-- Text of battery limited temporarily tip resume charge button. [CHAR LIMIT=NONE] -->
    <string name="battery_tip_limited_temporarily_dialog_resume_charge">Resume charging</string>
    <!-- Footer message for battery tip dialog to show the status about the battery [CHAR LIMIT=NONE] -->
    <string name="battery_tip_dialog_message_footer">Includes high-power background activity</string>
    <!-- Title for restricted app preference, showing how many app need to be restricted [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_title">{count, plural,
      =1      {Restrict # app}
      other   {Restrict # apps}
    }</string>
    <!-- Title for restricted app preference, showing how many app been restricted [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_handled_title">{count, plural,
      =1      {{label} recently restricted}
      other   {# apps recently restricted}
    }</string>
    <!-- Summary for restricted app preference, showing the impact of the apps [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_summary">{count, plural,
      =1      {{label} has high background battery usage}
      other   {# apps have high background battery usage}
    }</string>
    <!-- Summary for restricted app preference, showing the impact of the apps [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_handled_summary">{count, plural,
      =1      {This app can\'t run in the background}
      other   {These apps can\'t run in the background}
    }</string>

    <!-- Title for dialog to restrict the app [CHAR LIMIT=NONE] -->
    <string name="battery_tip_restrict_app_dialog_title">{count, plural,
      =1      {Restrict app?}
      other   {Restrict # apps?}
    }</string>
    <!-- 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>
    <!-- Charge to full button for battery defender tips [CHAR LIMIT=NONE] -->
    <string name="battery_tip_charge_to_full_button">Charge to full</string>
    <!-- Title of incompatible charging battery tip [CHAR LIMIT=NONE] -->
    <string name="battery_tip_incompatible_charging_title">Check charging accessory</string>
    <!-- Content description for the incompatible charging battery tip button [CHAR LIMIT=NONE] -->
    <string name="battery_tip_incompatible_charging_content_description">Learn more about incompatible charging</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>
    <!-- Footer for the aosp smart battery page -->
    <string name="smart_battery_footer">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] -->
    <string name="restricted_app_summary">{count, plural,
      =1      {Limiting battery usage for # app}
      other   {Limiting battery usage for # apps}
    }</string>

    <!-- Summary for restricted app to show the restriction time [CHAR LIMIT=NONE] -->
    <string name="restricted_app_time_summary">Restricted <xliff:g id="time" example="5 days ago">%1$s</xliff:g></string>

    <!-- Footer message for restrict app details page -->
    <string name="restricted_app_detail_footer">These apps are restricted from background battery usage. They may not work as expected, 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_summary">Detecting when apps drain battery</string>
    <!-- Summary for battery manager when it is on. [CHAR LIMIT=NONE] -->
    <string name="battery_manager_summary_unsupported">Detecting when apps drain battery</string>

    <!-- Summary for battery manager, showing app restricted -->
    <string name="battery_manager_app_restricted">{count, plural,
      =1      {# app restricted}
      other   {# apps restricted}
    }</string>

    <!-- Title to display the battery percentage. [CHAR LIMIT=24] -->
    <string name="battery_header_title_alternate"><xliff:g id="number" example="88">^1</xliff:g><small> <font size="20"><xliff:g id="unit" example="%">%</xliff:g></font></small></string>

    <!-- Summary for top level battery tile if battery is not present. [CHAR LIMIT=NONE] -->
    <string name="battery_missing_message">Problem reading the battery meter.</string>
    <!-- Help text if battery is not present. [CHAR LIMIT=NONE] -->
    <string name="battery_missing_link_message"></string>
    <!-- Accessibility description for battery missing link. [CHAR LIMIT=NONE] -->
    <string name="battery_missing_link_a11y_message">Tap to learn more about this error</string>

    <!-- Label for power consumed by the screen -->
    <string name="power_screen">Screen</string>
    <!-- Label for power consumed by the CPU -->
    <string name="power_cpu">CPU</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 the GPS -->
    <string name="power_gps">GPS</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 -->
    <string name="power_cell">Mobile network</string>
    <!-- Label for power consumed by Calling -->
    <string name="power_phone">Voice calls</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">Remaining battery life is approximate and can change based on usage</string>
    <!-- Title for battery usage amount by this app. [CHAR LIMIT=80] -->
    <string name="battery_detail_power_usage">Battery usage</string>

    <!-- Description for no any battery usage since last full charge [CHAR LIMIT=120] -->
    <string name="battery_not_usage">No usage since last full charge</string>
    <!-- Description for no any battery usage for past 24 hr [CHAR LIMIT=120] -->
    <string name="battery_not_usage_24hr">No usage for past 24 hr</string>
    <!-- Description for no usage time but have battery usage [CHAR LIMIT=120] -->
    <string name="battery_usage_without_time"></string>
    <!-- Description for the specific time slot in the battery usage page [CHAR LIMIT=120] -->
    <string name="battery_usage_since_last_full_charge">since last full charge</string>
    <!-- Description for system apps aggregated battery usage data [CHAR LIMIT=120] -->
    <string name="battery_usage_system_apps">System apps</string>
    <!-- Description for uninstalled apps aggregated battery usage data [CHAR LIMIT=120] -->
    <string name="battery_usage_uninstalled_apps">Uninstalled apps</string>
    <!-- Description for others battery usage data [CHAR LIMIT=120] -->
    <string name="battery_usage_others">Others</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>

    <!-- Label for mediaserver process in battery usage [CHAR_LIMIT=NONE] -->
    <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>
    <!-- Label for network tethering UID label in battery usage [CHAR_LIMIT=NONE] -->
    <string name="process_network_tethering">Tethering</string>
    <!-- Label for removed apps UID lablel in battery usage [CHAR_LIMIT=NONE] -->
    <string name="process_removed_apps">Removed apps</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 preference to indicate there is no battery saver schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_no_schedule">No schedule</string>

    <!-- Battery saver: Label for preference to indicate there is a routine based schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_routine">Based on your routine</string>

    <!-- Battery saver: Summary for preference to indicate there is a routine based schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_pref_auto_routine_summary">Will turn on based on your routine</string>

    <!-- Battery saver: Label for preference to indicate there is a percentage based schedule [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_percentage">Based on percentage</string>

    <!-- Battery saver: Summary for preference to describe what is meant by a routine based schedule [CHAR_LIMIT=NONE] -->
    <string name="battery_saver_auto_routine_summary">Battery Saver turns on if your battery is likely to run out before your next typical charge</string>

    <!-- Battery saver: Label for seekbar to change battery saver threshold [CHAR_LIMIT=40] -->
    <string name="battery_saver_auto_percentage_summary">Will turn on at <xliff:g id="percent" example="52%">%1$s</xliff:g></string>

    <!-- Battery saver: Title for battery saver schedule screen [CHAR_LIMIT=40] -->
    <string name="battery_saver_schedule_settings_title">Set a schedule</string>

    <!-- Battery saver: Summary text displayed below "Turn on" button for battery saver [CHAR_LIMIT=40] -->
    <string name="battery_saver_turn_on_summary">Extend battery life</string>

    <!-- Battery Saver: Title for sticky battery saver preference [CHAR_LIMIT=60] -->
    <string name="battery_saver_sticky_title_new">Turn off when charged</string>

    <!-- Battery Saver: Title for sticky battery saver preference with percentage [CHAR_LIMIT=60] -->
    <string name="battery_saver_sticky_title_percentage">Turn off at <xliff:g id="battery_percentage" example="80%">%1$s</xliff:g></string>

    <!-- Battery Saver: Description for sticky battery saver preference [CHAR_LIMIT=NONE] -->
    <string name="battery_saver_sticky_description_new">Battery Saver turns off when battery reaches <xliff:g id="battery_percentage" example="80%">%1$s</xliff:g></string>

    <!-- Battery saver: Label for seekbar to change battery saver threshold [CHAR_LIMIT=40] -->
    <string name="battery_saver_seekbar_title"><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>

    <!-- [CHAR_LIMIT=NONE] Battery usage main screen chart graph hint since last full charge -->
    <string name="battery_usage_chart_graph_hint_last_full_charge">Battery level since last full charge</string>
    <!-- [CHAR_LIMIT=NONE] Battery usage main screen chart graph hint -->
    <string name="battery_usage_chart_graph_hint">Battery level for past 24 hr</string>
    <!-- [CHAR_LIMIT=NONE] Battery app usage section header since last full charge -->
    <string name="battery_app_usage">App usage since last full charge</string>
    <!-- [CHAR_LIMIT=NONE] Battery app usage section header for past 24 hour -->
    <string name="battery_app_usage_for_past_24">App usage for past 24 hr</string>
    <!-- [CHAR_LIMIT=NONE] Battery system usage section header since last full charge -->
    <string name="battery_system_usage">System usage since last full charge</string>
    <!-- [CHAR_LIMIT=NONE] Battery system usage section header for past 24 hour -->
    <string name="battery_system_usage_for_past_24">System usage for past 24 hr</string>
    <!-- [CHAR_LIMIT=NONE] Battery system usage section header -->
    <string name="battery_system_usage_for">System usage for <xliff:g id="slot">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery app usage section header -->
    <string name="battery_app_usage_for">App usage for <xliff:g id="slot">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery system usage section header since last full charge to slot_timestamp. Please use similar text with tc/3248552137819897140 -->
    <string name="battery_system_usage_since_last_full_charge_to">System usage since last full charge to <xliff:g id="slot_timestamp" example="Friday 10 am">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery app usage section header since last full charge to slot_timestamp. Please use similar text with tc/7309909074935858949 -->
    <string name="battery_app_usage_since_last_full_charge_to">App usage since last full charge to <xliff:g id="slot_timestamp" example="Friday 10 am">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery usage item for total usage time less than a minute -->
    <string name="battery_usage_total_less_than_one_minute">Total: less than a min</string>
    <!-- [CHAR_LIMIT=NONE] Battery usage item for total background time less than a minute -->
    <string name="battery_usage_background_less_than_one_minute">Background: less than a min</string>
    <!-- [CHAR_LIMIT=NONE] Device screen on time less than a minute -->
    <string name="battery_usage_screen_time_less_than_one_minute">Screen time: less than a min</string>
    <!-- [CHAR_LIMIT=NONE] Power usage time less than a minute -->
    <string name="power_usage_time_less_than_one_minute">Less than a min</string>
    <!-- [CHAR_LIMIT=NONE] Battery usage item for total usage time -->
    <string name="battery_usage_for_total_time">Total: <xliff:g id="time">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery usage item for background usage time -->
    <string name="battery_usage_for_background_time">Background: <xliff:g id="time">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Device screen on time -->
    <string name="battery_usage_screen_time">Screen time: <xliff:g id="time">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery usage main screen footer for empty content -->
    <string name="battery_usage_screen_footer_empty">Battery usage data will be available in a few hours once fully charged</string>
    <!-- [CHAR_LIMIT=NONE] Battery chart label for the current time. -->
    <string name="battery_usage_chart_label_now">now</string>
    <!-- [CHAR_LIMIT=NONE] A hyphen for two timestamps. For example, "6 AM - 8 AM", which means "from 6 AM to 8 AM". Please notice the spaces around the hyphen -->
    <string name="battery_usage_timestamps_hyphen"><xliff:g id="from_timestamp">%1$s</xliff:g> - <xliff:g id="to_timestamp">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] The first slot is a week day (e.g. "Monday"); the second slot is a hourly time span (e.g. "6 AM - 8 AM"). -->
    <string name="battery_usage_day_and_hour"><xliff:g id="day">%1$s</xliff:g> <xliff:g id="hour">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Accessibility content description for each slot in battery chart view. -->
    <string name="battery_usage_time_info_and_battery_level"><xliff:g id="time_info" example="Battery usage for Monday 6 AM - 8 AM">%1$s</xliff:g> <xliff:g id="battery_level" example="Battery level percentage from 83% to 59%">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Accessibility content description for battery chart view. -->
    <string name="battery_usage_chart">Battery usage chart</string>
    <!-- [CHAR_LIMIT=NONE] Accessibility content description for daily battery chart view. -->
    <string name="daily_battery_usage_chart">Daily battery usage chart</string>
    <!-- [CHAR_LIMIT=NONE] Accessibility content description for hourly battery chart view. -->
    <string name="hourly_battery_usage_chart">Hourly battery usage chart</string>
    <!-- [CHAR_LIMIT=NONE] Accessibility content description for battery level percentage. -->
    <string name="battery_level_percentage">Battery level percentage from <xliff:g id="start_percentage">%1$s</xliff:g> to <xliff:g id="end_percentage">%2$s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Battery usage breakdown title since last full charge -->
    <string name="battery_usage_breakdown_title_since_last_full_charge">Battery usage since last full charge</string>
    <!-- [CHAR_LIMIT=NONE] Battery usage breakdown title for a selected slot -->
    <string name="battery_usage_breakdown_title_for_slot">Battery usage for <xliff:g id="slot">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] Device screen on time category since last full charge -->
    <string name="screen_time_category_last_full_charge">Screen time since last full charge</string>
    <!-- [CHAR_LIMIT=NONE] Device screen on time category for a selected slot -->
    <string name="screen_time_category_for_slot">Screen time for <xliff:g id="slot">%s</xliff:g></string>
    <!-- [CHAR_LIMIT=NONE] The spinner item text in the battery usage breakdown. -->
    <string name="battery_usage_spinner_view_by_apps">View by apps</string>
    <!-- [CHAR_LIMIT=NONE] The spinner item text in the battery usage breakdown. -->
    <string name="battery_usage_spinner_view_by_systems">View by systems</string>
    <!-- [CHAR_LIMIT=NONE] Less than some percentage, e.g. < 1% -->
    <string name="battery_usage_less_than_percent">&lt; <xliff:g id="percentage">%1$s</xliff:g></string>
    <!-- Process Stats strings -->
    <skip />
    <!-- Description of battery information footer text. [CHAR LIMIT=NONE] -->
    <string name="battery_cycle_count_footer">Due to quality inspections before shipping, the cycle count may not be zero on first use</string>

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

    <!-- On-device recognition settings --><skip />
    <!-- [CHAR_LIMIT=NONE] Name of the settings item to open the on-device recognition settings. -->
    <string name="on_device_recognition_settings">On-device recognition settings</string>
    <!-- [CHAR_LIMIT=NONE] Title of the on-device recognition settings -->
    <string name="on_device_recognition_settings_title">On-device recognition</string>
    <!-- [CHAR_LIMIT=NONE] Summary of the on-device recognition settings -->
    <string name="on_device_recognition_settings_summary">On-device speech recognition</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>

    <!-- Title of preference to enter the VPN settings activity -->
    <string name="vpn_settings_title">VPN</string>
    <!-- Title of preference to enter the VPN settings activity [CHAR LIMIT=30] -->
    <string name="vpn_settings_insecure_single">Not secure</string>
    <!-- Title of preference to enter the VPN settings activity, if there are multiple vpns but only 1 insecure vpn [CHAR LIMIT=60] -->
    <string name="vpn_settings_single_insecure_multiple_total"><xliff:g id="vpn_count" example="1">%d</xliff:g> not secure</string>
    <!-- Title of preference to enter the VPN settings activity, if there are multiple vpns and multiple insecure vpns [CHAR LIMIT=60] -->
    <string name="vpn_settings_multiple_insecure_multiple_total"><xliff:g id="vpn_count" example="1">%d</xliff:g> not secure</string>

    <!-- Title of Adaptive connectivity. Adaptive connectivity is a feature which automatically manages network connections for better battery life and performance. [CHAR LIMIT=60] -->
    <string name="adaptive_connectivity_title">Adaptive connectivity</string>
    <!-- Summary of Adaptive connectivity preference. [CHAR LIMIT=NONE] -->
    <string name="adaptive_connectivity_summary">Extends battery life and improves device performance by automatically managing your network connections</string>
    <!-- Switch on text of Adaptive connectivity preference. [CHAR LIMIT=NONE]-->
    <string name="adaptive_connectivity_switch_on">On</string>
    <!-- Switch off text of Adaptive connectivity preference. [CHAR LIMIT=NONE]-->
    <string name="adaptive_connectivity_switch_off">Off</string>
    <!-- Title for adaptive connectivity main switch preferences. [CHAR LIMIT=50] -->
    <string name="adaptive_connectivity_main_switch_title">Use adaptive connectivity</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 [CHAR LIMIT=30] -->
    <string name="credentials_install">Install a certificate</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>
    <!-- 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 for Wi-Fi configuration. [CHAR LIMIT=NONE]. -->
    <string name="credential_for_wifi">Installed for Wi\u2011Fi</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_in_use">Installed for Wi\u2011Fi (In use)</string>
    <!-- Description of dialog to reset credential storage [CHAR LIMIT=NONE] -->
    <string name="credentials_reset_hint">Remove all the contents?</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>
    <!-- Title of Usage Access preference item [CHAR LIMIT=30] -->
    <string name="usage_access_title">Apps with usage access</string>
    <!-- Title of CA certificate [CHAR LIMIT=30] -->
    <string name="ca_certificate">CA certificate</string>
    <!-- Title of User certificate [CHAR LIMIT=30] -->
    <string name="user_certificate">VPN &amp; app user certificate</string>
    <!-- Title of Wi-Fi certificate [CHAR LIMIT=30] -->
    <string name="wifi_certificate">Wi\u2011Fi certificate</string>
    <!-- Title of warning shown to the user before they can install a CA certificate [CHAR LIMIT=NONE] -->
    <string name="ca_certificate_warning_title">Your data won\u2019t be private</string>
    <!-- Description of warning shown to the user before they can install a CA certificate [CHAR LIMIT=NONE] -->
    <string name="ca_certificate_warning_description">CA certificates are used by websites, apps, and VPNs for encryption. Only install CA certificates from organizations you trust. \n\nIf you install a CA certificate, the certificate owner could access your data, such as passwords or credit card details, from websites you visit or apps you use – even if your data is encrypted.</string>
    <!-- Label for button to not install a certificate [CHAR_LIMIT=50] -->
    <string name="certificate_warning_dont_install">Don\u2019t install</string>
    <!-- Label for button to continue installing a certificate [CHAR_LIMIT=50] -->
    <string name="certificate_warning_install_anyway">Install anyway</string>
    <!-- Toast message that a certificate was not installed -->
    <string name="cert_not_installed">Certificate not installed</string>

    <!-- Title of screen shown to the user when an app requests to manage the user's KeyChain credentials [CHAR LIMIT=NONE] -->
    <string name="request_manage_credentials_title">Allow <b><xliff:g id="app_name" example="Ping">^1</xliff:g></b> to install certificates on this device?</string>
    <!-- Description of screen shown to the user when an app requests to manage the user's KeyChain credentials [CHAR LIMIT=NONE] -->
    <string name="request_manage_credentials_description">These certificates will verify you by sharing your device\u2019s unique ID with the apps and URLs below</string>
    <!-- Label for button to not allow an app to manage the user's KeyChain credentials [CHAR_LIMIT=50] -->
    <string name="request_manage_credentials_dont_allow">Don\u2019t allow</string>
    <!-- Label for button to allow an app to manage the user's KeyChain credentials [CHAR_LIMIT=50] -->
    <string name="request_manage_credentials_allow">Allow</string>
    <!-- Label for floating action button to scroll to the end of the authentication policy list [CHAR LIMIT=30] -->
    <string name="request_manage_credentials_more">Show more</string>
    <!-- Title of preference for the certificate management app [CHAR LIMIT=30] -->
    <string name="certificate_management_app">Certificate management app</string>
    <!-- Summary if there is no certificate management app [CHAR_LIMIT=NONE] -->
    <string name="no_certificate_management_app">None</string>
    <!-- Summary of preference if there is a certificate management app [CHAR LIMIT=NONE] -->
    <string name="certificate_management_app_description">Certificates will verify you when you use the apps and URLs below</string>
    <!-- Label for button to uninstall all certificates installed by the credential management app [CHAR LIMIT=30] -->
    <string name="uninstall_certs_credential_management_app">Uninstall certificates</string>
    <!-- Label for button to remove the credential management app [CHAR LIMIT=30] -->
    <string name="remove_credential_management_app">Remove app</string>
    <!-- Dialog title for button to remove the credential management app [CHAR LIMIT=30] -->
    <string name="remove_credential_management_app_dialog_title">Remove this app?</string>
    <!-- Dialog message for button to remove the credential management app [CHAR LIMIT=NONE] -->
    <string name="remove_credential_management_app_dialog_message">This app won\u2019t manage certificates, but it will stay on your device. Any certificates installed by the app will be uninstalled.</string>
    <!-- List item found in the credential management app's authentication policy [CHAR LIMIT=NONE] -->
    <string name="number_of_urls">{count, plural,
      =1      {# URL}
      other   {# URLs}
    }</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>
    <!-- Configure backup account menu title [CHAR LIMIT=50]-->
    <string name="backup_data_management_title">Manage 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>

    <!-- 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>
    <!-- Simplified device admin warning message [CHAR LIMIT=NONE]-->
    <string name="device_admin_warning_simplified">This device will be managed and monitored by
        <xliff:g id="app_name" example="Example Supervisor">%1$s</xliff:g>.</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>
    <!-- Simplified title for dialog to set a profile owner [CHAR LIMIT=40] -->
    <string name="profile_owner_add_title_simplified">Allow supervision?</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">Learn more</string>
    <string name="notification_log_title">Notification log</string>

    <string name="notification_history_title">Notification history</string>
    <string name="notification_history_today">Last %d hours</string>
    <string name="notification_history_snooze">Snoozed</string>
    <string name="notification_history_dismiss">Recently dismissed</string>

    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <string name="notification_history_count">{count, plural,
      =1      {# notification}
      other   {# notifications}
    }</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>
    <!-- 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>

    <!-- 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 apps on or off. The work apps are a group of apps that are managed by the the user's employer. While this setting is off, the user cannot interact with those apps or get notifications from them. "Work" is an adjective. -->
    <string name="work_mode_label">Work apps</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>

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

    <!-- 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>
    <!-- Title of remove message for remove account dialog -->
    <string name="really_remove_account_title">Remove account?</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>

    <!-- the following are for Settings Storage screen -->
    <!-- Menu item/button 'delete' -->
    <string name="delete">Delete</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 Mobile data & WI-FI summary. [CHAR LIMIT=40] -->
    <string name="data_usage_app_summary_title">Mobile data &amp; Wi\u2011Fi</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 menu option to enable global auto-sync of private account data [CHAR LIMIT=30] -->
    <string name="account_settings_menu_auto_sync_private">Auto-sync private 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>
    <!--  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>

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

    <!-- Title for Network usage to control whether Wifi is metered or not [CHAR LIMIT=20] -->
    <string name="wifi_metered_title">Network usage</string>
    <!-- Option for indicating that a network is metered (expensive). [CHAR LIMIT=32] -->
    <string name="data_usage_metered_yes">Metered</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>
    <!-- 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 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:
        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</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</string>
    <!-- Preference summary for a VPN app that has an insecure type. [CHAR LIMIT=40]  -->
    <string name="vpn_insecure_summary">Not secure</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>

    <!-- Dialog subtitle warning for a VPN app that has an insecure type. [CHAR LIMIT=100]  -->
    <string name="vpn_insecure_dialog_subtitle">Not secure. Update to an IKEv2 VPN</string>
    <!-- Dialog message when user attempted to start a VPN type that is no longer supported. It is
         very unlikely, but not impossible, that a user has a very old VPN configuration that the
         newer device no longer supports. This message is displayed when the user tries to start
         this unsupported VPN. [CHAR LIMIT=NONE]  -->
    <string name="vpn_start_unsupported">Failed to start unsupported VPN.</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">Uninstall</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 is required. For example, a network uses this credential. [CHAR LIMIT=NONE] -->
    <string name="credential_being_used_by">Being used by</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">1 user key</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_usercrt">1 user certificate</string>
    <!-- Item found in the PKCS12 keystore being investigated [CHAR LIMIT=NONE] -->
    <string name="one_cacrt">1 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>
    <!--  Title for spell checker settings for work [CHAR LIMIT=45]-->
    <string name="spellcheckers_settings_for_work_title">Spell checker for work</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] -->
    <string name="ssl_ca_cert_dialog_title">{count, plural,
      =1      {Trust or remove certificate}
      other   {Trust or remove certificates}
    }</string>
    <!-- Text of message to show to device owner user whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_info_message_device_owner"> {numberOfCertificates, plural,
        =1 {{orgName} 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.}
        other {{orgName} 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.}
        }</string>
    <!-- Text of message to show to work profile users whose administrator has installed a SSL CA Cert.  [CHAR LIMIT=NONE] -->
    <string name="ssl_ca_cert_info_message">{numberOfCertificates, plural,
        =1 {{orgName} 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.}
        other {{orgName} 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.}
        }</string>
    <!-- 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]-->
    <string name="ssl_ca_cert_settings_button">{count, plural,
      =1      {Check certificate}
      other   {Check certificates}
    }</string>

    <!-- 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 summary for a restricted profile [CHAR LIMIT=50] -->
    <string name="user_summary_restricted_profile">Restricted profile</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>

    <!-- Summary for add user action, when it's disabled [CHAR LIMIT=100] -->
    <string name="user_add_max_count">You can\u2019t add any more users. Remove a user to add a new one.</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>
    <!-- TODO(b/257333623): HSUM has no 1:1 admin:dream relationship. There can even be >1 admin -->
    <!-- User settings item to allow the system to automatically switch back to the Dock User when
         the device is docked. [CHAR LIMIT=50] -->
    <string name="switch_to_dock_user_when_docked">Switch to admin user when docked</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">Delete 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 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. -->
    <!-- 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 for guest category in guest mode [CHAR LIMIT=35] -->
    <string name="guest_category_title">Guest (You)</string>
    <!-- Title for users preference [CHAR LIMIT=35] -->
    <string name="user_category_title">Users</string>
    <!-- Title for users preference when in guest mode [CHAR LIMIT=35] -->
    <string name="other_user_category_title">Other users</string>
    <!-- Title of preference to remove guest on exit option[CHAR LIMIT=35] -->
    <string name="remove_guest_on_exit">Delete guest activity</string>
    <!-- Summary of preference to remove guest on exit option[CHAR LIMIT=NONE] -->
    <string name="remove_guest_on_exit_summary">Delete all guest apps and data
        when exiting guest mode</string>
    <!-- Title of dialog shown when remove_guest_on_exit toggle is ON [CHAR LIMIT=35] -->
    <string name="remove_guest_on_exit_dialog_title">Delete guest activity?</string>
    <!-- Message of dialog shown when remove_guest_on_exit toggle is ON [CHAR LIMIT=NONE] -->
    <string name="remove_guest_on_exit_dialog_message">Apps and data from this guest session will be
        deleted now, and all future guest activity will be deleted each time you exit guest mode</string>
    <!-- Search keywords for the "Delete Guest Activity" section in Multiple Users Screen. [CHAR LIMIT=NONE] -->
    <string name="remove_guest_on_exit_keywords">delete, guest, activity, remove, data, visitor, erase</string>
    <!-- Title of preference to enable guest calling[CHAR LIMIT=40] -->
    <string name="enable_guest_calling">Allow guest to make phone calls</string>
    <!-- Summary of preference to enable guest calling [CHAR LIMIT=NONE] -->
    <string name="enable_guest_calling_summary">Call history will be shared with guest user</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 grant user admin privileges [CHAR LIMIT=45] -->
    <string name="user_grant_admin">Make this user an admin</string>
    <!-- Title of preference to remove the user [CHAR LIMIT=35] -->
    <string name="user_remove_user">Delete 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 confirmation of revoking admin privileges [CHAR LIMIT=45] -->
    <string name="user_revoke_admin_confirm_title">Remove admin privileges?</string>
    <!-- Message for confirmation of revoking admin privileges [CHAR LIMIT=none] -->
    <string name="user_revoke_admin_confirm_message">If you remove admin privileges for this user, you or another admin can give them back later.</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>

    <!-- Button label for opening an arbitrary app [CHAR LIMIT=60] -->
    <string name="open_app_button">Open <xliff:g id="app_name" example="Safety">%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>

    <!-- Title for copying apps to another user [CHAR LIMIT=45] -->
    <string name="user_choose_copy_apps_to_another_user">Choose apps to install</string>
    <!-- Menu title for copying apps to another user [CHAR LIMIT=35] -->
    <string name="user_copy_apps_menu_title">Install available apps</string>

    <!-- NFC payment settings --><skip/>
    <!-- Title for NFC payment settings page [CHAR LIMIT=40] -->
    <string name="nfc_payment_settings_title">Contactless payments</string>
    <!-- Title for NFC default payment settings page [CHAR LIMIT=40] -->
    <string name="nfc_default_payment_settings_title">Default payment app</string>
    <!-- Text string explaining how Tap and Pay works [CHAR LIMIT=100] -->
    <string name="nfc_default_payment_footer">To make a payment using a payment app, hold the back of your device to a payment terminal</string>
    <!-- Text string linking to a page explaining how Tap and Pay works [CHAR LIMIT=40] -->
    <string name="nfc_more_details">Learn more</string>

    <!-- Strings shown in a dialog when a user tries to set a work app as a nfc default payment app --><skip/>
    <!-- Title for the dialog [CHAR LIMIT=40] -->
    <string name="nfc_default_payment_workapp_confirmation_title">Set work app as default payment app?</string>
    <!-- Header text for the dialog [CHAR LIMIT=40] -->
    <string name="nfc_default_payment_workapp_confirmation_message_title">To make a payment using a work app:</string>
    <!-- Text string in the dialog [CHAR LIMIT=60] -->
    <string name="nfc_default_payment_workapp_confirmation_message_1">work profile must be turned on.</string>
    <!-- Text string in the dialog [CHAR LIMIT=80] -->
    <string name="nfc_default_payment_workapp_confirmation_message_2">you\u2019ll need to enter your work PIN, pattern, or password if you have one.</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 payment app</string>
    <!-- Header for a dialog asking what to do when the open app supports TapPay [CHAR LIMIT=40] -->
    <string name="nfc_payment_use_default_dialog">Use default payment app</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 contactless 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 users can click to indicate they 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\u2026</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 default payment app</string>
    <!-- Label for the dialog that is shown when the user is asked to update a
         preferred payment application [CHAR LIMIT=50] -->
    <string name="nfc_payment_update_default_label">Update default payment app</string>
    <string name="nfc_payment_set_default">At a contactless terminal, pay with
        <xliff:g id="app">%1$s</xliff:g>
    </string>
    <string name="nfc_payment_set_default_instead_of">At a contactless terminal, pay with <xliff:g
        id="app">%1$s</xliff:g>.\n\nThis replaces <xliff:g id="app">%2$s</xliff:g> as your default
        payment app.
    </string>
    <!-- Label of the Set default button of the Set default payment app dialog [CHAR LIMIT=40] -->
    <string name="nfc_payment_btn_text_set_deault">Set default</string>
    <!-- Label of the Update button of the Update default payment app dialog [CHAR LIMIT=40] -->
    <string name="nfc_payment_btn_text_update">Update</string>
    <!-- Summary text of the work apps in the default payment selection list [CHAR LIMIT=20]-->
    <string name="nfc_work_text">Work</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>

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

    <!-- 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, manage apps storage [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_storage" translatable="false"></string>
    <!-- Help URI, manage apps power [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_high_power" translatable="false"></string>
    <!-- Help URI, manage apps overlay [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_overlay" translatable="false"></string>
    <!-- Help URI, manage apps write settings [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_write_settings" translatable="false"></string>
    <!-- Help URI, manage apps manage sources [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_manage_sources" translatable="false"></string>
    <!-- Help URI, manage apps games [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_games" translatable="false"></string>
    <!-- Help URI, manage apps wifi access [DO NOT TRANSLATE] -->
    <string name="help_uri_apps_wifi_access" translatable="false"></string>
    <!-- Help URI, manage apps that have access to all files [DO NOT TRANSLATE] -->
    <string name="help_uri_manage_external_storage" translatable="false"></string>
    <!-- Help URI, manage apps that can modify media files [DO NOT TRANSLATE] -->
    <string name="help_uri_media_management_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, Vibration [DO NOT TRANSLATE] -->
    <string name="help_uri_accessibility_vibration" 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 URI, manage apps that can set alarms and reminders [DO NOT TRANSLATE] -->
    <string name="help_uri_alarms_and_reminders" translatable="false"></string>
    <!-- Help URI, manage apps that can run long background tasks [DO NOT TRANSLATE] -->
    <string name="help_uri_long_background_tasks" 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, Battery Defender [DO NOT TRANSLATE] -->
    <string name="help_url_battery_defender" translatable="false"></string>
    <!-- Help URL, Dock Defender [DO NOT TRANSLATE] -->
    <string name="help_url_dock_defender" translatable="false"></string>
    <!-- Help URL, Incompatible charging [DO NOT TRANSLATE] -->
    <string name="help_url_incompatible_charging" 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, Install certificate settings [DO NOT TRANSLATE] -->
    <string name="help_url_install_certificate" 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, Face [DO NOT TRANSLATE] -->
    <string name="help_url_face" 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, Auto brightness [DO NOT TRANSLATE] -->
    <string name="help_url_auto_brightness" translatable="false" />
    <!-- Help URL, Adaptive sleep [DO NOT TRANSLATE] -->
    <string name="help_url_adaptive_sleep" translatable="false" />
    <!-- Help URL, Previously connected bluetooth devices [DO NOT TRANSLATE] -->
    <string name="help_url_previously_connected_devices" translatable="false"></string>
    <!-- Help URL, Fast Pair devices on Connected device settings [DO NOT TRANSLATE] -->
    <string name="help_url_connected_devices_fast_pair_devices" translatable="false"></string>
    <!-- Help URL, Top level privacy settings [DO NOT TRANSLATE] -->
    <string name="help_url_privacy_dashboard" translatable="false"></string>

    <string name="help_url_memtag" translatable="false"></string>
    <string name="help_url_development_memtag" translatable="false"></string>
    <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_dark_theme" 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>
    <!-- Help URL, Accessibility caption preferences [DO NOT TRANSLATE] -->
    <string name="help_url_caption" translatable="false"></string>
    <!-- Help URL, Accessibility Timeout [DO NOT TRANSLATE] -->
    <string name="help_url_timeout" translatable="false"></string>
    <!-- Help URL, Accessibility Color Inversion [DO NOT TRANSLATE] -->
    <string name="help_url_color_inversion" translatable="false"></string>
    <!-- Help URL, Accessibility Flash Notification [DO NOT TRANSLATE] -->
    <string name="help_url_flash_notifications" 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>
    <!-- url for the SIM combination warning required dialog help page -->
    <string name="help_uri_sim_combination_warning" translatable="false"></string>
    <!-- url for the NFC and payment settings page -->
    <string name="help_uri_nfc_and_payment_settings" translatable="false"></string>
    <!-- url for battery page if battery is not present -->
    <string name="help_url_battery_missing" translatable="false"></string>
    <!-- url for vpn page if connected vpn is not a secure type -->
    <string name="help_url_insecure_vpn" translatable="false"></string>
    <!-- url for learning more about IT admin policy disabling -->
    <string name="help_url_action_disabled_by_it_admin" translatable="false"></string>
    <!-- url for learning more about bluetooth audio sharing -->
    <string name="help_url_audio_sharing" 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>

    <!-- Cell Broadcast settings title.  [CHAR LIMIT=50] -->
    <string name="cell_broadcast_settings">Wireless 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">VoLTE</string>
    <!-- Enhaced 4G LTE Mode title for carriers who want to show Advanced Calling.  [CHAR LIMIT=50] -->
    <string name="enhanced_4g_lte_mode_title_advanced_calling">Advanced Calling</string>
    <!-- Enhaced 4G LTE Mode title for carriers who want to show 4G Calling.  [CHAR LIMIT=50] -->
    <string name="enhanced_4g_lte_mode_title_4g_calling">4G Calling</string>
    <!-- Enhaced 4G LTE Mode summary.  [CHAR LIMIT=100] -->
    <string name="enhanced_4g_lte_mode_summary">Use LTE services to improve voice calls (recommended)</string>
    <!-- Enhaced 4G LTE Mode summary for 4g calling.  [CHAR LIMIT=100] -->
    <string name="enhanced_4g_lte_mode_summary_4g_calling">Use 4G services to improve voice calls (recommended)</string>
    <!-- NR advanced calling(VoNR or Vo5G) title.  [CHAR LIMIT=50] -->
    <string name="nr_advanced_calling_title">Vo5G</string>
    <!-- NR advanced calling(VoNR or Vo5G) summary.  [CHAR LIMIT=NONE] -->
    <string name="nr_advanced_calling_summary">Use 5G for voice calls</string>
    <!-- Title of a preference determining whether or not the user has allowed the device to share
         their contacts' phone numbers with their carrier in order to implement contact discovery,
         which is a service that exchanges contacts with the carrier to determine if your
         contacts support advanced calling features, such as video calling. [CHAR LIMIT=50]-->
    <string name="contact_discovery_opt_in_title">Send contacts to carrier</string>
    <!-- Summary of a preference determining whether or not the user has enabled contact discovery,
         which is a service that exchanges contacts with the carrier to determine if your contacts
         support enhanced features, such as video calling and RCS messaging. [CHAR LIMIT=110] -->
    <string name="contact_discovery_opt_in_summary">Send your contacts\u2019 phone numbers to provide enhanced features</string>
    <!-- Title of the dialog shown when the user tries to enable Contact Discovery, which is a
         service that exchanges contacts with the carrier to determine if your contacts support
         enhanced features, such as video calling and RCS messaging. [CHAR LIMIT=50] -->
    <string name="contact_discovery_opt_in_dialog_title">Send contacts to <xliff:g id="carrier" example="T-mobile">%1$s</xliff:g>?</string>
    <!-- Title of the dialog shown when the carrier name is not known and the user tries to enable
         Contact Discovery, which is a service that exchanges contacts with the carrier to determine
         if your contacts support enhanced features, such as video calling and RCS messaging.
         [CHAR LIMIT=50] -->
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined">Send contacts to your carrier?</string>
    <!-- The text displayed in the dialog shown when the user tries to enable Contact Discovery,
         which is a service that exchanges contacts with the carrier to determine if your contacts
         support enhanced features, such as video calling and RCS messaging. [CHAR LIMIT=NONE]-->
    <string name="contact_discovery_opt_in_dialog_message">Your contacts\u2019 phone numbers will be periodically sent to <xliff:g id="carrier" example="T-mobile">%1$s</xliff:g>.<xliff:g id="empty_line" example="  ">\n\n</xliff:g>This info identifies whether your contacts can use certain features, like video calls or some messaging features.</string>
    <!-- The text displayed in the dialog shown when the mobile carrier's name is not known and the
         user tries to enable Contact Discovery, which is a service that exchanges contacts with
         the carrier to determine if your contacts support enhanced features, such as video calling
         and RCS messaging. [CHAR LIMIT=NONE]-->
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined">Your contacts\u2019 phone numbers will be periodically sent to your carrier.<xliff:g id="empty_line" example="  ">\n\n</xliff:g>This info identifies whether your contacts can use certain features, like video calls or some messaging features.</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>
    <!-- Title of multimedia messaging service settings.  [CHAR LIMIT=50] -->
    <string name="mms_message_title">MMS messages</string>
    <!-- Summary of multimedia messaging service settings.  [CHAR LIMIT=100] -->
    <string name="mms_message_summary">Send &amp; receive when mobile data is off</string>

    <!-- Title of a preference for whether to allow auto data switch that is shown for backup
         data SIM. This is needed for some multi-SIM scenarios, because the SIM that is
         default for data might be unavailable while the backup is in coverage. [CHAR LIMIT=60] -->
    <string name="auto_data_switch_title">Switch mobile data automatically</string>
    <!-- Summary of a preference for whether to allow auto data switch that is shown for backup
         data SIM. This is needed for some multi-SIM scenarios, because the SIM that is
         default for data might be unavailable while the backup is in coverage. [CHAR LIMIT=NONE]-->
    <string name="auto_data_switch_summary">
        Use this network when it has better availability
    </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 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 for adoptable [CHAR LIMIT=25] -->
    <string name="wizard_back_adoptable">Format another way</string>

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

    <!-- Title for SIM settings title settings during Setup Wizard.  [CHAR LIMIT=40] -->
    <string name="sim_settings_title">SIMs</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">Choose SIM for mobile data</string>
    <!-- Message for selecting sim for SMS in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_sms">Select a SIM for SMS</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\u2026</string>
    <!-- Title for selecting specific sim for data in settings.  [CHAR LIMIT=40] -->
    <string name="select_specific_sim_for_data_title">Use <xliff:g id="new_sim" example="carrierA">%1$s</xliff:g> for mobile data?</string>
    <!-- Message for selecting specific sim for data in settings.  [CHAR LIMIT=NONE] -->
    <string name="select_specific_sim_for_data_msg">If you switch to <xliff:g id="new_sim" example="carrierA">%1$s</xliff:g>, <xliff:g id="old_sim" example="carrierB">%2$s</xliff:g> will no longer be used for mobile data.</string>
    <!-- Button on a selecting specific sim dialog to confirm data in settings.  [CHAR LIMIT=40] -->
    <string name="select_specific_sim_for_data_button">Use <xliff:g id="new_sim" example="carrierA">%1$s</xliff:g></string>
    <!-- Message for selecting sim for call in settings.  [CHAR LIMIT=40] -->
    <string name="select_sim_for_calls">Call with</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>
    <!-- Orange label.  [CHAR LIMIT=40] -->
    <string name="color_orange">Orange</string>
    <!-- Purple label.  [CHAR LIMIT=40] -->
    <string name="color_purple">Purple</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>
    <!-- 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 notification.  [CHAR LIMIT=40] -->
    <string name="sim_notification_title">Your SIMs 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>

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

    <!-- 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, wifi setting and data usage settings [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_mobile">Mobile, Wi\u2011Fi, hotspot</string>
    <!-- Summary for Network and Internet settings, explaining it contains wifi and data usage setting [CHAR LIMIT=NONE]-->
    <string name="network_dashboard_summary_no_mobile">Wi\u2011Fi, 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, explaining default settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_default_summary">Bluetooth, pairing</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>
    <!--Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_android_auto_summary">Bluetooth, Android Auto, driving mode, NFC</string><!--
    Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary">Bluetooth, Android Auto, driving mode</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary">Bluetooth, Android Auto, NFC</string>
    <!-- Summary for Connected devices settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode">Bluetooth, Android Auto</string>
    <!-- Summary for Tap & pay settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary">Unavailable because NFC is off</string>
    <!-- Summary for Tap & pay settings, explaning a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="nfc_and_payment_settings_no_payment_installed_summary">To use, first install a payment app</string>
    <!-- Summary for Apps & Notification settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="app_and_notification_dashboard_summary">Recent apps, default apps</string>
    <!-- Toast shown when an app in the work profile attempts to open notification settings. The apps in the work profile cannot access notification settings. [CHAR LIMIT=NONE] -->
    <string name="notification_settings_work_profile">Notification access is not available for apps in the work profile.</string>
    <!-- Title for setting tile leading to saved autofill passwords, autofill, and account settings [CHAR LIMIT=40]-->
    <string name="account_dashboard_title">Passwords &amp; accounts</string>
    <!-- Summary for setting tile leading to saved autofill passwords, autofill, and account settings [CHAR LIMIT=NONE]-->
    <string name="account_dashboard_default_summary">Suggestions for sign-in &amp; autofill</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>
    <!-- Title for setting tile leading to App Clones menu under the Apps page [CHAR LIMIT=40] -->
    <string name="cloned_apps_dashboard_title">Cloned Apps</string>
    <!-- Description for introduction of the cloned apps page [CHAR LIMIT=NONE]-->
    <string name="desc_cloned_apps_intro_text">Create a second instance of an app so that you can use two accounts at the same time.</string>
    <!-- Description while displaying cloneable app list in Cloned Apps page [CHAR LIMIT=NONE]-->
    <string name="desc_cloneable_app_list_text">Apps that can be cloned.</string>
    <!-- Summary for Cloned Apps menu [CHAR  LIMIT=40] -->
    <string name="cloned_apps_summary"><xliff:g id="cloned_apps_count">%1$s</xliff:g> cloned, <xliff:g id="allowed_apps_count">%2$d</xliff:g> available to clone</string>
    <!-- Description for cloned apps removal title [CHAR LIMIT=40]-->
    <string name="delete_all_app_clones">Delete all App clones</string>
    <!-- Description for cloned apps removal failure title [CHAR LIMIT=40]-->
    <string name="delete_all_app_clones_failure">Delete all App clones failed</string>
    <!-- Summary text when an app is being cloned [CHAR LIMIT=40] -->
    <string name="cloned_app_creation_summary">Creating&#8230;</string>
    <!-- Summary text after an app is cloned [CHAR LIMIT=40] -->
    <string name="cloned_app_created_summary">Cloned</string>
    <!-- Summary text shown in toast when app is being cloned [CHAR LIMIT=40] -->
    <string name="cloned_app_creation_toast_summary">Creating <xliff:g id="package_label">%1$s</xliff:g> clone</string>
    <!-- Summary text shown in toast after app is successfully cloned [CHAR LIMIT=40] -->
    <string name="cloned_app_created_toast_summary">Created <xliff:g id="package_label">%1$s</xliff:g> clone</string>
    <!-- Summary text for system preference title, showing important setting items under system setting [CHAR LIMIT=NONE]-->
    <string name="system_dashboard_summary">Languages, gestures, time, backup</string>
    <!-- Summary text for language preference title, showing important setting items under language setting [CHAR LIMIT=NONE]-->
    <string name="languages_setting_summary">System languages, app languages, regional preferences, speech</string>

    <!--Search Keywords [CHAR LIMIT=NONE]-->
    <string name="keywords_wifi">wifi, wi-fi, network connection, internet, wireless, data, wi fi</string>
    <!-- Search keyword for "Open Network Notification" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_wifi_notify_open_networks">Wi\u2011Fi notification, wifi notification</string>
    <!-- Search keyword for "Wi-fi data usage" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_wifi_data_usage">data usage</string>
    <!-- Search keyword for "Time format" settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_time_format">Use 24-hour format</string>
    <!-- Search keyword for "Default Apps" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_app_default">Open with</string>
    <!-- Search keyword for "App info" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_applications_settings">Applications</string>
    <!-- Search keyword for "Time zone" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_time_zone">timezone</string>
    <!-- Search keyword for "Display over other apps" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_draw_overlay">Chat head, system, alert, window, dialog, display, on top other apps, draw</string>

    <!-- Search keyword for "Flashlight" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_flashlight">Flashlight, Light, Torch</string>
    <string name="keywords_change_wifi_state">wifi, wi-fi, toggle, control</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_display">screen, touchscreen</string>
    <string name="keywords_display_brightness_level">dim screen, touchscreen, battery, bright</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>
    <!-- Search keyword for "Cast" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_display_cast_screen">project, cast, Screen mirroring, Screen sharing, mirroring, share screen, screen casting</string>
    <string name="keywords_storage">space, disk, hard drive, device usage</string>
    <string name="keywords_battery">power usage, charge</string>
    <string name="keywords_battery_usage">view battery usage, battery usage, power usage</string>
    <string name="keywords_battery_saver">battery saver, power saver, saver</string>
    <string name="keywords_battery_adaptive_preferences">adaptive preferences, adaptive battery</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, haptic, vibrator, vibrate</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, GPS</string>
    <string name="keywords_accounts">account, add an account, work profile, add account, remove, delete</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_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>
    <!-- Search keyword for "screen resolution" settings [CHAR_LIMIT=NONE]-->
    <string name="keywords_screen_resolution">FHD, QHD, resolution, 1080p, 1440p</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>
    <!-- Search keyword for App pinning Settings [CHAR LIMIT=NONE] -->
    <string name="keywords_app_pinning">screen pinning</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_fold_lock_behavior">
        awake, sleep, do not lock, stay unlocked on fold, folding, closing, fold, close, screen off
    </string>
    <string name="keywords_gesture">gestures</string>
    <string name="keywords_wallet">wallet</string>
    <string name="keywords_payment_settings">pay, tap, payments</string>
    <string name="keywords_backup">backup, back up</string>
    <string name="keywords_face_unlock">face, unlock, auth, sign in</string>
    <string name="keywords_biometric_unlock">face, unlock, auth, sign in, fingerprint, biometric</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</string>
    <string name="keywords_sim_status_esim">network, mobile network state, service state, signal strength, mobile network type, roaming, eid</string>
    <string name="keywords_sim_status_iccid">network, mobile network state, service state, signal strength, mobile network type, roaming, iccid</string>
    <string name="keywords_sim_status_iccid_esim">network, mobile network state, service state, signal strength, mobile network type, roaming, iccid, eid</string>
    <string name="keywords_esim_eid">eid</string>
    <string name="keywords_model_and_hardware">serial number, hardware version</string>
    <string name="keywords_battery_info">battery info, manufacture date, cycle count, first use</string>
    <string name="keywords_android_version">android security patch level, baseband version, kernel version</string>
    <!-- Search keywords for dark mode settings [CHAR LIMIT=NONE] -->
    <string name="keywords_dark_ui_mode">theme, light, dark, mode, light sensitivity, photophobia, make darker, darken, dark mode, migraine</string>

    <!-- Search keyword for Device Theme Settings [CHAR LIMIT=NONE] -->
    <string name="keywords_systemui_theme">dark theme</string>

    <!-- Search keyword for Send Device Feedback Setting [CHAR LIMIT=NONE] -->
    <string name="keywords_device_feedback">bug</string>

    <!-- Search keyword for Ambient display settings screen. -->
    <string name="keywords_ambient_display_screen">Ambient display, Lock screen display</string>

    <!-- Search keyword for lock screen notification setting [CHAR_LIMIT=NONE] -->
    <string name="keywords_lock_screen_notif">lock screen notification, notifications</string>

    <!-- Search keyword for face settings. -->
    <string name="keywords_face_settings">face</string>

    <!-- Search keyword for fingerprint settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_fingerprint_settings">fingerprint, add fingerprint</string>

    <!-- Search keyword for biometric settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_biometric_settings">face, fingerprint, add fingerprint</string>

    <!-- Search keyword for active unlock settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_active_unlock_settings">watch unlock, add watch unlock</string>

    <!-- Search keywords for adaptive brightness setting [CHAR LIMIT=NONE]-->
    <string name="keywords_display_auto_brightness">dim screen, touchscreen, battery, smart brightness, dynamic brightness, Auto brightness</string>

    <!-- Search keywords for adaptive sleep setting [CHAR LIMIT=NONE]-->
    <string name="keywords_display_adaptive_sleep">smart, dim screen, sleep, battery, timeout, attention, display, screen, inactivity</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">camera, smart, auto rotate, 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, cache, 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, theme, grid, customize, personalize</string>

    <!-- List of synonyms for the Styles picker setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_styles">icon, accent, color, home screen, lock screen, shortcut, clock size</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 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 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 device vibration primary setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_accessibility_vibration_primary_switch">haptics, vibrate, vibration</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 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, ring</string>
    <!-- List of synonyms for ring vibration setting (changes whether your phone vibrates when it rings), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_ramping_ringer_vibration">haptics, vibrate, phone, call, ring, gradually</string>
    <!-- List of synonyms for notification vibration setting (changes whether your phone vibrates when it shows a notification), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_notification_vibration">haptics, vibrate, sensitivity, notification</string>
    <!-- List of synonyms for alarm vibration setting (changes whether your phone vibrates when an alarm goes off), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_alarm_vibration">haptics, vibrate, sensitivity, alarm</string>
    <!-- List of synonyms for media vibration setting (changes whether your phone vibrates as part of a music, animation, video, etc), used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_media_vibration">haptics, vibrate, sensitivity, media</string>
    <!-- List of synonyms for vibration and haptics setting, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_vibration">haptics, vibrate, vibration</string>
    <!-- Battery Saver: Search terms for sticky battery saver preference [CHAR_LIMIT=NONE] -->
    <string name="keywords_battery_saver_sticky">battery saver, sticky, persist, power saver, battery</string>
    <!-- Battery Saver: Search terms for battery saver schedule preference. Feel free to add additional terms when translating if appropriate [CHAR_LIMIT=NONE] -->
    <string name="keywords_battery_saver_schedule">routine, schedule, battery saver, power saver, battery, automatic, percent</string>

    <!-- List of synonyms for the enhance 4G LTE titles, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_enhance_4g_lte">volte, advanced calling, 4g calling</string>

    <!-- List of synonyms for the NR advanced calling(VoNR or Vo5G) titles, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_nr_advanced_calling">vo5g, vonr, advanced calling, 5g calling</string>

    <!-- List of synonyms for add language, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_add_language">add language, add a language</string>

    <!-- List of synonyms for the font size, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_font_size">text size, large print, large font, large text, low vision, make text bigger, font enlarger, font enlargement</string>

    <!-- List of synonyms for the always show time and info, used to match in settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_always_show_time_info">always on ambient display, AOD</string>

    <!-- List of synonyms for the nfc tag apps control [CHAR LIMIT=NONE] -->
    <string name="keywords_change_nfc_tag_apps_state">nfc, tag, reader</string>

    <!-- List of synonyms for keyboard vibration settings search [CHAR LIMIT=NONE] -->
    <string name="keywords_keyboard_vibration">keyboard, haptics, vibrate,</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: 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 remote media volume. [CHAR LIMIT=30] -->
    <string name="remote_media_volume_option_title">Cast 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 & notification volume. [CHAR LIMIT=30] -->
    <string name="ring_volume_option_title">Ring &amp; notification volume</string>

    <!-- Sound: Title for the option managing ring volume. [CHAR LIMIT=30] -->
    <string name="separate_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: Content description of ring volume title in silent mode. [CHAR LIMIT=NONE BACKUP_MESSAGE_ID=8994620163934249882] -->
    <string name="ringer_content_description_silent_mode">Ringer silent</string>

    <!-- Sound: Content description of ring volume title in vibrate mode. [CHAR LIMIT=NONE BACKUP_MESSAGE_ID=6261841170896561364] -->
    <string name="ringer_content_description_vibrate_mode">Ringer vibrate</string>

    <!-- Sound: Content description of notification volume title in vibrate mode. [CHAR LIMIT=NONE] -->
    <string name="notification_volume_content_description_vibrate_mode">Notification volume muted, notifications will vibrate</string>

    <!-- Sound: Content description of volume title in silent mode [CHAR LIMIT=NONE] -->
    <string name="volume_content_description_silent_mode"> <xliff:g id="volume type" example="notification volume">%1$s</xliff:g> muted</string>

    <!-- Sound: Summary for when notification volume is disabled. [CHAR LIMIT=100] -->
    <string name="notification_volume_disabled_summary">Unavailable because ring is muted</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: Option for vibrate when ringing setting: Ramping ringer. [CHAR LIMIT=80] -->
    <string name="vibrate_when_ringing_option_ramping_ringer">Vibrate first then ring gradually</string>

    <!-- Sound: Title for the option enabling spatializer effect. [CHAR LIMIT=30] -->
    <string name="spatial_audio_title">Spatial Audio</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 sound</string>

    <!-- Sound: Other sounds: Title for the option enabling charging sounds and vibration. [CHAR LIMIT=50] -->
    <string name="charging_sounds_title">Charging sounds and vibration</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">Tap &amp; click sounds</string>

    <!-- Sound: Other sounds: Title for the option enabling the vibrate icon. [CHAR LIMIT=50] -->
    <string name="vibrate_icon_title">Always show icon when in vibrate mode</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>

    <!-- Setting title for controlling how caption text display in real time [CHAR LIMIT=40]-->
    <string name="live_caption_title">Live Caption</string>

    <!-- Setting summary for controlling how caption text display in real time [CHAR LIMIT=NONE]-->
    <string name="live_caption_summary">Automatically caption media</string>

    <!-- Output device type for the wired headphones that is available for spatializer effect. [CHAR LIMIT=NONE]-->
    <string name="spatial_audio_wired_headphones">Wired headphones</string>

    <!-- Sound: Summary for the spatializer effect. [CHAR LIMIT=NONE]-->
    <string name="spatial_audio_text">Audio from compatible media becomes more immersive</string>

    <!-- Sound: Summary for the Spatial audio setting when it is off. [CHAR LIMIT=NONE]-->
    <string name="spatial_summary_off">Off</string>

    <!-- Sound: Summary for the Spatial audio setting when it is on with one output device enabled. [CHAR LIMIT=NONE]-->
    <string name="spatial_summary_on_one">On / <xliff:g id="output device" example="Phone speaker">%1$s</xliff:g></string>

    <!-- Sound: Summary for the Spatial audio setting when it is on with two output devices enabled. [CHAR LIMIT=NONE]-->
    <string name="spatial_summary_on_two">On / <xliff:g id="output device" example="Phone speaker">%1$s</xliff:g> and <xliff:g id="output device" example="Wired headphones">%2$s</xliff:g></string>

    <!-- Sound: Footer message for the Spatial audio setting. [CHAR LIMIT=NONE]-->
    <string name="spatial_audio_footer_title">You can also turn on Spatial Audio for Bluetooth devices.</string>

    <!-- Sound: Footer hyperlink text to launch the Connected devices settings page. [CHAR LIMIT=NONE]-->
    <string name="spatial_audio_footer_learn_more_text">Connected devices settings</string>

    <!-- Sound: Summary for the Do not Disturb option that describes how many automatic rules (schedules) are enabled [CHAR LIMIT=NONE]-->
    <string name="zen_mode_settings_schedules_summary">
        {count, plural,
            =0    {None}
            =1    {1 schedule set}
            other {# schedules set}
        }
    </string>

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

    <!-- Sound: Summary for the Do not Disturb option and associated settings page. [CHAR LIMIT=240]-->
    <string name="zen_mode_settings_summary">Only get notified by important people and apps</string>

    <!-- Subtitle for the Do not Disturb slice. [CHAR LIMIT=50]-->
    <string name="zen_mode_slice_subtitle">Limit interruptions</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: Specifies alarms and media can bypass DND.  [CHAR LIMIT=100] -->
    <string name="zen_mode_behavior_alarms_only">Alarms and media sounds can interrupt</string>

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

    <!--  Do not disturb: Title for dialog that allows users to delete DND rules/schedules[CHAR LIMIT=40] -->
    <string name="zen_mode_delete_automatic_rules">Delete schedules</string>

    <!--  Do not disturb: Delete text button presented in a dialog to confirm the user would like to delete the selected DND rules. [CHAR LIMIT=30] -->
    <string name="zen_mode_schedule_delete">Delete</string>

    <!--  Do not disturb: Edit label for button that allows user to edit the dnd schedule name. [CHAR LIMIT=30] -->
    <string name="zen_mode_rule_name_edit">Edit</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">Schedules</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">Schedule</string>

    <!--  Do not disturb: Title do not disturb settings representing automatic (scheduled) do not disturb rules. [CHAR LIMIT=30] -->
    <string name="zen_mode_schedule_category_title">Schedule</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: Header for the Do Not Disturb automatic rules. [CHAR LIMIT=55] -->
    <string name="zen_mode_schedule_title">Schedule</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 schedule</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: zen settings screens category title [CHAR LIMIT=100] -->
    <string name="zen_mode_settings_category">Allow interruptions that make sound</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: restrict notifications settings title [CHAR LIMIT=80] -->
    <string name="zen_mode_restrict_notifications_title">Display options for hidden notifications</string>
    <!-- Do not disturb: Hide notifications screen category title [CHAR LIMIT=100] -->
    <string name="zen_mode_restrict_notifications_category">When Do Not Disturb is on</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=76] -->
    <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, vibrate or make sound for new or existing notifications. Keep in mind, critical notifications for device activity and status will still appear.\n\nWhen you turn off Do Not Disturb, find missed notifications by swiping down from the top of your screen.</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 at top of screen</string>
    <!-- Do not disturb: what to block option [CHAR LIMIT=NONE] -->
    <string name="zen_mode_block_effect_badge">Hide notification dots on app icons</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 pull-down shade</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 device 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 schedule -->
    <string name="zen_mode_settings_dnd_automatic_rule">Do Not Disturb was automatically turned on by a schedule (<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=120] Zen mode settings footer: Footer informing user DND has custom settings. -->
    <string name="zen_mode_settings_dnd_custom_settings_footer">Do Not Disturb is on for <xliff:g id="rule_names" example="Sleeping and Work">%s</xliff:g> with custom settings.</string>

    <!-- [CHAR LIMIT=120] Zen mode settings footer: Link following zen_mode_settings_dnd_custom_settings_footer to see the currently applied custom dnd settings. -->
    <string name="zen_mode_settings_dnd_custom_settings_footer_link"> <annotation id="link">View custom settings</annotation></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 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</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</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_time_hours">
        {count, plural,
            =1    {1 hour}
            other {# hours}
        }
    </string>

    <!--  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">
        {count, plural,
            =1    {1 minute}
            other {# minutes}
        }
    </string>

    <!-- Summary for the Sound Do not Disturb option when DND isn't currently on. [CHAR LIMIT=NONE]-->
    <string name="zen_mode_sound_summary_off">
        {count, plural,
            =0    {Off}
            =1    {Off / 1 schedule can turn on automatically}
            other {Off / # schedules can turn on automatically}
        }
    </string>

    <!-- Do not disturb settings, main screen, category header [CHAR LIMIT=120]-->
    <string name="zen_category_behavior">What can interrupt Do Not Disturb</string>
    <!-- Do not disturb settings, main screen, field, dnd breakthrough [CHAR LIMIT=100]-->
    <string name="zen_category_people">People</string>
    <!-- Do not disturb settings, main screen, field, dnd breakthrough  [CHAR LIMIT=100]-->
    <string name="zen_category_apps">Apps</string>
    <!-- Do not disturb settings, main screen, field, dnd breakthrough  [CHAR LIMIT=100]-->
    <string name="zen_category_exceptions">Alarms &amp; other interruptions</string>
    <!-- Do not disturb settings, main screen, field, schedules [CHAR LIMIT=100]-->
    <string name="zen_category_schedule">Schedules</string>
    <!-- Do not disturb settings, main screen, field, duration setting where user can specify how
    long dnd will last when toggling dnd on from qs) [CHAR LIMIT=100] -->
    <string name="zen_category_duration">Duration for Quick Settings</string>
    <!-- Do not disturb settings, main screen, category header describing settings that do not
    fit in another group [CHAR LIMIT=100] -->
    <string name="zen_settings_general">General</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 custom settings dialog title [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_dialog_title">Custom settings</string>
    <!-- Do not disturb custom settings dialog button label [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_dialog_review_schedule">Review schedule</string>
    <!-- Do not disturb custom settings dialog button label [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_dialog_ok">Got it</string>
    <!-- Do not disturb custom settings notifications header [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_notifications_header">Notifications</string>
    <!-- Do not disturb custom settings duration header [CHAR LIMIT=40]-->
    <string name="zen_custom_settings_duration_header">Duration</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>

    <!-- 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">Use the same sounds as your personal profile</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">Use personal profile 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">Confirm</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 work profile will use the same sounds as your personal profile</string>

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

    <!-- Summary for the top level Notifications Settings [CHAR LIMIT=NONE]-->
    <string name="notification_dashboard_summary">Notification history, conversations</string>

    <!-- notification header - settings for conversation type notifications -->
    <string name="conversation_notifs_category">Conversation</string>

    <!-- notification header for general notification settings [CHAR LIMIT=80]-->
    <string name="general_notification_header">Manage</string>

    <!-- notification preference for app specific notification settings [CHAR LIMIT=80]-->
    <string name="app_notification_field">App notifications</string>

    <!-- notification preference summary for app specific notification settings [CHAR LIMIT=120]-->
    <string name="app_notification_field_summary">Control notifications from individual apps</string>

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

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

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

    <!-- Configure Notifications: setting title [CHAR LIMIT=80 BACKUP_MESSAGE_ID=6691908606916292167] -->
    <string name="asst_capability_prioritizer_title">Adaptive notification priority</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_capability_prioritizer_summary">Automatically set lower priority notifications to Gentle</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80 BACKUP_MESSAGE_ID=6691908606916292167] -->
    <string name="asst_capability_ranking_title">Adaptive notification ranking</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_capability_ranking_summary">Automatically rank notifications by relevance</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80 BACKUP_MESSAGE_ID=6691908606916292167] -->
    <string name="asst_feedback_indicator_title">Adaptive notification feedback</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_feedback_indicator_summary">Indicate adjustments made to notifications and show the option to provide feedback to the system</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80] -->
    <string name="asst_importance_reset_title">Reset notification importance</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_importance_reset_summary">Reset user changed importance settings and allow notification assistant to prioritize</string>

    <!-- Configure Notifications: setting title [CHAR LIMIT=80] -->
    <string name="asst_capabilities_actions_replies_title">Suggested actions and replies</string>

    <!-- Configure Notifications: setting summary [CHAR LIMIT=200] -->
    <string name="asst_capabilities_actions_replies_summary">Automatically show suggested actions &amp; replies</string>

    <!-- Configure notifications: settings summary [CHAR LIMIT=NONE] -->
    <string name="notification_history_summary">Show recent and snoozed notifications</string>

    <!-- Configure notifications: settings title [CHAR LIMIT=100] -->
    <string name="notification_history">Notification history</string>

    <!-- Configure notifications: settings title [CHAR LIMIT=100] -->
    <string name="notification_history_toggle">Use notification history</string>

    <!-- Notification history screen; title when history is off [CHAR LIMIT=200] -->
    <string name="notification_history_off_title_extended">Notification history turned off</string>

    <!--  Notification history screen; summary when history is off [CHAR LIMIT=NONE] -->
    <string name="notification_history_off_summary">Turn on notification history to see recent notifications and snoozed notifications</string>

    <!-- Notification history screen; title when history is newly turned on [CHAR LIMIT=200] -->
    <string name="history_toggled_on_title">No recent notifications</string>

    <!--  Notification history screen; summary when history is newly turned on [CHAR LIMIT=NONE] -->
    <string name="history_toggled_on_summary">Your recent and snoozed notifications will appear here</string>

    <!-- Notification history screen; content description describing what happens when you tap on a notification history entry [CHAR LIMIT=NONE] -->
    <string name="notification_history_view_settings">view notification settings</string>

    <!-- Notification history screen; content description describing what happens when you tap on a snoozed or recently dismissed notification [CHAR LIMIT=NONE] -->
    <string name="notification_history_open_notification">open notification</string>

    <!-- Configure Notifications: setting title, whether the snooze menu is shown on notifications [CHAR LIMIT=80] -->
    <string name="snooze_options_title">Allow notification snoozing</string>

    <!-- Configure Notifications: Title for the notification badging option. [CHAR LIMIT=50 BACKUP_MESSAGE_ID=5125022693565388760] -->
    <string name="notification_badging_title">Notification dot on app icon</string>

    <!-- Configure Notifications: Title for the notification bubbles option. [CHAR LIMIT=60] -->
    <string name="notification_bubbles_title">Bubbles</string>
    <!-- Title for the toggle shown on the app-level bubbles page  [CHAR LIMIT=60] -->
    <string name="bubbles_app_toggle_title">Bubbles</string>
    <!-- Title for bubbles option on the conversation level screen -->
    <string name="bubbles_conversation_toggle_title">Bubble this conversation</string>
    <!-- Summary for bubbles option on the conversation level screen -->
    <string name="bubbles_conversation_toggle_summary">Show floating icon on top of apps</string>
    <!-- Title of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=NONE] -->
    <string name="bubbles_feature_disabled_dialog_title">Turn on bubbles for device?</string>
    <!-- Description of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=NONE] -->
    <string name="bubbles_feature_disabled_dialog_text">Turning on bubbles for this app will also turn on bubbles for your device.\n\nThis affects other apps or conversations that are allowed to bubble.</string>
    <!-- Button of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=60]-->
    <string name="bubbles_feature_disabled_button_approve">Turn on</string>
    <!-- Button to cancel out of the dialog shown when the user has disabled bubbles at the feature level but tries to enable it for an app. [CHAR LIMIT=60] -->
    <string name="bubbles_feature_disabled_button_cancel">Cancel</string>

    <!-- Bubble feature settings: Description for toggle when bubbles are turned on in notification settings [CHAR LIMIT=100] -->
    <string name="notifications_bubble_setting_on_summary">On / Conversations can appear as floating icons</string>
    <!-- Bubble feature settings: Title of the toggle to turn bubbles on and off [CHAR LIMIT=100] -->
    <string name="notifications_bubble_setting_title">Allow apps to show bubbles</string>
    <!-- Bubble feature settings: Description shown with the toggle to turn bubbles on and off [CHAR LIMIT=NONE]-->
    <string name="notifications_bubble_setting_description">Some conversations will appear as floating icons on top of other apps</string>
    <!-- Bubble app settings: option allowing all conversations from an app to bubble if the app sends bubbles [CHAR LIMIT=60]-->
    <string name="bubble_app_setting_all">All conversations can bubble</string>
    <!-- Bubble app settings: option allowing only user selected conversations from an app to bubble if the app sends bubbles [CHAR LIMIT=60] -->
    <string name="bubble_app_setting_selected">Selected conversations can bubble</string>
    <!-- Bubble app settings: option allowing no bubbles from the app [CHAR LIMIT=60] -->
    <string name="bubble_app_setting_none">Nothing can bubble</string>
    <!-- Bubble app settings: Title above a list of conversations that have been selected to bubble [CHAR LIMIT=60]-->
    <string name="bubble_app_setting_selected_conversation_title">Conversations</string>
    <!-- Bubble app settings: Title above a list of conversations that have been excluded from bubbling [CHAR LIMIT=100] -->
    <string name="bubble_app_setting_excluded_conversation_title">All conversations can bubble except</string>
    <!-- Bubble app settings: Content description - action to make a conversation no longer bubble -->
    <string name="bubble_app_setting_unbubble_conversation">Turn off bubbles for this conversation</string>
    <!-- Bubble app settings: Content description - action to make a conversation bubble -->
    <string name="bubble_app_setting_bubble_conversation">Turn on bubbles for this conversation</string>

    <!-- Configure notifications: value for swipe direction [CHAR LIMIT=100] -->
    <string name="swipe_direction_ltr">Swipe right to dismiss, left to show menu</string>

    <!-- Configure notifications: value for swipe direction [CHAR LIMIT=100] -->
    <string name="swipe_direction_rtl">Swipe left to dismiss, right to show menu</string>

    <!-- Notification settings: suppress status bar/ambient icons for silent notifications -->
    <string name="silent_notifications_status_bar">Hide silent notifications in status bar</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 privacy options for notifications. [CHAR LIMIT=60] -->
    <string name="lock_screen_notifications_title">Privacy</string>

    <!-- Configure lock screen: Title for the option of unlocking directly to home. [CHAR LIMIT=30] -->
    <string name="lockscreen_bypass_title">Skip lock screen</string>

    <!-- Configure lock screen: Summary for the option of unlocking directly to home. [CHAR LIMIT=150] -->
    <string name="lockscreen_bypass_summary">After unlocking, go directly to last used screen. Notifications won’t show on lock screen. Swipe down from top to see them.</string>

    <!-- Configure lock screen: Search keywords for the option of unlocking directly to home. [CHAR LIMIT=100] -->
    <string name="keywords_lockscreen_bypass">Lock screen, Lockscreen, Skip, Bypass</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: Title for the option controlling whether only new notifications are displayed to the user
    on the lock screen [CHAR LIMIT=60] -->
    <string name="unseen_notifs_lock_screen">Show only new notifications on lock screen</string>

    <!-- Configure notifications: Summary for option of showing only new notifications on the lock screen. [CHAR LIMIT=100] -->
    <string name="unseen_notifs_lock_screen_summary">Automatically remove previously viewed notifications from the lock screen</string>

    <!-- Configure notifications: Title for determining which notifications appear on the lock screen [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_title">Notifications on lock screen</string>

    <!-- Configure notifications: summary for lockscreen notifications: all notifications shown
    regardless of noisiness [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_all_summary">Show conversations, default, and silent</string>

    <!-- Configure notifications: Value for lockscreen notifications: all notifications shown
    regardless of noisiness [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_all">Show conversations, default, and silent</string>

    <!-- Configure notifications: Value for lockscreen notifications: show alerting notifications [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_alerting">Hide silent conversations and notifications</string>

    <!-- Configure notifications: Value for lockscreen notifications: don't show notifications [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_show_none">Don\u2019t show any notifications</string>

    <!-- Configure notifications: Title for redacting sensitive content on lockscreen [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_redact">Sensitive notifications</string>

    <!-- Configure notifications: Summary for redacting sensitive content on lockscreen [CHAR LIMIT=120] -->
    <string name="lock_screen_notifs_redact_summary">Show sensitive content when locked</string>

    <!-- Configure notifications: Title for redacting sensitive content on lockscreen, work profile [CHAR LIMIT=60] -->
    <string name="lock_screen_notifs_redact_work">Sensitive work profile notifications</string>

    <!-- Configure notifications: Summary for redacting sensitive content on lockscreen, work profile [CHAR LIMIT=120] -->
    <string name="lock_screen_notifs_redact_work_summary">Show sensitive work profile content when 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, but will be shown if the user is unlocked by either smart lock or via biometric unlock mechanism.
         [CHAR LIMIT=50] -->
    <string name="lock_screen_notifications_summary_hide">Show sensitive content only when unlocked</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">What do you want your lock screen to show?</string>

    <!-- Security > Choose PIN/PW/Pattern > Notification redaction interstitial: Title for the screen asking the user how much notification content they want to see on their lock screen [CHAR LIMIT=30] -->
    <string name="lock_screen_notifications_interstitial_title">Lock screen</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=100] Notification importance screen title -->
    <string name="notification_importance_title">Behavior</string>

    <!-- [CHAR LIMIT=100] Header for a grouping on conversations-->
    <string name="conversations_category_title">Conversations</string>

    <!-- [CHAR LIMIT=100] Title for switch that says whether this app can appear in the conversation notification section-->
    <string name="conversation_section_switch_title">Conversation section</string>

    <!-- [CHAR LIMIT=100] Summary for switch that says whether this app can appear in the conversation notification section-->
    <string name="conversation_section_switch_summary">Allow app to use conversation section</string>

    <!-- [CHAR LIMIT=NONE] Conversation preference summary, the parent channel this conversation was spawned from (separator) the parent channel group (e.g. an account name)-->
    <string name="notification_conversation_summary" translatable="false">"<xliff:g id="parent_category_name">%1$s</xliff:g> • <xliff:g id="parent_category_group_name">%2$s</xliff:g>"</string>

    <!-- [CHAR LIMIT=100] Field on conversation settings page -->
    <string name="demote_conversation_title">Not a conversation</string>

    <!-- [CHAR LIMIT=NONE] Summary for demote_conversation_title on conversation settings page -->
    <string name="demote_conversation_summary">Remove from the conversation section</string>

    <!-- [CHAR LIMIT=100] Field on notification channel settings page -->
    <string name="promote_conversation_title">This is a conversation</string>

    <!-- [CHAR LIMIT=NONE] Summary for promote_conversation_title on notifications settings page -->
    <string name="promote_conversation_summary">Add to the conversation section</string>

    <!-- [CHAR LIMIT=100] summary text on link to 'all conversations' page, no conversations are priority -->
    <string name="priority_conversation_count_zero">No priority conversations</string>

    <!-- [CHAR LIMIT=100] summary text on link to 'all conversations' page, some conversations are priority -->
    <string name="priority_conversation_count">{count, plural,
      =1      {# priority conversation}
      other   {# priority conversations}
    }</string>

    <!-- [CHAR LIMIT=100] preference category title -->
    <string name="important_conversations">Priority conversations</string>

    <!-- preference category summary -->
    <string name="important_conversations_summary_bubbles">Show at top of conversation section and appear as floating bubbles</string>

    <!-- preference category summary -->
    <string name="important_conversations_summary">Show at top of conversation section</string>

    <!-- [CHAR LIMIT=100] preference category title -->
    <string name="other_conversations">Non-priority conversations</string>

    <!-- summary for other conversations list -->
    <string name="other_conversations_summary">Conversations you\u2019ve made changes to</string>

    <!-- [CHAR LIMIT=100] preference category title -->
    <string name="recent_conversations">Recent conversations</string>

    <!-- [CHAR LIMIT=60] button title -->
    <string name="conversation_settings_clear_recents">Clear recent conversations</string>

    <!-- a11y feedback for 'clear recents' button' -->
    <string name="recent_convos_removed">Recent conversations removed</string>

    <!-- a11y feedback for 'clear recent conversation' button' -->
    <string name="recent_convo_removed">Conversation removed</string>

    <!-- a11y string -->
    <string name="clear">Clear</string>

    <!-- a11y string -->
    <string name="clear_conversation">Clear <xliff:g id="conversation_name" example="Mom">%1$s</xliff:g></string>

    <!-- title for conversation onboarding -->
    <string name="conversation_onboarding_title">Priority and modified conversations will appear here</string>

    <!-- summary for conversation onboarding -->
    <string name="conversation_onboarding_summary">Once you mark a conversation as priority, or make any other changes to conversations, they will appear here.
        \n\nTo change conversation settings:
        \nSwipe down from the top of the screen to open the pull-down shade, then touch &amp; hold a conversation.</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">Minimize</string>

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

    <!-- [CHAR LIMIT=100] Notification Importance title -->
    <string name="notification_silence_title">Silent</string>

    <!-- [CHAR LIMIT=100] Notification Importance title -->
    <string name="notification_alert_title">Default</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>

    <!-- [CHAR LIMIT=150] Notification Importance title: important conversation level -->
    <string name="notification_priority_title">Priority</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: important conversation level summary -->
    <string name="notification_channel_summary_priority">Shows at top of conversation section, appears as floating bubble, displays profile picture on lock screen</string>

    <string name="convo_not_supported_summary"><xliff:g id="app_name" example="Android Services">%1$s</xliff:g> doesn\u2019t support most conversation features. You can’t set a conversation as priority, and conversations won’t appear as floating bubbles.</string>

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

    <!-- [CHAR LIMIT=150] Notification Importance title: min importance level summary -->
    <string name="notification_channel_summary_min">In the pull-down shade, collapse notifications to one line</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: low importance level summary -->
    <string name="notification_channel_summary_low">No sound or vibration</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: low importance level summary -->
    <string name="notification_conversation_summary_low">No sound or vibration and appears lower in conversation section</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: normal importance level summary -->
    <string name="notification_channel_summary_default">May ring or vibrate based on device settings</string>

    <!-- [CHAR LIMIT=150] Notification Importance title: high importance level summary -->
    <string name="notification_channel_summary_high">When device is unlocked, show notifications as a banner across the top of the screen</string>

    <!-- [CHAR LIMIT=100] Label for on/off toggle -->
    <string name="notification_switch_label">All \"<xliff:g id="app_name" example="Android Services">%1$s</xliff:g>\" notifications</string>

    <!-- [CHAR LIMIT=100] Label for on/off toggle -->
    <string name="notification_app_switch_label">All <xliff:g id="app_name" example="Android Services">%1$s</xliff:g> notifications</string>

    <!-- app summary of notification app list screen [CHAR LIMIT=100] -->
    <string name="notifications_sent_daily">{count, plural,
      =1      {About # notification per day}
      other   {About # notifications per day}
    }</string>
    <string name="notifications_sent_weekly">{count, plural,
      =1      {About # notification per week}
      other   {About # notifications 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=60] -->
    <string name="manage_notification_access_title">Device &amp; app notifications</string>

    <string name="manage_notification_access_summary">Control which apps and devices can read notifications</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>

    <!-- Title for Notification Assistant setting  [CHAR LIMIT=30]-->
    <string name="notification_assistant_title">Enhanced notifications</string>
    <!-- Summary of Notification Assistant provided features [CHAR LIMIT=NONE]-->
    <string name="notification_assistant_summary">Get suggested actions, replies, and more</string>

    <!-- Label for no NotificationAssistantService [CHAR_LIMIT=NONE] -->
    <string name="no_notification_assistant">None</string>

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

    <!-- Button title that grants 'notification access' permission to an app [CHAR_LIMIT=60]-->
    <string name="notification_access_detail_switch">Allow notification access</string>

    <!-- Summary for a warning message about security implications of enabling a notification
          assistant, displayed as a dialog message. [CHAR LIMIT=NONE] -->
    <string name="notification_assistant_security_warning_summary">
        Enhanced notifications replaced Android Adaptive Notifications in Android 12.
        This feature shows suggested actions and replies, and organizes your notifications.
        \n\nEnhanced notifications can access notification content, including personal information
        like contact names and messages. This feature can also dismiss or respond to notifications,
        such as answering phone calls, and control Do Not Disturb.
    </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">
        The <xliff:g id="notification_listener_name">%1$s</xliff:g> app will be able to read all notifications,
        including personal information such as contact names, photos, and the text of messages you receive.
        This app will also be able to snooze or dismiss notifications or take action on buttons in notifications, including answering phone calls.
        \n\nThis will also give the app the ability to turn Do Not Disturb on or off and change related settings.
    </string>
    <string name="nls_warning_prompt">The <xliff:g id="notification_listener_name">%1$s</xliff:g> app will be able to:</string>
    <string name="nls_feature_read_title">Read your notifications</string>
    <string name="nls_feature_read_summary">It can read your notifications, including personal information such as contacts, messages, and photos.</string>
    <string name="nls_feature_reply_title">Reply to messages</string>
    <string name="nls_feature_reply_summary">It can reply to messages and take action on buttons in notifications, including snoozing or dismissing notifications and answering calls.</string>
    <string name="nls_feature_settings_title">Change settings</string>
    <string name="nls_feature_settings_summary">It can 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>
    <string name="notif_type_ongoing">Real-time</string>
    <string name="notif_type_ongoing_summary">Ongoing communication from apps in use, navigation, phone calls, and more</string>
    <string name="notif_type_conversation">Conversations</string>
    <string name="notif_type_conversation_summary">SMS, text messages, and other communications</string>
    <string name="notif_type_alerting">Notifications</string>
    <string name="notif_type_alerting_summary">May ring or vibrate based on settings</string>
    <string name="notif_type_silent">Silent</string>
    <string name="notif_type_silent_summary">Notifications that never make sound or vibrations</string>
    <!-- category header for apps allowed to read notifications. [CHAR LIMIT=45] -->
    <string name="notification_listener_allowed">Allowed</string>
    <!-- category header for apps not allowed to read notifications. [CHAR LIMIT=45] -->
    <string name="notification_listener_not_allowed">Not allowed</string>

    <!-- Per notification listener, a list of apps whose notifications this listener cannot see -->
    <string name="notif_listener_excluded_app_title">See all apps</string>
    <string name="notif_listener_excluded_app_summary">Change settings for each app that sends notifications</string>
    <string name="notif_listener_excluded_app_screen_title">Apps shown on device</string>
    <string name="notif_listener_not_migrated">This app doesn\u2019t support enhanced settings</string>
    <string name="notif_listener_more_settings">More settings</string>
    <string name="notif_listener_more_settings_desc">More settings are available inside this app</string>

    <!-- Title for Polite Notifications setting  [CHAR LIMIT=30]-->
    <string name="notification_polite_title">Notification cooldown</string>
    <string name="notification_polite_all_apps">Apply cooldown to all notifications</string>
    <string name="notification_polite_all_apps_summary">Gradually lower the notification volume when you get many successive notifications from the same app</string>
    <string name="notification_polite_conversations">Apply cooldown to conversations</string>
    <string name="notification_polite_conversations_summary">Gradually lower the notification volume when you get many messages from the same chat within a short period of time</string>
    <string name="notification_polite_disabled">Don\'t use notification cooldown</string>
    <string name="notification_polite_disabled_summary">Never lower notification volume, regardless of the amount of successive notifications from the same app</string>
    <string name="notification_polite_vibrate_unlocked">Vibrate when unlocked</string>
    <string name="notification_polite_vibrate_unlocked_summary">Only vibrate when screen is unlocked</string>
    <string name="notification_polite_work">Apply to work profiles</string>
    <string name="notification_polite_work_summary">Apply the notification cooldown settings from your personal profile to your work profile</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>

    <!-- Settings label. This setting shows a user's connected work and personal apps.
    When a user connects select work and personal apps, they can access work and personal data together. [CHAR LIMIT=50] -->
    <string name="interact_across_profiles_title">Connected work &amp; personal apps</string>

    <!-- Settings subtext. This text is shown when the work and personal apps are connected. [CHAR LIMIT=45] -->
    <string name="interact_across_profiles_summary_allowed">Connected</string>

    <!-- Settings subtext. This text is shown when the work and personal apps are not connected. [CHAR LIMIT=45] -->
    <string name="interact_across_profiles_summary_not_allowed">Not connected</string>

    <!-- Settings subtext. This text is shown when a user doesn't have any connected apps. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_empty_text">No connected apps</string>

    <!-- Search keywords. If a user is searching for the "Connected work & personal apps" feature in Settings,
    these keywords will surface that feature. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_keywords">cross profile connected app apps work and personal</string>

    <!-- Toggle label. This text is shown when a user's work and personal apps are connected. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_switch_enabled">Connected</string>

    <!-- Toggle label. This text is shown when a user can connect specific work and personal apps.
    The apps they can connect are shown above this toggle. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_switch_disabled">Connect these apps</string>

    <!-- Settings text. This text lets a user know that if they connect work and personal apps,
    they will share permissions and can access each other's data. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_summary_1">Connected apps share permissions and can access each other\u2019s data.</string>

    <!-- Settings text. This text lets a user know that they should only connect work and personal apps
    if they trust the work app with their personal data. The work app could potentially show that data
    to the user's IT admin. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_summary_2">Only connect apps if you trust them not to share personal data with your IT admin.</string>

    <!-- Settings text. This text lets a user know that they can disconnect work and personal apps from
    the Privacy page in settings, This is only shown when the connected app page is launched via
    an app, not when navigated to via settings. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_summary_3">You can disconnect apps anytime in your device\u2019s privacy settings.</string>

    <!-- Dialog title. This dialog is shown when a user tries to connect a work app to a personal
    app (e.g. their work Calendar to their personal Calendar), and it's confirming that they should
    connect the apps only if they trust the work app with their personal data. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_title">Trust work <xliff:g id="name" example="Calendar">%1$s</xliff:g> with your personal data?</string>

    <!-- Dialog text. This dialog is shown when a user tries to connect a work app to a personal
    app (e.g. their work Calendar to their personal Calendar), and it's confirming that they should
    connect the apps only if they trust the work app with their personal data.
    The placeholder is the app name. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_summary">Only connect apps if you trust them not to share personal data with your IT admin.</string>

    <!-- Title of a section in a dialog. This section shows the app data that will be
    accessible when work and personal apps are connected. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_app_data_title">App data</string>

    <!-- Dialog text. This text lets the user know that their work app (e.g. Calendar) will be
    able to access data in their personal app. The placeholder is the app name. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_app_data_summary">This app can access data in your personal <xliff:g id="name" example="Calendar">%1$s</xliff:g> app.</string>

    <!-- Title of a section in a dialog. This section shows the permissions that will be accessible
    when work and personal apps are connected. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_permissions_title">Permissions</string>

    <!-- Dialog text. This text lets the user know that their work app (e.g. Calendar) will be able
    to use permissions in their personal app. The placeholder is the app name. [CHAR LIMIT=NONE] -->
    <string name="interact_across_profiles_consent_dialog_permissions_summary">This app can use your personal <xliff:g id="name" example="Calendar">%1$s</xliff:g> app\u2019s permissions, like access to location, storage, or contacts.</string>

    <!-- Summary of preference to manage connected work and personal apps, informing the user that
    currently no apps are connected [CHAR LIMIT=NONE]-->
    <string name="interact_across_profiles_number_of_connected_apps_none">No apps connected</string>

    <!-- Summary of preference to manage connected work and personal apps, informing the user how many apps are connected -->
    <string name="interact_across_profiles_number_of_connected_apps">{count, plural,
      =1      {# app connected}
      other   {# apps connected}
    }</string>

    <!-- Banner title. This banner lets a user know that they need to install an app in their
    work profile in order to connect it to the corresponding personal app.
    The placeholder would be the app name (e.g. Calendar). [CHAR LIMIT=NONE]-->
    <string name="interact_across_profiles_install_work_app_title">To connect these apps, install <xliff:g id="name" example="Calendar">%1$s</xliff:g> in your work profile</string>

    <!-- Banner title. This banner lets a user know that they need to install an app in their
    personal profile in order to connect it to the corresponding work app.
    The placeholder would be the app name (e.g. Calendar). [CHAR LIMIT=NONE]-->
    <string name="interact_across_profiles_install_personal_app_title">To connect these apps, install <xliff:g id="name" example="Calendar">%1$s</xliff:g> in your personal profile</string>

    <!-- Banner text. This banner lets a user know that they need to install an app in their
    work/personal profile in order to connect it to the corresponding personal app.
    The placeholder would be the app name (e.g. Calendar). [CHAR LIMIT=NONE]-->
    <string name="interact_across_profiles_install_app_summary">Tap to get the app</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>

    <!-- Button title that grants 'Do Not Disturb' permission to an app [CHAR_LIMIT=60]-->
    <string name="zen_access_detail_switch">Allow Do Not Disturb</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 appearing when app notifications are off -->
    <string name="app_notifications_off_desc">You haven\'t allowed notifications from this app</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] Text appearing when app does not send notifications -->
    <string name="app_notifications_not_send_desc">This app does not send notifications</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=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=NONE] Footer listing a count of deleted channels. -->
    <string name="deleted_channels">{count, plural,
      =1      {# category deleted}
      other   {# categories deleted}
    }</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] App notification settings: Full screen intent permission option title -->
    <string name="app_notification_fsi_permission_title">Allow full screen notifications</string>

    <!-- [CHAR LIMIT=NONE] App notification settings: Full screen intent permission option description -->
    <string name="app_notification_fsi_permission_summary">Allow notifications to take up the full screen when the device is locked</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">Lock screen</string>

    <!-- [CHAR LIMIT=20] Notification settings: App notifications dialog dismiss button caption -->
    <string name="app_notifications_dialog_done">Done</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">Vibration</string>

    <!-- [CHAR LIMIT=180] Notification settings: sound -->
    <string name="notification_channel_sound_title">Sound</string>

    <!-- [CHAR LIMIT=180] Notification conversation: important -->
    <string name="notification_conversation_important">Priority</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule name option and edit dialog title -->
    <string name="zen_mode_rule_name">Schedule name</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Rule name hint text -->
    <string name="zen_mode_rule_name_hint">Enter schedule name</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Warning text for invalid zen rule names -->
    <string name="zen_mode_rule_name_warning">Schedule name already in use</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Add another automatic zen rule option name-->
    <string name="zen_mode_add_rule">Add more</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Add event-based rule, set rule name title -->
    <string name="zen_mode_add_event_rule">Add event schedule</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Add time-based rule, set rule name title -->
    <string name="zen_mode_add_time_rule">Add time schedule</string>

    <!-- [CHAR LIMIT=60] Zen mode settings: Choose rule type dialog title -->
    <string name="zen_mode_choose_rule_type">Choose schedule 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=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=40] Zen mode settings: Event rule type name -->
    <string name="zen_event_rule_type_name">Event</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 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=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">Schedule turns off when an alarm rings</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Title for preference to allow custom behavior for the dnd schedule -->
    <string name="zen_mode_custom_behavior_title">Do Not Disturb behavior</string>

    <!-- [CHAR LIMIT=120] Zen mode settings: Summay text indicating the currenty dnd schedule is using the default dnd settings -->
    <string name="zen_mode_custom_behavior_summary_default">Use default settings</string>

    <!-- [CHAR LIMIT=120] Zen mode settings: Summay text indicating the currenty dnd schedule is using custom behavior -->
    <string name="zen_mode_custom_behavior_summary">Create custom settings for this schedule</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Category text indicating the schedule this custom behavior will be configured for-->
    <string name="zen_mode_custom_behavior_category_title">For \u2018<xliff:g id="schedule_name" example="Schedule 1">%1$s</xliff:g>\u2019</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=120] Zen mode settings: Title for conversations settings page -->
    <string name="zen_mode_conversations_title">Conversations</string>
    <string name="zen_mode_from_all_conversations">All conversations</string>
    <string name="zen_mode_from_important_conversations">Priority conversations</string>
    <!-- [CHAR LIMIT=40] Version of the above for "priority conversations" when it is a non-first member of a list -->
    <string name="zen_mode_from_important_conversations_second">priority conversations</string>
    <string name="zen_mode_from_no_conversations">None</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Number of conversations allowed to bypass DND -->
    <string name="zen_mode_conversations_count">
        {count, plural,
            =0    {None}
            =1    {1 conversation}
            other {# conversations}
        }
    </string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Header for calls and messages section of conversations
    setting page -->
    <string name="zen_mode_people_calls_messages_section_title">Who can interrupt</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: people screen footer -->
    <string name="zen_mode_people_footer">Even if messaging or calling apps can\u0027t notify you, people you choose here can still reach you through those apps</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Allow calls toggle title -->
    <string name="zen_mode_calls_title">Calls</string>
    <!-- [CHAR LIMIT=20] Zen mode settings: Calls option -->
    <string name="zen_mode_calls">Calls</string>
    <!-- [CHAR LIMIT=20] Zen mode settings: Calls option -->
    <string name="zen_mode_calls_list">calls</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Calls settings header -->
    <string name="zen_mode_calls_header">Calls that can interrupt</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Calls screen footer -->
    <string name="zen_mode_calls_footer">To make sure allowed calls make sound, check that device is set to ring</string>
    <!-- [CHAR LIMIT=NONE] Zen mode custom rule settings: Calls screen footer -->
    <string name="zen_mode_custom_calls_footer">For \u2018<xliff:g id="schedule_name" example="Schedule 1">%1$s</xliff:g>\u2019 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] -->
    <string name="zen_mode_starred_contacts_summary_contacts">
        {count, plural, offset:2
            =0    {None}
            =1    {{contact_1}}
            =2    {{contact_1} and {contact_2}}
            =3    {{contact_1}, {contact_2}, and {contact_3}}
            other {{contact_1}, {contact_2}, and # others}
        }
    </string>

    <!-- [CHAR LIMIT=50] Zen mode settings: placeholder for a Contact name when the name is empty -->
    <string name="zen_mode_starred_contacts_empty_name">(No name)</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Messages option -->
    <string name="zen_mode_messages">Messages</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: Messages option -->
    <string name="zen_mode_messages_list">messages</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: Allow messages to bypass DND title -->
    <string name="zen_mode_messages_title">Messages</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Messages settings header -->
    <string name="zen_mode_messages_header">Messages that can interrupt</string>
    <!-- Do not disturb settings, messages, events and reminders footer [CHAR LIMIT=NONE]-->
    <string name="zen_mode_messages_footer">To make sure allowed messages make sound, check that device is set to ring</string>
    <!-- [CHAR LIMIT=NONE] Zen mode custom rule settings: Messages screen footer -->
    <string name="zen_mode_custom_messages_footer">For \u2018<xliff:g id="schedule_name" example="Schedule 1">%1$s</xliff:g>\u2019 incoming messages are blocked. You can adjust settings to allow your friends, family, or other contacts to reach you.</string>

    <!-- Zen mode settings: All messages can bypass DND summary [CHAR LIMIT=NONE -->
    <string name="zen_mode_all_messages_summary">All messages can reach you</string>
    <!-- Zen mode settings: All calls can bypass DND summary [CHAR LIMIT=NONE -->
    <string name="zen_mode_all_calls_summary">All calls can reach you</string>
    <!-- Zen mode settings: Senders in contacts can bypass DND summary summary [CHAR LIMIT=NONE] -->
    <string name="zen_mode_contacts_count">
        {count, plural,
            =0    {None}
            =1    {1 contact}
            other {# contacts}
        }
    </string>
    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From anyone -->
    <string name="zen_mode_from_anyone">Anyone</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From contacts only -->
    <string name="zen_mode_from_contacts">Contacts</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: Calls or messages option value: From starred contacts only -->
    <string name="zen_mode_from_starred">Starred contacts</string>

    <!-- [CHAR LIMIT=40] Zen mode settings: Calls option value: No calls allowed -->
    <string name="zen_mode_none_calls">None</string>
    <!-- [CHAR LIMIT=40] Zen mode settings: Messages option value: No messages allowed -->
    <string name="zen_mode_none_messages">None</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow alarms option -->
    <string name="zen_mode_alarms">Alarms</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow alarms summary -->
    <string name="zen_mode_alarms_summary">From timers, alarms, security systems, and other apps</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Alarms list option (ie: sound from alarm clock) -->
    <string name="zen_mode_alarms_list">alarms</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Alarms (ie: sound from alarm clock) category in a list of sounds that can bypass DND when alarms is the first or only element in the list. For example "Alarms can interrupt" or "Alarms and media can interrupt" -->
    <string name="zen_mode_alarms_list_first">Alarms</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow media (sound from video) to bypass dnd -->
    <string name="zen_mode_media">Media sounds</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow media (sound from video) to bypass dnd  summary-->
    <string name="zen_mode_media_summary">Sounds from videos, games, and other media</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Media (ie: sound from video) -->
    <string name="zen_mode_media_list">media</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Media (ie: sound from video) category in a list of sounds when media is the first or only element in the list. For example "Media can interrupt" or "Media and touch sounds can interrupt" -->
    <string name="zen_mode_media_list_first">Media</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: allow touch sounds to bypass DND  -->
    <string name="zen_mode_system">Touch sounds</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: allow touch sounds to bypass DND summary  -->
    <string name="zen_mode_system_summary">Sounds from the keyboard and other buttons</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: System sounds (ie: touch sounds) -->
    <string name="zen_mode_system_list">touch sounds</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: System sounds (ie: touch sounds) category in a list of sounds that can bypass DND when touch sounds is the first or only element in the list. For example "Touch sounds can interrupt" or "Touch sounds and events can interrupt" -->
    <string name="zen_mode_system_list_first">Touch sounds</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow reminder notifications/sounds to bypass DND  -->
    <string name="zen_mode_reminders">Reminders</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow reminder notifications/sounds to bypass DND summary  -->
    <string name="zen_mode_reminders_summary">From tasks and reminders</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Reminders (ie: calendar reminders are allowed to bypass dnd) -->
    <string name="zen_mode_reminders_list">reminders</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Reminders (ie: calendar reminders) category in a list of elements that can bypass DND where reminders is the first or only element in the list. For example, "Reminds can interrupt” or "Reminders and events can interrupt” -->
    <string name="zen_mode_reminders_list_first">Reminders</string>

    <!-- [CHAR LIMIT=80] Zen mode settings: Allow event notifications/sounds to bypass DND -->
    <string name="zen_mode_events">Calendar events</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Allow event notifications/sounds to bypass DND summary -->
    <string name="zen_mode_events_summary">From upcoming calendar events</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Events (ie: calendar events) -->
    <string name="zen_mode_events_list">events</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: Events (ie: calendar events) category in a list of sounds when events is the first or only element in the list. For example “Events can interrupt" or “Events and touch sounds can interrupt" -->
    <string name="zen_mode_events_list_first">Events</string>

    <!-- [CHAR LIMIT=100] Zen mode settings: Allow apps to bypass DND -->
    <string name="zen_mode_bypassing_apps">Allow apps to override</string>
    <!-- [CHAR LIMIT=100] Zen mode settings: Allow apps to bypass DND header -->
    <string name="zen_mode_bypassing_apps_header">Apps that can interrupt</string>
    <!-- [CHAR LIMIT=100] Zen mode settings: Add apps to bypass DND header -->
    <string name="zen_mode_bypassing_apps_add_header">Select more apps</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: No apps are bypassing DND -->
    <string name="zen_mode_bypassing_apps_none">No apps selected</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: No apps are bypassing DND -->
    <string name="zen_mode_bypassing_apps_subtext_none">No apps can interrupt</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Preference to add apps that are allowed to bypass DND -->
    <string name="zen_mode_bypassing_apps_add">Add apps</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Summary indicating all notification channels can
    bypass DND for this app -->
    <string name="zen_mode_bypassing_apps_summary_all">All notifications</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Summary indicating all notification channels can
    bypass DND for this app -->
    <string name="zen_mode_bypassing_apps_summary_some">Some notifications</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Footer for DND bypassing apps settings -->
    <string name="zen_mode_bypassing_apps_footer">Selected people can still reach you, even if you don\u2019t allow apps to interrupt</string>
    <!-- [CHAR LIMIT=NONE] Zen mode settings: Lists apps that can bypass DND. For example, "Nest, Messages, and 2 more can interrupt". -->
    <string name="zen_mode_bypassing_apps_subtext">
        {count, plural, offset:2
            =0    {No apps can interrupt}
            =1    {{app_1} can interrupt}
            =2    {{app_1} and {app_2} can interrupt}
            =3    {{app_1}, {app_2}, and {app_3} can interrupt}
            other {{app_1}, {app_2}, and # more can interrupt}
        }
    </string>
    <!-- [CHAR LIMIT=100] Zen mode settings: Allow apps to bypass DND title-->
    <string name="zen_mode_bypassing_apps_title">Apps</string>
    <!-- [CHAR LIMIT=100] Zen mode settings: Allow notifications from an app to bypass DND header -->
    <string name="zen_mode_bypassing_app_channels_header">Notifications that can interrupt</string>
    <!-- [CHAR LIMIT=100] Zen mode settings: Allow all notifications from an app to bypass DND
    toggle title -->
    <string name="zen_mode_bypassing_app_channels_toggle_all">Allow all notifications</string>

    <!-- [CHAR LIMIT=NONE] Zen mode settings: Summary for sound interruption settings -->
    <string name="zen_mode_other_sounds_summary">
        {count, plural, offset:2
            =0    {Nothing can interrupt}
            =1    {{sound_category_1} can interrupt}
            =2    {{sound_category_1} and {sound_category_2} can interrupt}
            =3    {{sound_category_1}, {sound_category_2}, and {sound_category_3} can interrupt}
            other {{sound_category_1}, {sound_category_2}, and # more can interrupt}
        }
    </string>
    <!-- [CHAR LIMIT=120] Zen mode settings: No sounds are allowed to bypass DND -->
    <string name="zen_mode_sounds_none">Nothing can interrupt</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Summary for people category -->
    <string name="zen_mode_people_none">No one can interrupt</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Summary for people category -->
    <string name="zen_mode_people_some">Some people can interrupt</string>
    <!-- [CHAR LIMIT=120] Zen mode settings: Summary for people category -->
    <string name="zen_mode_people_all">All people can interrupt</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: 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 (ie: repeat callers are allowed to bypass dnd) -->
    <string name="zen_mode_repeat_callers_list">repeat callers</string>
    <!-- [CHAR LIMIT=50] Zen mode settings: calls summary -->
    <string name="zen_mode_calls_summary_one"><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"><xliff:g id="caller type" example="starred contacts">%1$s</xliff:g> and <xliff:g id="caller type" 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=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. -->
    <string name="zen_mode_summary_alarms_only_by_minute">{count, plural,
      =1      {Change to alarms only for one minute until {time}}
      other   {Change to alarms only for # minutes (until {time})}
    }</string>
    <!-- [CHAR LIMIT=NONE] Zen mode summary spoken when changing mode by voice: switch to alarms only for N hours. -->
    <string name="zen_mode_summary_alarms_only_by_hour">{count, plural,
      =1      {Change to alarms only for one hour until {time}}
      other   {Change to alarms only for # hours until {time}}
    }</string>
    <!-- [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>

    <!-- Content description for help icon button [CHAR LIMIT=20] -->
    <string name="warning_button_text">Warning</string>

    <!-- Strings for suggestion card's close button [CHAR LIMIT=20] -->
    <string name="suggestion_button_close">Close</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>

    <!-- Switch text for nfc feature being on [CHAR LIMIT=NONE] -->
    <string name="nfc_setting_on">On</string>
    <!-- Switch text for nfc feature being off [CHAR LIMIT=NONE] -->
    <string name="nfc_setting_off">Off</string>

    <!-- The subtext when screen pinning feature is enabled. [CHAR LIMIT=28] -->
    <string name="screen_pinning_switch_on_text">On</string>
    <!-- The subtext when screen pinning feature is disabled. [CHAR LIMIT=28] -->
    <string name="screen_pinning_switch_off_text">Off</string>
    <!-- [CHAR LIMIT=28] Screen pinning title -->
    <string name="screen_pinning_title">App pinning</string>
    <!-- [CHAR LIMIT=none] Screen pinning introduction -->
    <string name="app_pinning_intro">App pinning allows you to keep the current app in view until you unpin it. This feature can be used, for example, to let a trusted friend play a specific game.</string>
    <!-- [CHAR LIMIT=none] Screen pinning description -->
    <string name="screen_pinning_description">
        <![CDATA[
        When an app is pinned, the pinned app may open other apps and personal data may be accessible.
        \n\nTo use app pinning:
        \t\n{0,number,integer}. Turn on app pinning
        \t\n{1,number,integer}. Open Overview
        \t\n{2,number,integer}. Tap the app icon at the top of the screen, then tap Pin
        ]]>
    </string>
    <!-- [CHAR LIMIT=none] Screen pinning description -->
    <string name="screen_pinning_guest_user_description">
        <![CDATA[
        When an app is pinned, the pinned app may open other apps and personal data may be accessible.
        \n\nIf you want to securely share your device with someone, try using a guest user instead.
        \n\nTo use app pinning:
        \t\n{0,number,integer}. Turn on app pinning
        \t\n{1,number,integer}. Open Overview
        \t\n{2,number,integer}. Tap the app icon at the top of the screen, then tap Pin
        ]]>
    </string>
    <!-- [CHAR LIMIT=300] Screen pinning title -->
    <string name="screen_pinning_dialog_message">
        When app is pinned:
        \n\n\u2022\t\tPersonal data may be accessible
        \n\t\t(such as contacts and email content)
        \n\u2022\t\tPinned app may open other apps
        \n\nOnly use app pinning with people you trust.
    </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>

    <!-- [CHAR LIMIT=60] turn eSim deletion confirmation on/off  -->
    <string name="confirm_sim_deletion_title">Confirm you want to erase your eSIM</string>
    <!-- [CHAR LIMIT=NONE] eSim deletion confirmation description  -->
    <string name="confirm_sim_deletion_description">Verify it\u0027s you before erasing an eSIM</string>

    <!-- [CHAR LIMIT=32] Name of Advanced memory protection page in "More Security Settings" and heading of page. -->
    <string name="memtag_title">Advanced memory protection beta</string>
    <!-- [CHAR LIMIT=52] Label for button to turn on / off Advanced memory protection.-->
    <string name="memtag_toggle">Advanced memory protection</string>
    <!-- [CHAR LIMIT=NONE] Subtitle of Advanced memory protection page. -->
    <string name="memtag_intro">This beta feature helps you protect your device from bugs that may put your security at risk.</string>
    <!-- [CHAR LIMIT=NONE] Status label indicating that Advanced memory protection is on. -->
    <string name="memtag_on">On</string>
    <!-- [CHAR LIMIT=37] Status label indicating that Advanced memory protection is off. -->
    <string name="memtag_off">Off</string>
    <!-- [CHAR LIMIT=37] Status label indicating that system needs to be rebooted for Advanced memory protection to be on. -->
    <string name="memtag_on_pending">On after restart</string>
    <!-- [CHAR LIMIT=37] Status label indicating that system needs to be rebooted for Advanced memory protection to be off. -->
    <string name="memtag_off_pending">Off after restart</string>
    <!-- [CHAR LIMIT=37] Status label indicating that Advanced memory protection was forced off via remote device configuration. -->
    <string name="memtag_force_off">Currently unavailable for your device</string>
    <!-- [CHAR LIMIT=37] Status label indicating that Advanced memory protection was forced on via remote device configuration. -->
    <string name="memtag_force_on">Always on for your device</string>
    <!-- [CHAR LIMIT=NONE] Subtext on page to control Advanced memory protection settings. -->
    <string name="memtag_footer">You\u0027ll have to restart your device to turn Advanced memory protection on or off. When it\u0027s on, you may notice slower device performance.</string>
    <!-- [CHAR LIMIT=31] Header of dialog asking user to reboot device. -->
    <string name="memtag_reboot_title">Restart device?</string>
    <!-- [CHAR LIMIT=NONE] Message shown in dialog prompting user to reboot device to turn on Advanced memory protection.-->
    <string name="memtag_reboot_message_on">You\u0027ll need to restart your device to turn on Advanced memory protection.</string>
    <!-- [CHAR LIMIT=NONE] Message shown in dialog prompting user to reboot device to turn off Advanced memory protection.-->
    <string name="memtag_reboot_message_off">You\u0027ll need to restart your device to turn off Advanced memory protection.</string>
    <!-- [CHAR LIMIT=17] Button label in dialog prompting user to reboot device.-->
    <string name="memtag_reboot_yes">Restart</string>
    <!-- [CHAR LIMIT=17] Button label in dialog prompting user to reboot device.-->
    <string name="memtag_reboot_no">Not now</string>
    <!-- [CHAR LIMIT=NONE] Label for Learn More link. -->
    <string name="memtag_learn_more">Learn more about Advanced memory protection.</string>
    <!-- [CHAR LIMIT=NONE] Search keywords for Advanced memory protection option.
         This is not translatable because it's the technical name for the technology. -->
    <string name="keywords_memtag" translatable="false">MTE, Memory Tagging Extension</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>

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

    <string name="app_launch_open_domain_urls_title">Open supported links</string>
    <!-- Preference title for Supported links open in this app. [CHAR LIMIT=60] -->
    <string name="app_launch_top_intro_message">Allow web links to open in this app</string>
    <!-- Preference title for Links to open in this app. [CHAR LIMIT=60] -->
    <string name="app_launch_links_category">Links to open in this app</string>

    <string name="app_launch_supported_domain_urls_title">Supported links</string>

    <string name="app_launch_other_defaults_title">Other default preferences</string>
    <!-- Preference title for Add link [CHAR LIMIT=60] -->
    <string name="app_launch_add_link">Add link</string>
    <!-- Footer for Open by default. [CHAR LIMIT=NONE] -->
    <string name="app_launch_footer">An app can verify links to automatically open in the app.</string>

    <!-- Title, message and button for verified links dialog. -->
    <string name="app_launch_verified_links_title">{count, plural,
      =1      {# verified link}
      other   {# verified links}
    }</string>
    <string name="app_launch_verified_links_message">{count, plural,
      =1      {This link is verified and automatically opens in this app.}
      other   {These links are verified and automatically open in this app.}
    }</string>
    <!-- OK button for verified links dialog. [CHAR LIMIT=20] -->
    <string name="app_launch_dialog_ok">OK</string>
    <!-- Info icon description of the verified links. [CHAR LIMIT=NONE] -->
    <string name="app_launch_verified_links_info_description">Show verified links list</string>

    <!-- Title for Checking other supported links dialog. [CHAR LIMIT=50] -->
    <string name="app_launch_checking_links_title">Checking for other supported links\u2026</string>
    <!-- Cancel button for Checking other supported links dialog. [CHAR LIMIT=20] -->
    <string name="app_launch_dialog_cancel">Cancel</string>

    <!-- Title and button for supported links dialog. -->
    <string name="app_launch_supported_links_title">{count, plural,
      =1      {# supported link}
      other   {# supported links}
    }</string>
    <!-- Add button for supported links dialog. [CHAR LIMIT=20] -->
    <string name="app_launch_supported_links_add">Add</string>
    <!-- The subtext of the link title in supported links dialog. [CHAR LIMIT=30] -->
    <string name="app_launch_supported_links_subtext">Opens in <xliff:g id="app_label" example="Reddit">%s</xliff:g></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>

    <!-- 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"><xliff:g id="notifications_sent" example="~6 per week">%1$s</xliff:g> / <xliff:g id="notifications_categories_off" example="3 categories turned off">%2$s</xliff:g> </string>
    <!-- Label for showing apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="notifications_disabled">Off</string>

    <!-- Permissions preference summary [CHAR LIMIT=40] -->
    <string name="notifications_categories_off">{count, plural,
      =1      {# category turned off}
      other   {# categories turned off}
    }</string>

    <!-- Runtime permissions preference summary.  Number of additional permissions granted. [CHAR LIMIT=40] -->
    <string name="runtime_permissions_additional_count">{count, plural,
      =1      {# additional permission}
      other   {# additional permissions}
    }</string>

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

    <!-- Runtime permissions preference summary, which describes what the permission manager does. [CHAR LIMIT=NONE] -->
    <string name="runtime_permissions_summary_control_app_access">Control app access to your data</string>

    <!-- Permissions usage title [CHAR LIMIT=NONE] -->
    <string name="permissions_usage_title">Privacy dashboard</string>

    <!-- Permissions usage summary, which describes what the permissions usage does [CHAR LIMIT=NONE] -->
    <string name="permissions_usage_summary">Show which apps recently used permissions</string>

    <!-- Label for showing apps that have not been used for months. [CHAR LIMIT=40]-->
    <string name="unused_apps">Unused apps</string>

    <!-- Summary of number of apps that have not been used for months. [CHAR LIMIT=40]-->
    <string name="unused_apps_summary">{count, plural,
      =1      {# unused app}
      other   {# unused apps}
    }</string>

    <!-- Label for category for unused app settings for an app. [CHAR LIMIT=40]-->
    <string name="unused_apps_category">Unused app settings</string>

    <!-- Label of a switch preference that controls whether the system will pause app activity when the app has not been used for months [CHAR LIMIT=40]-->
    <string name="unused_apps_switch">Pause app activity if unused</string>

    <!-- Summary of the switch preference that controls whether the system will pause app activity when the app has not been used for months [CHAR LIMIT=NONE]-->
    <string name="unused_apps_switch_summary">Remove permissions, delete temporary files, and stop notifications</string>

    <!-- Label of a switch preference that controls whether the system will pause app activity when the app has not been used for a while [CHAR LIMIT=40]-->
    <string name="unused_apps_switch_v2">Manage app if unused</string>

    <!-- Summary of the switch preference that controls whether the system will pause app activity when the app has not been used for a while [CHAR LIMIT=NONE]-->
    <string name="unused_apps_switch_summary_v2">Remove permissions, delete temporary files, stop notifications, and archive the app</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 apps with blocked notifications in list [CHAR LIMIT=30] -->
    <string name="filter_notif_blocked_apps">Turned off</string>

    <!-- Title for advanced application management settings [CHAR LIMIT=30] -->
    <string name="advanced_apps">Advanced</string>

    <!-- Label for list that shows all permissions -->
    <string name="app_permissions">Permission manager</string>

    <!-- Title for the entrypoint that navigates to the App Data Sharing Updates page. [CHAR LIMIT=70]-->
    <string name="app_data_sharing_updates_title">Data sharing updates for location</string>

    <!-- Summary for the entrypoint that navigates to the App Data Sharing Updates page. [CHAR LIMIT=130]-->
    <string name="app_data_sharing_updates_summary">Review apps that changed the way they may share your location data</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>

    <!-- Explanation that the app that will ALWAYS be launched to open web links to domains that it understands -->
    <string name="app_link_open_always">Allow app to open supported links</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 allow app to open links</string>

    <!-- Summary for allow app to open supported links [CHAR LIMIT=42] -->
    <string name="app_link_open_always_summary">{count, plural,
      =1      {App claims to handle # link}
      other   {App claims to handle # links}
    }</string>

    <!-- Footer of open supported links settings [CHAR LIMIT=NONE] -->
    <string name="open_supported_links_footer">App claims to handle following links:</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">Digital assistant app</string>

    <!-- Title for Default Assist settings [CHAR LIMIT=30] -->
    <string name="default_digital_assistant_title">Default digital assistant app</string>

    <!-- Label for the button to acknowledge assistant security implications. [CHAR LIMIT=30] -->
    <string name="assistant_security_warning_agree">Agree</string>

    <!-- Title for Default Browser settings [CHAR LIMIT=30] -->
    <string name="default_browser_title">Browser app</string>

    <!--  Title for Default Phone app settings [CHAR LIMIT=30] -->
    <string name="default_phone_title">Phone app</string>

    <!-- Label of system app for current setting -->
    <string name="system_app">(System)</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 title to show stats about how much time user spent in an app [CHAR LIMIT=45] -->
    <string name="time_spent_in_app_pref_title">Screen time</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>

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

    <!-- 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 list to control apps that ignore battery saving restrictions [CHAR LIMIT=27]-->
    <string name="high_power_apps">Battery optimization</string>

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

    <!-- 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.</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>
    <!-- Summary of power usage for an app within past 24 hr[CHAR LIMIT=NONE] -->
    <string name="battery_summary_24hr"><xliff:g id="percentage" example="2">%1$s</xliff:g> use for past 24 hours</string>

    <!-- Summary for app with no battery usage [CHAR LIMIT=NONE] -->
    <string name="no_battery_summary">No battery use since last full charge</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>
    <!-- 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>
    <!-- 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>
    <!-- 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 using the device as a Webcam. -->
    <string name="usb_use_uvc_webcam">Webcam</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 transcoding the files that are transferred via MTP. -->
    <string name="usb_transcode_files">Convert videos to AVC</string>
    <!-- The summary text that appears when the user enables the 'Convert videos to AVC' option for
         transcoding files to compatible formats before transferring them from the device to PC.
         [CHAR LIMIT=NONE] -->
    <string name="usb_transcode_files_summary">Videos will play on more media players, but quality may be reduced</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>
    <!-- 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>

    <!-- The title used in USB Preferences which provides the user with the control over this
         device's power role. -->
    <string name="usb_power_title">Power options</string>
    <!-- The title used in USB Preferences which lets the user control the options for the file
         transfer mode. -->
    <string name="usb_file_transfer_title">File transfer options</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\u2026</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 entering UVC mode [CHAR LIMIT=NONE] -->
    <string name="usb_summary_UVC">Webcam</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 summary for USB preference when set to entering UVC mode
         and powering other device [CHAR LIMIT=NONE] -->
    <string name="usb_summary_UVC_power">Webcam and supplying power</string>

    <!-- Settings item title for background check prefs [CHAR LIMIT=35] -->
    <string name="background_check_pref">Background check</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] -->
    <string name="memory_usage_apps_summary">{count, plural,
      =1      {1 app used memory in the last {time}}
      other   {# apps used memory in the last {time}}
    }</string>

    <!-- Label for toggle that enables the profiling/aggregating of memory usage [CHAR LIMIT=80]-->
    <string name="force_enable_pss_profiling_title">Enable memory usage profiling</string>
    <!-- Description with an explanation of the extra resources used if profiling of memory usage is enabled [CHAR LIMIT=NONE]-->
    <string name="force_enable_pss_profiling_summary">Memory usage profiling requires additional system resources.</string>
    <!-- Summary that shows the current memory usage profiling status as disabled. [CHAR LIMIT=NONE]-->
    <string name="pss_profiling_disabled">Memory profiling disabled</string>

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

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

    <!-- 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>
    <!-- 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. This app will be able to see where you tap or change what\u2019s displayed on the screen.</string>

    <!-- Change Media Output settings -->
    <!-- Title for Change Media Output screen [CHAR LIMIT=30] -->
    <string name="media_routing_control_title">Change media output</string>
    <!-- Label for setting which controls whether app can change media outputs for other apps [CHAR LIMIT=45] -->
    <string name="allow_media_routing_control">Allow app to switch media output</string>
    <!-- Description for allowing change media output setting [CHAR LIMIT=NONE] -->
    <string name="allow_media_routing_description">Allow this app to choose which connected device plays audio or video from other apps. If allowed, this app can access a list of available devices such as headphones and speakers and choose which output device is used to stream or cast audio or video.</string>

    <!-- Manager External Storage settings title [CHAR LIMIT=40] -->
    <string name="manage_external_storage_title">All files access</string>
    <!-- Label for a setting which controls whether an app can manage external storage [CHAR LIMIT=45] -->
    <string name="permit_manage_external_storage">Allow access to manage all files</string>
    <!-- Description for a setting which controls whether an app can manage external storage
         [CHAR LIMIT=NONE] -->
    <string name="allow_manage_external_storage_description">Allow this app to read, modify and delete all files on this device or any connected storage volumes. If granted, app may access files without your explicit knowledge.</string>
    <!-- Label for showing apps that can manage external storage[CHAR LIMIT=45] -->
    <string name="filter_manage_external_storage">Can access all files</string>

    <!-- Voice Activation apps settings title [CHAR LIMIT=40] -->
    <string name="voice_activation_apps_title">Voice activation apps</string>
    <!-- Label for a setting which controls whether an app can be voice activated [CHAR LIMIT=NONE] -->
    <string name="permit_voice_activation_apps">Allow voice activation</string>
    <!-- Description for a setting which controls whether an app can be voice activated [CHAR LIMIT=NONE] -->
    <string name ="allow_voice_activation_apps_description">Voice activation turns-on approved apps, hands-free, using voice command. Built-in adaptive sensing ensures data stays private only to you.\n\n<a href="">More about protected adaptive sensing</a></string>

    <!-- Manage full screen intent permission title [CHAR LIMIT=40] -->
    <string name="full_screen_intent_title">Full screen notifications</string>

    <!-- Label for setting that allows apps to send full screen intents. [CHAR LIMIT=NONE] -->
    <string name="permit_full_screen_intent">Allow full screen notifications from this app</string>

    <!-- Description for setting that allows apps to send full screen intents. [CHAR LIMIT=NONE] -->
    <string name="footer_description_full_screen_intent">Allow this app to show notifications that take up the full screen when the device is locked. Apps may use these to highlight alarms, incoming calls, or other urgent notifications.</string>

    <!-- Media management apps settings title [CHAR LIMIT=40] -->
    <string name="media_management_apps_title">Media management apps</string>
    <!-- Label for a setting which controls whether an app can manage media files [CHAR LIMIT=45] -->
    <string name="media_management_apps_toggle_label">Allow app to manage media</string>
    <!-- Description for a setting which controls whether an app can manage media files [CHAR LIMIT=NONE] -->
    <string name="media_management_apps_description">If allowed, this app can modify or delete media files created with other apps without asking you. App must have permission to access files and media.</string>
    <!-- Search keywords for media management apps settings [CHAR_LIMIT=NONE] -->
    <string name="keywords_media_management_apps">Media, File, Management, Manager, Manage, Edit, Editor, App, Application, Program</string>

    <!-- Keyword for VR setting -->
    <string name="keywords_vr_listener">vr virtual reality listener stereo helper service</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>

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

    <!-- 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>
    <!-- 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 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 everything bigger 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>
    <!-- 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>

    <!-- Wi-Fi state - Disconnected [CHAR LIMIT=NONE] -->
    <string name="disconnected">Not connected</string>

    <!-- Physical keyboard state - Disconnected [CHAR LIMIT=NONE] -->
    <string name="keyboard_disconnected">Not connected</string>

    <!-- Summary of apps [CHAR LIMIT=NONE] -->
    <string name="apps_summary"><xliff:g id="count" example="24">%1$d</xliff:g> 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 for Display settings, explaining a few important settings under it [CHAR LIMIT=NONE]-->
    <string name="display_dashboard_summary">Dark theme, font size, brightness</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 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 taps a setting on their phone that's blocked by their IT admin [CHAR LIMIT=30 BACKUP_MESSAGE_ID:4867639270211833535] -->
    <string name="disabled_by_policy_title">Blocked by work policy</string>
    <!-- Title for dialog displayed to tell user that changing volume on their phone is blocked by their IT 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 are blocked by their IT admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_outgoing_calls">Can’t make calls</string>
    <!-- Title for dialog displayed to tell user that sending SMS messages is blocked by their IT admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_sms">Can’t send SMS messages</string>
    <!-- Title for dialog displayed to tell user that the camera on their phone is blocked by their IT admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_camera">Can’t use camera</string>
    <!-- Title for dialog displayed to tell user that taking screenshots on their phone is blocked by their IT admin [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_screen_capture">Can’t take screenshots</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>
    <!-- Dialog title. This dialog lets a user know that a specific setting is blocked by their credit provider. Since the user purchased the device from the credit provider, the credit provider controls what they can access. [CHAR LIMIT=50] -->
    <string name="disabled_by_policy_title_financed_device">Blocked by your credit provider</string>
    <!-- Dialog title shown when parental consent is required for the child to set up biometric authentication. [CHAR LIMIT=30] -->
    <string name="disabled_by_policy_title_biometric_parental_consent">Parent needed</string>
    <!-- Dialog content shown when parental consent is required for the child to set up biometric authentication. [CHAR LIMIT=NONE] -->
    <string name="disabled_by_policy_content_biometric_parental_consent">Hand the phone to your parent to start setting this up</string>
    <!-- Dialog content shown when parental consent is required for the child to change blocked settings. [CHAR LIMIT=NONE] -->
    <string name="disabled_by_policy_parental_consent">Hand the phone to your parent to allow this setting to be changed.</string>
    <!-- Shown when the user tries to change phone settings that are blocked by their IT admin [CHAR LIMIT=200] -->
    <string name="default_admin_support_msg">For more info, 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>
    <!-- Shown in admin details page to warn user about policies the admin can set on a financed device. [CHAR LIMIT=NONE] -->
    <string name="admin_financed_message">Your device administrator may be able to access data
        associated with this device, manage apps, and change this device\’s settings.</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 active</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">Networks unavailable</string>

    <!-- Title of condition that do not disturb is on [CHAR LIMIT=36] -->
    <string name="condition_zen_title">Do Not Disturb is on</string>

    <!-- Summary of condition that do not disturb is on and all exceptions set to off [CHAR LIMIT=38] -->
    <string name="condition_zen_summary_phone_muted">Phone muted</string>

    <!-- Summary of condition that do not disturb is on and some exceptions are allowed [CHAR LIMIT=36] -->
    <string name="condition_zen_summary_with_exceptions">With exceptions</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">Features restricted</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 only available via Wi\u2011Fi</string>

    <!-- Title of condition that background data is off [CHAR LIMIT=30] -->
    <string name="condition_bg_data_title">Data Saver</string>

    <!-- Summary of condition that background data is off [CHAR LIMIT=NONE] -->
    <string name="condition_bg_data_summary">Features restricted</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">For apps &amp; notifications</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">Ringer muted</string>

    <!-- Summary of condition that indicates device is muted -->
    <string name="condition_device_muted_summary">For calls &amp; notifications</string>

    <!-- Title of condition that indicates device is set to vibrate [CHAR LIMIT=50] -->
    <string name="condition_device_vibrate_title">Vibration only</string>

    <!-- Summary of condition that indicates device is set to vibrate -->
    <string name="condition_device_vibrate_summary">For calls &amp; notifications</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 tinted amber</string>

    <!-- Title of condition that gray scale is on [CHAR LIMIT=NONE] -->
    <string name="condition_grayscale_title">Grayscale</string>

    <!-- Summary of condition that gray scale is on [CHAR LIMIT=NONE] -->
    <string name="condition_grayscale_summary">Display only in gray color</string>

    <!-- Content description for condition footer button. In talkback mode, double tapping will cause condition list to collapse [CHAR LIMIT=NONE]-->
    <string name="homepage_condition_footer_content_description">Collapse</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 non-carrier data usage in data usage screen [CHAR LIMIT=60] -->
    <string name="non_carrier_data_usage">Non-carrier 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>

    <!-- 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">Mobile 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>

    <!-- A summary shown on data usage screens to indicate data tracking excluded from carrier networks [CHAR LIMIT=NONE] -->
    <string name="non_carrier_data_usage_warning">Excludes data used by carrier networks</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] -->
    <string name="data_saver_unrestricted_summary">{count, plural,
      =1      {1 app allowed to use unrestricted data when Data Saver is on}
      other   {# apps allowed to use unrestricted data when Data Saver is on}
    }</string>

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

    <!-- Brief content description for data usage chart [CHAR LIMIT=NONE] -->
    <string name="data_usage_chart_brief_content_description">Graph showing data usage between <xliff:g id="start_date" example="August 19">%1$s</xliff:g> and <xliff:g id="end_date" example="September 16">%2$s</xliff:g>.</string>

    <!-- Content description for data usage chart when data is not available [CHAR LIMIT=NONE] -->
    <string name="data_usage_chart_no_data_content_description">No data in this date range</string>

    <!-- Informational text about time left in billing cycle [CHAR LIMIT=60] -->
    <string name="billing_cycle_days_left">{count, plural,
      =1      {# day left}
      other   {# days left}
    }</string>

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

    <!-- 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 blocklisted for background data access [CHAR LIMIT=NONE] -->
    <string name="restrict_background_blocklisted">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=75] -->
    <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>

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

    <!-- Preference title for battery usage list page[CHAR_LIMIT=50]-->
    <string name="app_battery_usage_title">App battery usage</string>

    <!-- Preference summary for battery usage list page[CHAR_LIMIT=50]-->
    <string name="app_battery_usage_summary">Set battery usage for apps</string>

    <!-- Label of action button in battery tips card [CHAR LIMIT=50] -->
    <string name="battery_tips_card_action_button">View Settings</string>

    <!-- Label of action button in battery tips card [CHAR LIMIT=50] -->
    <string name="battery_tips_card_action_button_check">Check</string>

    <!-- Label of dismiss button in battery tips card [CHAR LIMIT=50] -->
    <string name="battery_tips_card_dismiss_button">Got it</string>

    <!-- Feedback card message in battery tips card [CHAR LIMIT=NONE] -->
    <string name="battery_tips_card_feedback_info">Is this message helpful?</string>

    <!-- Content description for battery hints warning icon of app anomaly [CHAR LIMIT=NONE] -->
    <string name="battery_hints_warning_icon_a11y">Battery tips warning icon</string>

    <!-- Summary of settings anomaly for adaptive brightness [CHAR LIMIT=NONE] -->
    <string name="battery_tips_settings_summary_brightness">Turn on adaptive brightness to extend battery life</string>

    <!-- Summary of settings anomaly for screen timeout [CHAR LIMIT=NONE] -->
    <string name="battery_tips_settings_summary_screen_timeout">Reduce screen timeout to extend battery life</string>

    <!-- Summary of apps anomaly for always high [CHAR LIMIT=NONE] -->
    <string name="battery_tips_apps_summary_always_high"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> used more battery</string>

    <!-- Summary of apps anomaly for higher than usual [CHAR LIMIT=NONE] -->
    <string name="battery_tips_apps_summary_higher_than_usual"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> used more battery than usual</string>

    <!-- Summary of apps anomaly for always high in background [CHAR LIMIT=NONE] -->
    <string name="battery_tips_apps_summary_always_high_in_background"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> used more battery while in the background</string>

    <!-- Summary of apps anomaly for higher than usual in background [CHAR LIMIT=NONE] -->
    <string name="battery_tips_apps_summary_higher_than_usual_in_background"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> used more battery than usual while in the background</string>

    <!-- Summary of apps anomaly for always high in foreground [CHAR LIMIT=NONE] -->
    <string name="battery_tips_apps_summary_always_high_in_foreground"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> used more battery while in the foreground</string>

    <!-- Summary of apps anomaly for higher than usual in foreground [CHAR LIMIT=NONE] -->
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground"><xliff:g id="app_label" example="Pokemon Go">%1$s</xliff:g> used more battery than usual while in the foreground</string>

    <!-- Content description of the icon in power anomaly banner [CHAR LIMIT=NONE] -->
    <string name="battery_usage_anomaly_content_description">Battery usage anomaly</string>

    <!-- Label of hint for apps anomaly in battery usage [CHAR LIMIT=NONE] -->
    <string name="battery_app_item_hint">High battery usage</string>

    <!-- Label of hint for apps background anomaly in battery usage [CHAR LIMIT=NONE] -->
    <string name="battery_app_item_hint_in_bg">High battery usage in the background</string>

    <!-- Label of hint for apps foreground anomaly in battery usage [CHAR LIMIT=NONE] -->
    <string name="battery_app_item_hint_in_fg">High battery usage in the foreground</string>

    <!-- Filter title for battery unrestricted[CHAR_LIMIT=50]-->
    <string name="filter_battery_unrestricted_title">Unrestricted</string>

    <!-- Filter title for battery optimized[CHAR_LIMIT=50]-->
    <string name="filter_battery_optimized_title">Optimized</string>

    <!-- Filter title for battery restricted[CHAR_LIMIT=50]-->
    <string name="filter_battery_restricted_title">Restricted</string>

    <!-- [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 primary switch for spell checker, turning off will disable entire spell check feature. -->
    <string name="spell_checker_primary_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: 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 public version -->
    <string name="notification_log_details_public_version">publicVersion</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 alert info -->
    <string name="notification_log_details_alerted">notification alerted</string>
    <string name="notification_log_channel">channel</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 all overlays in a given category. -->
    <string name="overlay_option_device_default">Device default</string>
    <!-- [CHAR_LIMIT=NONE] Developer Settings: Toast displayed to the user when an overlay fails to apply. -->
    <string name="overlay_toast_failed_to_apply">Failed to apply overlay</string>

    <!-- [CHAR_LIMIT=60] Label for special access screen -->
    <string name="special_access">Special app access</string>

    <!-- Title for the See more preference item in Special app access settings [CHAR LIMIT=30] -->
    <string name="special_access_more">See more</string>

    <!-- Label for the settings activity for controlling apps that can run long background tasks [CHAR LIMIT=30] -->
    <string name="long_background_tasks_label">Long background tasks</string>
    <!-- Label for the switch to toggle the permission for running long background tasks [CHAR LIMIT=50] -->
    <string name="long_background_tasks_switch_title">Allow long-running background tasks</string>
    <!-- Title for the settings screen for controlling apps that can run long background tasks [CHAR LIMIT=30] -->
    <string name="long_background_tasks_title">Long background tasks</string>
    <!-- Description that appears below the long_background_tasks switch [CHAR LIMIT=NONE] -->
    <string name="long_background_tasks_footer_title">
        Allow this app to run long background tasks. This lets the app run tasks that might
        take longer than a few minutes to finish, such as downloads and uploads.
        \n\nIf this permission is denied, the system will limit how long the app can perform
        such tasks in the background.
    </string>
    <!-- Keywords for settings screen for controlling apps that can run long background tasks [CHAR LIMIT=NONE] -->
    <string name="keywords_long_background_tasks">long jobs, data transfer, background tasks</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 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 setting that changes the UI to dark -->
    <string name="dark_ui_mode">Dark theme</string>

    <!-- [CHAR LIMIT=60] Summary string on dark theme explaining why the toggle is disabled while the setting is still on-->
    <string name="dark_ui_mode_disabled_summary_dark_theme_on">Temporarily disabled due to Battery Saver</string>

    <!-- [CHAR LIMIT=60] Summary string for screen attention explaining why the toggle is disabled by battery saver-->
    <string name="ambient_camera_summary_battery_saver_on">Temporarily disabled due to Battery Saver</string>

    <!-- [CHAR LIMIT=60] Button text for screen attention to turn off battery saver-->
    <string name="ambient_camera_battery_saver_off">Turn off battery saver</string>

    <!-- [CHAR LIMIT=60] Summary string on dark theme explaining why the toggle is disabled while the setting is off-->
    <string name="dark_ui_mode_disabled_summary_dark_theme_off">Temporarily turned on due to Battery Saver</string>

    <!-- [CHAR_LIMIT=50] Title string in the dark theme slice(suggestion) -->
    <string name="dark_theme_slice_title">Try Dark theme</string>

    <!-- [CHAR_LIMIT=50] Subtitle string in the dark theme slice(suggestion) -->
    <string name="dark_theme_slice_subtitle">Helps extend battery life</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=50] Setting title to disable the adb authorization timeout feature. -->
    <string name="adb_authorization_timeout_title">Disable adb authorization timeout</string>
    <!-- [CHAR LIMIT=NONE] Setting summary explaining the disablement of the automatic adb authorization timeout. -->
    <string name="adb_authorization_timeout_summary">Disable automatic revocation of adb authorizations for systems that have not reconnected within the default (7 days) or user-configured (minimum 1 day) amount of time.</string>

    <!-- [CHAR LIMIT=25] Title of developer tile to toggle sensors -->
    <string name="sensors_off_quick_settings_title">Sensors Off</string>

    <!-- [CHAR LIMIT=60] Title of work profile setting page -->
    <string name="managed_profile_settings_title">Work profile settings</string>
    <!-- [CHAR LIMIT=NONE] Settings toggle. This setting lets a user's personal apps identify contacts using the user's work directory. -->
    <string name="managed_profile_contact_search_title">Search for work directory contacts in personal apps</string>
    <!-- [CHAR LIMIT=NONE] Settings toggle description. This setting lets a user's personal apps identify contacts using the user's work directory. "Searches" is a noun. -->
    <string name="managed_profile_contact_search_summary">Your searches and incoming calls may be visible to your IT admin</string>
    <!-- [CHAR LIMIT=NONE] Settings label. This setting lets the user show their work events on their personal calendar. The adjective 'Cross-profile' is referring to the work and personal profiles a user has on their phone. -->
    <string name="cross_profile_calendar_title">Cross-profile calendar</string>
    <!-- [CHAR LIMIT=NONE] Setting description. If the user turns on this setting, they can see their work events on their personal calendar. -->
    <string name="cross_profile_calendar_summary">Show work events on your personal calendar</string>
    <!-- [CHAR_LIMIT_NONE] Footer description. Explains to the user what will happen when work apps are turned off. -->
    <string name="managed_profile_settings_footer">When work apps are off, they’re paused and can’t be accessed or send you notifications</string>

    <!-- 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 [CHAR LIMIT=60] -->
    <string name="automatic_storage_manager_primary_switch_title">Use Storage manager</string>

    <!-- Preference title for gesture settings [CHAR LIMIT=40 BACKUP_MESSAGE_ID:5280023307132819052]-->
    <string name="gesture_preference_title">Gestures</string>

    <!-- Title text for double tap power for camera [CHAR LIMIT=60]-->
    <string name="double_tap_power_for_camera_title">Quickly open 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 text for double twist for camera mode [CHAR LIMIT=60]-->
    <string name="double_twist_for_camera_mode_title">Flip camera for selfie</string>

    <!-- Summary text for double twist for camera mode  [CHAR LIMIT=160]-->
    <string name="double_twist_for_camera_mode_summary"></string>

    <!-- Title text for system navigation [CHAR LIMIT=60] -->
    <string name="system_navigation_title">Navigation mode</string>

    <!-- Title text for swipe up to switch apps [CHAR LIMIT=60] -->
    <string name="swipe_up_to_switch_apps_title">2-button navigation</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. To see all apps, swipe up again. To go back, tap the back button.</string>

    <!-- Preference title for "Safety & emergency" settings page [CHAR LIMIT=60]-->
    <string name="emergency_settings_preference_title">Safety &amp; emergency</string>

    <!-- Summary for the top level Safety & emergency Settings [CHAR LIMIT=NONE]-->
    <string name="emergency_dashboard_summary">Emergency SOS, medical info, alerts</string>

    <!-- Title text for edge to edge navigation [CHAR LIMIT=60] -->
    <string name="edge_to_edge_navigation_title">Gesture navigation</string>
    <!-- Summary text for edge to edge navigation [CHAR LIMIT=NONE] -->
    <string name="edge_to_edge_navigation_summary">To go home, swipe up from the bottom of the screen. To switch apps, swipe up from the bottom, hold, then release. To go back, swipe from either the left or right edge.</string>

    <!-- Title text for 3-button navigation [CHAR LIMIT=60] -->
    <string name="legacy_navigation_title">3-button navigation</string>
    <!-- Summary text for 3-button navigation  [CHAR LIMIT=NONE] -->
    <string name="legacy_navigation_summary">Go back, Home, and switch apps with buttons at the bottom of your screen.</string>

    <!-- Search keywords for System Navigation settings. [CHAR_LIMIT=NONE]-->
    <string name="keywords_system_navigation">system navigation, 2 button navigation, 3 button navigation, gesture navigation, swipe</string>

    <!-- Title for setting category that is shown to enable invoking digital assistant with swipe. [CHAR LIMIT=60] -->
    <string name="assistant_gesture_category_title">Digital assistant</string>
    <!-- Title text for swiping from bottom corners to invoke the digital assistant app. [CHAR LIMIT=60] -->
    <string name="assistant_corner_gesture_title">Swipe to invoke assistant</string>
    <!-- Summary text for swiping from bottom corners to invoke the digital assistant app. [CHAR LIMIT=NONE] -->
    <string name="assistant_corner_gesture_summary">Swipe up from a bottom corner to invoke digital assistant app</string>

    <!-- Title text for holding a long press on Home button to invoke the digital assistant app. [CHAR LIMIT=60] -->
    <string name="assistant_long_press_home_gesture_title">Hold Home for Assistant</string>
    <!-- Summary text for holding a long press on Home button to invoke the digital assistant app. [CHAR LIMIT=NONE] -->
    <string name="assistant_long_press_home_gesture_summary">Press and hold the Home button to invoke digital assistant app.</string>

    <!-- Label on the left side of sensitivity adjustment slider [CHAR LIMIT=30] -->
    <string name="low_label">Low</string>
    <!-- Label on the right side of sensitivity adjustment slider [CHAR LIMIT=30] -->
    <string name="high_label">High</string>

    <!-- Label for the slider to set sensitivity of the left edge of the screen [CHAR LIMIT=40] -->
    <string name="left_edge">Left edge</string>
    <!-- Label for the slider to set sensitivity of the right edge of the screen [CHAR LIMIT=40] -->
    <string name="right_edge">Right edge</string>

    <!-- Message for the dialog that explains how increasing sensitivity can affect gestures along the edges. [CHAR LIMIT=NONE] -->
    <string name="back_sensitivity_dialog_message">Higher sensitivity may conflict with any app gestures along the edges of the screen.</string>

    <!-- Title for adjusting the back sensitivity, which is the sensitivity of the edge swipe that would trigger back navigation. [CHAR LIMIT=60] -->
    <string name="back_sensitivity_dialog_title">Back Sensitivity</string>

    <!-- Title for the screen to show all the gesture navigation settings [CHAR LIMIT=80] -->
    <string name="gesture_settings_activity_title">Gesture Navigation Sensitivity</string>

    <!-- Title for the screen to show all the 2- and 3-button navigation settings. [CHAR LIMIT=80] -->
    <string name="button_navigation_settings_activity_title">Button navigation</string>

    <!-- Keywords for the gesture navigation settings. [CHAR LIMIT=NONE] -->
    <string name="keywords_gesture_navigation_settings">gesture navigation, back sensitivity, back gesture</string>

    <!-- Keywords for the 2-/3-button navigation settings. [CHAR LIMIT=NONE] -->
    <string name="keywords_button_navigation_settings">navigation, home button</string>

    <!-- Preference and settings suggestion title text for one handed [CHAR LIMIT=60] -->
    <string name="one_handed_title">One-handed mode</string>
    <!-- Preference Switch for enabling one handed [CHAR LIMIT=60] -->
    <string name="one_handed_mode_enabled">Use one-handed mode</string>
    <!-- Title for accessibility shortcut preference for enabling one handed. [CHAR LIMIT=60] -->
    <string name="one_handed_mode_shortcut_title">One-handed mode shortcut</string>
    <!-- Search keywords for "One-Handed" settings [CHAR_LIMIT=NONE] -->
    <string name="keywords_one_handed">reachability</string>
    <!-- Category title for one handed swipe down [CHAR_LIMIT=60] -->
    <string name="one_handed_mode_swipe_down_category">Swipe down to</string>
    <!-- Category title for one handed use the shortcut [CHAR_LIMIT=60] -->
    <string name="one_handed_mode_use_shortcut_category">Use the shortcut to</string>
    <!-- One-handed mode intro Text [CHAR_LIMIT=NONE] -->
    <string name="one_handed_mode_intro_text">Pull down the top half of your screen so it\u2019s easier to reach with one hand</string>
    <!-- One-handed mode Intro Text [CHAR_LIMIT=NONE] -->
    <string name="one_handed_mode_footer_text">
        <b>How to use one-handed mode</b>\n
        • Make sure gesture navigation is selected in system navigation settings\n
        • Swipe down near the bottom edge of the screen
    </string>
    <!-- One-handed mode pull down screen into reach action title [CHAR_LIMIT=60] -->
    <string name="one_handed_action_pull_down_screen_title">Pull screen into reach</string>
    <!-- One-handed mode pull down screen into reach action title [CHAR_LIMIT=NONE] -->
    <string name="one_handed_action_pull_down_screen_summary">The top of the screen will move into reach of your thumb.</string>
    <!-- One-handed mode show notification action [CHAR_LIMIT=60] -->
    <string name="one_handed_action_show_notification_title">Show notifications</string>
    <!-- One-handed mode show notification action [CHAR_LIMIT=NONE] -->
    <string name="one_handed_action_show_notification_summary">Notifications and settings will appear.</string>
    <!-- One-handed mode Intro text for gesture navigation [CHAR_LIMIT=NONE] -->

    <!-- Summary text for ambient display double tap [CHAR LIMIT=NONE]-->
    <string name="ambient_display_summary">To check time, notifications, and other info, double-tap your screen.</string>

    <!-- Preference and settings suggestion title text for display wake-up gesture [CHAR LIMIT=60]-->
    <string name="ambient_display_wake_screen_title">Wake up display</string>

    <!-- Summary text for ambient display tap [CHAR LIMIT=NONE]-->
    <string name="ambient_display_tap_screen_summary">To check time, notifications, and other info, tap your screen.</string>

    <!-- Preference title to enable feature for calling emergency services at panic/distress moments[CHAR_LIMIT=60]-->
    <string name="emergency_gesture_screen_title">Emergency SOS</string>

    <!-- Preference title to enable feature for calling emergency services at panic/distress moments[CHAR_LIMIT=60]-->
    <string name="emergency_gesture_switchbar_title">Use Emergency SOS</string>

    <!-- Preference summary to enable feature for calling emergency services at panic/distress moments[CHAR_LIMIT=NONE]-->
    <string name="emergency_gesture_screen_summary">Press the Power button quickly 5 times or more to start the actions below</string>

    <!-- Preference title to enable generating noisy sound before calling emergency services at panic/distress moments[CHAR_LIMIT=60]-->
    <string name="emergency_gesture_sound_setting_title">Play countdown alarm</string>

    <!-- Preference summary to enable generating noisy sound before calling emergency services at panic/distress moments[CHAR_LIMIT=NONE]-->
    <string name="emergency_gesture_sound_setting_summary">Play a loud sound when Emergency SOS is starting</string>

    <!-- Preference category title listing a phone number to call during emergency gesture [CHAR_LIMIT=60]-->
    <string name="emergency_gesture_category_call_for_help_title">Notify for help</string>

    <!-- Preference title listing a phone number to call during emergency gesture [CHAR_LIMIT=60]-->
    <string name="emergency_gesture_call_for_help_title">Call for help</string>

    <!-- Preference title listing a phone number to call during emergency gesture [CHAR_LIMIT=NONE]-->
    <string name="emergency_gesture_call_for_help_dialog_title">Number to call for help</string>

    <!-- Preference summary listing a phone number to call during emergency gesture, and clicking the perference will show a dialog to change this number [CHAR_LIMIT=NONE]-->
    <string name="emergency_gesture_call_for_help_summary"><xliff:g id="phone_number" example="911">%1$s</xliff:g>. Tap to change</string>

    <!-- Notes explaining limitations for emergency gesture number override [CHAR_LIMIT=NONE]-->
    <string name="emergency_gesture_number_override_notes">
        If you enter a non-emergency number:\n
        • Your device must be unlocked to use Emergency SOS\n
        • Your call may not be answered
    </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>

    <!-- Title for settings suggestion for fingerprint swipe for notifications [CHAR LIMIT=60] -->
    <string name="fingerprint_swipe_for_notifications_suggestion_title">See notifications quickly</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 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>

    <!-- Switch label to enable auto sync account [CHAR LIMIT=60] -->
    <string name="auto_sync_account_title">Automatically sync app 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] -->
    <string name="enterprise_privacy_number_packages_lower_bound">{count, plural,
      =1      {Minimum # app}
      other   {Minimum # apps}
    }</string>
    <!-- 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] -->
    <string name="enterprise_privacy_number_packages">{count, plural,
      =1      {# app}
      other   {# apps}
    }</string>
    <!-- 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] -->
    <string name="enterprise_privacy_number_ca_certs">{count, plural,
      =1      {Minimum # CA certificate}
      other   {Minimum # CA certificates}
    }</string>
    <!-- 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] -->
    <string name="enterprise_privacy_number_failed_password_wipe">{count, plural,
      =1      {# attempt}
      other   {# attempts}
    }</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>
    <!--Title for dialog displayed to tell user that settings are blocked by setting restrictions [CHAR LIMIT=50] -->
    <string name="blocked_by_restricted_settings_title">Restricted setting</string>
    <!--Toast message shown after the user successfully allows restricted settings [CHAR LIMIT=50] -->
    <string name="toast_allows_restricted_settings_successfully">Restricted settings allowed for <xliff:g id="app_name" example="Gmail">%s</xliff:g></string>
    <!--Content for dialog displayed to tell user that settings are blocked by setting restrictions [CHAR LIMIT=100] -->
    <string name="blocked_by_restricted_settings_content">For your security, this setting is currently unavailable.</string>

    <!-- Financed device Privacy --> <skip />

    <!-- Title of setting on security settings screen on a financed device. This will take the user to a screen with information about what a device administrator can control and their impact on the user's privacy on a financed device. Shown on financed-managed devices only. [CHAR LIMIT=NONE] -->
    <string name="financed_privacy_settings">Financed device info</string>
    <!-- Top introduction on the financed device privacy settings, summarizing the changes a credit provider can make to a financed device. [CHAR LIMIT=NONE] -->
    <string name="financed_privacy_intro">Your credit provider can change settings and install software on this device during setup.\n\nIf you miss a payment, your credit provider can lock your device and change device settings.\n\nTo learn more, contact your credit provider.</string>
    <!-- Section header. This section shows what restrictions will be enforced on the device when it is financed. [CHAR LIMIT=60] -->
    <string name="financed_privacy_restrictions_category">If your device is financed, you can\u2019t:</string>
    <!-- Label explaining that installing apps from unknown sources beyond Play Store. [CHAR LIMIT=60]-->
    <string name="financed_privacy_install_apps">Install apps from outside the Play Store</string>
    <!-- Label explaining that rebooting the device into safe mode. [CHAR LIMIT=60]-->
    <string name="financed_privacy_safe_mode">Reboot your device into safe mode</string>
    <!-- Label explaining that adding more than one user into the device. [CHAR LIMIT=60]-->
    <string name="financed_privacy_multi_users">Add multiple users to your device</string>
    <!-- Label explaining that updating the date and time on the device. [CHAR LIMIT=60] -->
    <string name="financed_privacy_config_date_time">Change date, time, and time zones</string>
    <!-- Label explaining that turning on the developer options on the device. [CHAR LIMIT=40]-->
    <string name="financed_privacy_developer_options">Use developer options</string>
    <!-- Section header. This section shows how credit provider would control the device. [CHAR LIMIT=40]-->
    <string name="financed_privacy_credit_provider_capabilities_category">Your credit provider can:</string>
    <!-- Label explaining that IMEI can be access by the credit provider. [CHAR LIMIT=40] -->
    <string name="financed_privacy_IMEI">Access your IMEI number</string>
    <!-- Label explaining that device can be reset and data can be deleted. [CHAR LIMIT=80]-->
    <string name="financed_privacy_factory_reset">Factory reset your device if something goes wrong</string>
    <!-- Section header. This section shows what the user can do if the device is locked by the credit provider. [CHAR LIMIT=100] -->
    <string name="financed_privacy_locked_mode_category">If your device is locked, you can only use it to:</string>
    <!-- Label explaining that calling emergency numbers. [CHAR LIMIT=40]-->
    <string name="financed_privacy_emergency_calls">Make emergency calls</string>
    <!-- Label explaining that access basic system level data including date, time, network status, and battery info. [CHAR LIMIT=100]-->
    <string name="financed_privacy_system_info">View system info like date, time, network status, and battery</string>
    <!-- Label explaining that powering on or off the device. [CHAR LIMIT=60]-->
    <string name="financed_privacy_turn_on_off_device">Turn your device on or off</string>
    <!-- Label explaining that accessing notifications and text messages. [CHAR LIMIT=60]-->
    <string name="financed_privacy_notifications">View notifications &amp; text messages</string>
    <!-- Label explaining that using apps that are allowed to be used by the credit provider when the device is locked. [CHAR LIMIT=100]-->
    <string name="financed_privacy_allowlisted_apps">Access apps that are allowed by the credit provider</string>
    <!-- Section header. This sections shows what would happen if the device is fully paid. [CHAR LIMIT=60] -->
    <string name="financed_privacy_fully_paid_category">Once you pay the full amount:</string>
    <!-- Label explaining that all previously restrictions enforce by the credit provider will be revoked. [CHAR LIMIT=100]-->
    <string name="financed_privacy_restrictions_removed">All restrictions are removed from the device</string>
    <!-- Label explaining that the app installed by credit provider can be uninstalled. [CHAR LIMIT=60]-->
    <string name="financed_privacy_uninstall_creditor_app">You can uninstall the creditor app</string>
    <!-- Title of setting on security settings screen on a device provisioned by Device Lock. This will take the user to a screen in Device Lock with information about what a device provider can control and their impact on the user's privacy. Shown on Device Lock provisioned devices only. [CHAR LIMIT=NONE] -->
    <string name="financed_device_info">Financed device info</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] -->
    <string name="default_camera_app_title">{count, plural,
      =1      {Camera app}
      other   {Camera apps}
    }</string>
    <!-- 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] -->
    <string name="default_email_app_title">{count, plural,
      =1      {Email client app}
      other   {Email client apps}
    }</string>
    <!-- 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] -->
    <string name="default_phone_app_title">{count, plural,
      =1      {Phone app}
      other   {Phone apps}
    }</string>
    <!-- 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>

    <!-- Storage Settings dropdown option of default internal storage [CHAR LIMIT=30] -->
    <string name="storage_default_internal_storage">This device</string>

    <!-- Preference label for the Games storage section. [CHAR LIMIT=50] -->
    <string name="storage_games">Games</string>

    <!-- Preference label for the Files storage section. [CHAR LIMIT=50] -->
    <string name="storage_files">Files</string>

    <!-- Preference label for the Images storage section. [CHAR LIMIT=50] -->
    <string name="storage_images">Images</string>

    <!-- Preference label for the Videos storage section. [CHAR LIMIT=50] -->
    <string name="storage_videos">Videos</string>

    <!-- Preference label for the Audio storage section. [CHAR LIMIT=50] -->
    <string name="storage_audio">Audio</string>

    <!-- Preference label for the Apps storage section. [CHAR LIMIT=50] -->
    <string name="storage_apps">Apps</string>

    <!-- Preference label for the Documents & other storage section. [CHAR LIMIT=50] -->
    <string name="storage_documents_and_other">Documents &amp; other</string>

    <!-- Preference label for the System storage section. [CHAR LIMIT=50] -->
    <string name="storage_system">System</string>

    <!-- Preference label for the Trash storage section. [CHAR LIMIT=50] -->
    <string name="storage_trash">Trash</string>

    <!-- Dialog title for the Trash storage section. [CHAR LIMIT=50] -->
    <string name="storage_trash_dialog_title">Empty trash?</string>

    <!-- Dialog message for the Trash storage section. [CHAR LIMIT=NONE] -->
    <string name="storage_trash_dialog_ask_message">There are <xliff:g id="total" example="520MB">%1$s</xliff:g> of files in the trash. All items will be deleted forever, and you won\u2019t be able to restore them.</string>

    <!-- Dialog message for the Trash storage section. [CHAR LIMIT=NONE] -->
    <string name="storage_trash_dialog_empty_message">Trash is empty</string>

    <!-- Dialog confirm button to empty all trash files. [CHAR LIMIT=50] -->
    <string name="storage_trash_dialog_confirm">Empty trash</string>

    <!-- Summary of a single storage volume used space. [CHAR LIMIT=24] -->
    <string name="storage_usage_summary"><xliff:g id="number" example="128">%1$s</xliff:g> <xliff:g id="unit" example="KB">%2$s</xliff:g> used</string>
    <!-- Summary of a single storage volume total space. [CHAR LIMIT=24] -->
    <string name="storage_total_summary"><xliff:g id="number" example="128">%1$s</xliff:g> <xliff:g id="unit" example="KB">%2$s</xliff:g> total</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 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>
    <!-- Preference label for choosing auto-fill service. [CHAR LIMIT=60] -->
    <string name="default_autofill_app">Default autofill service</string>
    <!-- Preference category for showing auto-fill services with saved passwords. [CHAR LIMIT=60] -->
    <string name="autofill_passwords">Passwords</string>
    <!-- Preference category for showing autofill and credman services with saved credentials. [CHAR LIMIT=60] -->
    <string name="credman_chosen_app_title">Preferred service</string>
    <!-- Preference category for showing additional credential services. [CHAR LIMIT=60] -->
    <string name="credman_credentials">Additional services</string>
    <!-- Summary for passwords settings that shows how many passwords are saved for each autofill
         service. [CHAR LIMIT=NONE] -->
    <string name="autofill_passwords_count">{count, plural,
      =1      {# password}
      other   {# passwords}
    }</string>
    <!-- DO NOT TRANSLATE Summary placeholder for when the passwords count is still loading or is
         unavailable. -->
    <string name="autofill_passwords_count_placeholder" translatable="false">\u2014</string>
    <!-- Keywords for the auto-fill feature. [CHAR LIMIT=NONE] -->
    <string name="autofill_keywords">auto, fill, autofill, password</string>
    <!-- Keywords for the credman feature. [CHAR LIMIT=NONE] -->
    <string name="credman_keywords">data, passkey, password</string>
    <!-- Keywords for the credman feature. [CHAR LIMIT=NONE] -->
    <string name="credman_autofill_keywords">auto, fill, autofill, data, passkey, password</string>
    <!-- Button for choosing credman service. [CHAR LIMIT=40] -->
    <string name="credman_button_change">Change</string>
    <!-- Button for opening credman service settings. [CHAR LIMIT=40] -->
    <string name="credman_button_open">Open</string>
    <!-- Label for None item in Credential Manager service selection [CHAR LIMIT=40] -->
    <string name="credman_app_list_preference_none">None selected</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>

    <!-- Message of the warning dialog for setting the auto-fill/credman app. [CHAR_LIMIT=NONE] -->
    <string name="credman_autofill_confirmation_message">
        <![CDATA[
        <b>Use <xliff:g id="app_name" example="Provider">%1$s</xliff:g>\?</b>
        <br/>
        <br/>
        New passwords, passkeys, and other info will be saved here from now on.
        <xliff:g id="app_name" example="Provider">%1$s</xliff:g> may use what\'s on your
        screen to determine what can be autofilled.
        ]]>
    </string>

    <!-- Title of the screen where the user picks a provider. [CHAR_LIMIT=NONE] -->
    <string name="credman_picker_title">Preferred service for passwords, passkeys &amp; autofill</string>

    <!-- Title of the warning dialog for disabling the credential provider. [CHAR_LIMIT=NONE] -->
    <string name="credman_confirmation_message_title">Turn off %1$s\?</string>

    <!-- Message of the warning dialog for disabling the credential provider. [CHAR_LIMIT=NONE] -->
    <string name="credman_confirmation_message">
        <![CDATA[
        <b>Turn off this service?</b>
        <br/>
        <br/>
        Saved info like passwords, passkeys, payment methods, and other info won\'t be filled
        in when you sign in. To use your saved info, choose a password, passkey, or data
        service.
        ]]>
    </string>

    <!-- Title for setting tile leading to saved autofill passwords, passkeys, autofill, and account settings [CHAR LIMIT=40]-->
    <string name="account_dashboard_title_with_passkeys">Passwords, passkeys &amp; autofill</string>

    <!-- Message of the warning dialog for disabling the credential provider (new strings for 24Q3). [CHAR_LIMIT=NONE] -->
    <string name="credman_confirmation_message_new_ui">
        <![CDATA[
        <b>Turn off all services?</b>
        <br/>
        <br/>
        Passwords, passkeys, and other saved info won\'t be available for autofill when you sign in
        ]]>
    </string>

    <!-- Message of the warning dialog for setting a new preferred credential provider (new strings for 24Q3). [CHAR_LIMIT=NONE] -->
    <string name="credman_autofill_confirmation_message_new_ui">
        <![CDATA[
        <b>Change your preferred service to <xliff:g id="app_name" example="Provider">%1$s</xliff:g>\?</b>
        <br/>
        <br/>
        New passwords, passkeys, and other info will be saved here from now on.
        <xliff:g id="app_name" example="Provider">%1$s</xliff:g> may use what\'s on your
        screen to determine what can be autofilled
        ]]>
    </string>

    <!-- Title of the warning dialog for enabling the credential provider. [CHAR_LIMIT=NONE] -->
    <string name="credman_enable_confirmation_message_title">Use %1$s\?</string>

    <!-- Positive button text for disabling credential manager. [CHAR_LIMIT=30] -->
    <string name="credman_confirmation_turn_off_positive_button">Turn off</string>

    <!-- Positive button text for changing credential manager provider. [CHAR_LIMIT=30] -->
    <string name="credman_confirmation_change_provider_positive_button">Change</string>

    <!-- Title of the error dialog when too many credential providers are selected (new strings for 24Q3). [CHAR_LIMIT=NONE] -->
    <string name="credman_limit_error_msg_title">You can only have 5 services on</string>

    <!-- Message of the error dialog when too many credential providers are selected (new strings for 24Q3). [CHAR_LIMIT=NONE] -->
    <string name="credman_limit_error_msg">Turn off at least 1 service to add another</string>

    <!-- Message of the warning dialog for enabling the credential provider. [CHAR_LIMIT=NONE] -->
    <string name="credman_enable_confirmation_message">%1$s uses what\'s on your screen to determine what can be autofilled.</string>

    <!-- Title of the error dialog when too many credential providers are selected. [CHAR_LIMIT=NONE] -->
    <string name="credman_error_message_title">Passwords, passkeys, and data services limit</string>

    <!-- Message of the error dialog when too many credential providers are selected. [CHAR_LIMIT=NONE] -->
    <string name="credman_error_message">You can have up to 5 passwords, passkeys, and data services active at the same time. Turn off a service to add more.</string>

    <!-- Positive button to turn off credential manager provider (confirmation). [CHAR LIMIT=60] -->
    <string name="credman_confirmation_message_positive_button">Turn off</string>

    <!-- Preference category for autofill debugging development settings. [CHAR LIMIT=25] -->
    <string name="debug_autofill_category">Autofill</string>

    <!-- UI debug setting: logging level for Android Autofill [CHAR LIMIT=25] -->
    <string name="autofill_logging_level_title">Logging level</string>

    <!-- Title of developer options to set the maximum number of requests per session [CHAR LIMIT=60]-->
    <string name="autofill_max_partitions">Max requests per session</string>

    <!-- Title of developer options to set the maximum number of visible datasets in the autofill UX [CHAR LIMIT=60]-->
    <string name="autofill_max_visible_datasets">Max visible datasets</string>

    <!-- Reset all autofill developer options to their default values.[CHAR_LIMIT=60] -->
    <string name="autofill_reset_developer_options">Reset to default values</string>

    <!-- Toast message shown when autofill_reset_developer_options has been performed. [CHAR_LIMIT=none] -->
    <string name="autofill_reset_developer_options_complete">Autofill developer options have been reset</string>

    <!-- Developer options location category strings -->
    <!-- Title for privacy category [CHAR LIMIT=30]-->
    <string name="location_category">Location</string>
    <!-- [CHAR LIMIT=130] Title for location indicator settings -->
    <string name="location_indicator_settings_title">Status bar location indicator</string>
    <!-- [CHAR LIMIT=130] Description for location indicator settings -->
    <string name="location_indicator_settings_description">Show for all locations, including network and connectivity</string>

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

    <!-- Developer options Input method category strings -->
    <!-- Title for input method category [CHAR LIMIT=30]-->
    <string name="input_method_category">Input Method</string>
    <!-- [CHAR LIMIT=30] Title for Stylus handwriting settings -->
    <string name="stylus_handwriting">Stylus handwriting</string>
    <!-- [CHAR LIMIT=130] Summary for Stylus handwriting toggle -->
    <string name="stylus_handwriting_summary">When enabled, current Input method receives stylus MotionEvent if an Editor is focused.</string>

    <!-- Name of setting for switching device theme [CHAR LIMIT=60] -->
    <string name="device_theme">Device 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>

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

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

    <!-- Help URI, USB Audio [DO NOT TRANSLATE] -->
    <string name="help_url_audio_accessory_not_supported" translatable="false"></string>

    <!-- Help URI, USB Contaminant [DO NOT TRANSLATE] -->
    <string name="help_url_usb_contaminant_detected" translatable="false"></string>

    <!-- Help URI, restricted apps page [DO NOT TRANSLATE] -->
    <string name="help_uri_restricted_apps" translatable="false"></string>

    <!-- Help URI, auto rotate page [DO NOT TRANSLATE] -->
    <string name="help_url_auto_rotate_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>

    <!-- Help URI, action disabled by restricted settings [DO NOT TRANSLATE] -->
    <string name="help_url_action_disabled_by_restricted_settings" 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>

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

    <!-- Title of a message for an empty state screen. A user will see this message if they try to use a certain feature, but the feature was turned off so it won't slow down their phone. [CHAR LIMIT=NONE] -->
    <string name="disabled_feature">Feature not available</string>
    <!-- Part of a message for an empty state screen. A user will see this message if they try to use a certain feature, but the feature was turned off so it won't slow down their phone. [CHAR LIMIT=NONE] -->
    <string name="disabled_feature_reason_slow_down_phone">This feature has been turned off because it slows down your phone</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>

    <!-- UI debug setting: select current app to use ANGLE [CHAR LIMIT=100] -->
    <string name="angle_enabled_app">Select ANGLE enabled app</string>
    <!-- UI debug setting: no ANGLE enabled app has been set [CHAR LIMIT=100] -->
    <string name="angle_enabled_app_not_set">No ANGLE enabled application set</string>
    <!-- UI debug setting: ANGLE enabled app has been set [CHAR LIMIT=NONE] -->
    <string name="angle_enabled_app_set">ANGLE enabled application: <xliff:g id="app_name" example="com.company.app">%1$s</xliff:g></string>

    <!-- Title for graphics driver dashboard where developers can configure apps to choose graphics driver [CHAR LIMIT=50] -->
    <string name="graphics_driver_dashboard_title">Graphics Driver Preferences</string>
    <!-- Summary for graphics driver dashboard [CHAR LIMIT=50] -->
    <string name="graphics_driver_dashboard_summary">Modify graphics driver settings</string>
    <!-- Footer text for graphics driver dashboard [CHAR LIMIT=NONE] -->
    <string name="graphics_driver_footer_text">When there are multiple graphics drivers, you can pick to use the updated graphics driver for Apps installed on the device.</string>
    <!-- Title for graphics Driver all apps preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_all_apps_preference_title">Enable for all apps</string>
    <!-- Title for graphics driver preference for app [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_title">Select Graphics Driver</string>
    <!-- The default value of graphics driver preference for app [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_default">Default</string>
    <!-- The value for updatable production driver app preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_production_driver">Game Driver</string>
    <!-- The value for updatable developer driver app preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_prerelease_driver">Developer Driver</string>
    <!-- The system driver value for system graphics driver app preference [CHAR LIMIT=50] -->
    <string name="graphics_driver_app_preference_system">System Graphics Driver</string>
    <!-- All the graphics driver preference values for all apps globally [CHAR LIMIT=50] -->
    <string-array name="graphics_driver_all_apps_preference_values">
        <item>@string/graphics_driver_app_preference_default</item>
        <item>@string/graphics_driver_app_preference_production_driver</item>
        <item>@string/graphics_driver_app_preference_prerelease_driver</item>
    </string-array>
    <!-- All the values of graphics driver for app preference [CHAR LIMIT=50] -->
    <string-array name="graphics_driver_app_preference_values">
        <item>@string/graphics_driver_app_preference_default</item>
        <item>@string/graphics_driver_app_preference_prerelease_driver</item>
        <item>@string/graphics_driver_app_preference_production_driver</item>
        <item>@string/graphics_driver_app_preference_system</item>
    </string-array>

    <!-- Debugging developer settings: enable angle as system driver? [CHAR LIMIT=50] -->
    <string name="enable_angle_as_system_driver">Experimental: Enable ANGLE</string>
    <!-- Debugging developer settings: enable angle as system driver summary [CHAR LIMIT=NONE] -->
    <string name="enable_angle_as_system_driver_summary">Warning: Enable ANGLE as default OpenGL ES driver. This feature is in experiment and may not be compatible with some camera and video apps.</string>
    <!--Dialog body text used to explain a reboot is required after changing ANGLE as system GLES driver setting-->
    <string name="reboot_dialog_enable_angle_as_system_driver">A reboot is required to change the system OpenGL ES driver</string>

    <!-- Title for App Compatibility Changes dashboard where developers can configure per-app overrides for compatibility changes [CHAR LIMIT=50] -->
    <string name="platform_compat_dashboard_title">App Compatibility Changes</string>
    <!-- Summary for App Compatibility Changes dashboard [CHAR LIMIT=NONE] -->
    <string name="platform_compat_dashboard_summary">Toggle app compatibility changes</string>
    <!-- Summary for selected app [DO NOT TRANSLATE] -->
    <string name="platform_compat_selected_app_summary" translatable="false"><xliff:g id="app_name" example="com.google.android.chrome">%1$s</xliff:g> targetSdkVersion <xliff:g id="number" example="29">%2$d</xliff:g></string>
    <!-- Title for default enabled app compat changes category [CHAR LIMIT=50] -->
    <string name="platform_compat_default_enabled_title">Default enabled changes</string>
    <!-- Title for default disabled app compat changes category [CHAR LIMIT=50] -->
    <string name="platform_compat_default_disabled_title">Default disabled changes</string>
    <!-- Title for target SDK gated app compat changes category (do not translate 'targetSdkVersion') [CHAR LIMIT=50] -->
    <string name="platform_compat_target_sdk_title">Enabled for targetSdkVersion &gt;= <xliff:g id="number" example="29">%d</xliff:g></string>
    <!-- Explanatory text shown when no debuggable apps are available [CHAR LIMIT=NONE] -->
    <string name="platform_compat_dialog_text_no_apps">App compatibility changes can only be modified for debuggable apps. Install a debuggable app and try again.</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>

    <!-- 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>
    <!-- Summary for preference showing the number of the accounts. [CHAR LIMIT=NONE]-->
    <string name="my_device_info_account_preference_summary">%d accounts</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>

    <!-- Title for preference category showing the name of basic info. [CHAR LIMIT=60]-->
    <string name="my_device_info_basic_info_category_title">Basic info</string>
    <!-- Title for preference category showing the name of legal & regulatory. [CHAR LIMIT=60]-->
    <string name="my_device_info_legal_category_title">Legal &amp; regulatory</string>
    <!-- Title for preference category showing the name of device details. [CHAR LIMIT=60]-->
    <string name="my_device_info_device_details_category_title">Device details</string>
    <!-- Title for preference category showing the name of device identifiers. [CHAR LIMIT=60]-->
    <string name="my_device_info_device_identifiers_category_title">Device identifiers</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 Launch via NFC [CHAR LIMIT=35] -->
    <string name="change_nfc_tag_apps_title">Launch via NFC</string>

    <!-- Special app access > Launch via NFC > Switch title. [CHAR LIMIT=NONE] -->
    <string name="change_nfc_tag_apps_detail_switch">Allow launch on NFC scan</string>

    <!-- Special app access > Launch via NFC > Description. [CHAR LIMIT=NONE] -->
    <string name="change_nfc_tag_apps_detail_summary">Allow this app to launch when an NFC tag is scanned.\nIf this permission is on, the app will be available as an option whenever a tag is detected.</string>

    <!-- Title for media output settings -->
    <string name="media_output_title">Play media to</string>

    <!-- Title with application label for media output settings. [CHAR LIMIT=NONE] -->
    <string name="media_output_label_title">Play <xliff:g id="label" example="Music Player">%s</xliff:g> on</string>

    <!-- Title for media output settings without media is playing -->
    <string name="media_output_title_without_playing">Audio will play on</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 when device is in ongoing call state. -->
    <string name="media_out_summary_ongoing_call_state">Unavailable during calls</string>

    <!-- Title for HFP(hands free profile) output switch button in settings. -->
    <string name="take_call_on_title">Take call on</string>

    <!-- Toast that appears when users tap an APN for which parameters cannot be viewed. [CHAR LIMIT=NONE] -->
    <string name="cannot_change_apn_toast">This APN cannot be changed.</string>

    <!-- Title for prevent ringing gesture screen [CHAR LIMIT=60]-->
    <string name="gesture_prevent_ringing_screen_title">Prevent ringing</string>
    <!-- Title for prevent ringing setting [CHAR LIMIT=60]-->
    <string name="gesture_prevent_ringing_title">Press Power &amp; Volume Up together to</string>
    <!-- Title for prevent ringing setting [CHAR LIMIT=60]-->
    <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>
    <!-- Summary for prevent ringing setting -->
    <string name="prevent_ringing_option_vibrate_summary">Vibrate</string>
    <!-- Summary for prevent ringing setting -->
    <string name="prevent_ringing_option_mute_summary">Mute</string>
    <!-- Summary for prevent ringing setting when the option itself is unavailable. [CHAR LIMIT=NONE] -->
    <string name="prevent_ringing_option_unavailable_lpp_summary">To enable, first change \"Press &amp; hold power button\" to the power menu.</string>

    <!-- Title for detail page of wifi network [CHAR LIMIT=30] -->
    <string name="pref_title_network_details">Network details</string>

    <!-- Title for Connected device shortcut [CHAR LIMIT=30] -->
    <string name="devices_title">Devices</string>

    <!-- Available networks screen, name of button when user wants to select network manually [CHAR LIMIT=60] -->
    <string name="choose_network_title">Choose network</string>
    <!-- Available networks screen, text when no networks connected [CHAR LIMIT=60] -->
    <string name="network_disconnected">Disconnected</string>
    <!-- Available networks screen, text when network connected [CHAR LIMIT=60] -->
    <string name="network_connected">Connected</string>
    <!-- Available networks screen, text when a network is connecting [CHAR LIMIT=60] -->
    <string name="network_connecting">Connecting\u2026</string>
    <!-- Available networks screen, text when a network cannot be connected [CHAR LIMIT=60] -->
    <string name="network_could_not_connect">Couldn\u2019t connect</string>
    <!-- Available networks screen, text when no networks are found [CHAR LIMIT=NONE] -->
    <string name="empty_networks_list">No networks found.</string>
    <!-- Available networks screen, toast when an error is encountered when searching for networks [CHAR LIMIT=NONE] -->
    <string name="network_query_error">Couldn\u2019t find networks. Try again.</string>
    <!-- Text to show this network is forbidden [CHAR LIMIT=NONE] -->
    <string name="forbidden_network">(forbidden)</string>

    <!-- A title for a SIM card spinner UI component which users can choose a SIM card. [CHAR LIMIT=NONE] -->
    <string name="sim_card">SIM</string>
    <!-- A label when there is no SIM card to choose. [CHAR LIMIT=NONE] -->
    <string name="wifi_no_sim_card">No SIM</string>
    <!-- A label when there is no SIM card information of a Wi-Fi network. [CHAR LIMIT=NONE] -->
    <string name="wifi_no_related_sim_card">None</string>
    <!-- A label wen a user needs a SIM to connect to the Wi-Fi network. [CHAR LIMIT=NONE] -->
    <string name="wifi_require_sim_card_to_connect">Requires SIM to connect</string>
    <!-- A label wen a user needs a specific SIM to connect to the Wi-Fi network. [CHAR LIMIT=NONE] -->
    <string name="wifi_require_specific_sim_card_to_connect">Requires <xliff:g id="wireless_carrier" example="Verizon">%s</xliff:g> SIM to connect</string>

    <!-- The following strings are summaries for preferred network modes in Mobile network settings,
     and have a character limit of 100 -->
    <!-- WCDMA preferred [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_wcdma_perf_summary">Preferred network mode: WCDMA preferred</string>
    <!-- GSM only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_gsm_only_summary">Preferred network mode: GSM only</string>
    <!-- WCDMA only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_wcdma_only_summary">Preferred network mode: WCDMA only</string>
    <!-- GSM / WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_gsm_wcdma_summary">Preferred network mode: GSM / WCDMA</string>
    <!-- CDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_summary">Preferred network mode: CDMA</string>
    <!-- CDMA / EvDo [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_evdo_summary">Preferred network mode: CDMA / EvDo</string>
    <!-- CDMA only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_only_summary">Preferred network mode: CDMA only</string>
    <!-- EvDo only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_evdo_only_summary">Preferred network mode: EvDo only</string>
    <!-- CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary">Preferred network mode: CDMA/EvDo/GSM/WCDMA</string>
    <!-- LTE [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_summary">Preferred network mode: LTE </string>
    <!-- GSM/WCDMA/LTE [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_gsm_wcdma_summary">Preferred network mode: GSM/WCDMA/LTE</string>
    <!-- CDMA+LTE/EVDO [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_cdma_evdo_summary">Preferred network mode: CDMA+LTE/EVDO</string>
    <!-- LTE/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary">Preferred network mode: LTE/CDMA/EvDo/GSM/WCDMA</string>
    <!-- Global [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_global_summary">Preferred network mode: Global</string>
    <!-- LTE / WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_wcdma_summary">Preferred network mode: LTE / WCDMA</string>
    <!-- LTE / GSM / UMTS [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_gsm_umts_summary">Preferred network mode: LTE / GSM / UMTS</string>
    <!-- LTE / CDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_cdma_summary">Preferred network mode: LTE / CDMA</string>
    <!-- TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_summary">Preferred network mode: TDSCDMA</string>
    <!-- TDSCDMA / WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_wcdma_summary">Preferred network mode: TDSCDMA / WCDMA</string>
    <!-- LTE / TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_summary">Preferred network mode: LTE / TDSCDMA</string>
    <!-- TDSCDMA / GSM [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_gsm_summary">Preferred network mode: TDSCDMA / GSM</string>
    <!-- LTE/GSM/TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary">Preferred network mode: LTE/GSM/TDSCDMA</string>
    <!-- TDSCDMA/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary">Preferred network mode: TDSCDMA/GSM/WCDMA</string>
    <!-- LTE/TDSCDMA/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary">Preferred network mode: LTE/TDSCDMA/WCDMA</string>
    <!-- LTE/TDSCDMA/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary">Preferred network mode: LTE/TDSCDMA/GSM/WCDMA</string>
    <!-- TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary">Preferred network mode: TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>
    <!-- LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary">Preferred network mode: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>
    <!-- NR only [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_only_summary">Preferred network mode: NR only</string>
    <!-- NR / LTE [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_summary">Preferred network mode: NR / LTE</string>
    <!-- NR/LTE/CDMA/EvDo [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary">Preferred network mode: NR/LTE/CDMA/EvDo</string>
    <!-- NR/LTE/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary">Preferred network mode: NR/LTE/GSM/WCDMA</string>
    <!-- NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary">Preferred network mode: NR/LTE/CDMA/EvDo/GSM/WCDMA</string>
    <!-- NR/LTE/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_wcdma_summary">Preferred network mode: NR/LTE/WCDMA</string>
    <!-- NR/LTE/TDSCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_summary">Preferred network mode: NR/LTE/TDSCDMA</string>
    <!-- NR/LTE/TDSCDMA/GSM [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary">Preferred network mode: NR/LTE/TDSCDMA/GSM</string>
    <!-- NR/LTE/TDSCDMA/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary">Preferred network mode: NR/LTE/TDSCDMA/WCDMA</string>
    <!-- NR/LTE/TDSCDMA/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary">Preferred network mode: NR/LTE/TDSCDMA/GSM/WCDMA</string>
    <!-- NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary">Preferred network mode: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</string>

    <!-- Text for Network mode 5g recommended [CHAR LIMIT=NONE] -->
    <string name="network_5G_recommended">5G (recommended)</string>
    <!-- Text for Network lte [CHAR LIMIT=NONE] -->
    <string name="network_lte_pure" translatable="false">LTE</string>
    <!-- Text for Network 4g [CHAR LIMIT=NONE] -->
    <string name="network_4G_pure" translatable="false">4G</string>
    <!-- Text for Network lte [CHAR LIMIT=NONE] -->
    <string name="network_lte">LTE (recommended)</string>
    <!-- Text for Network 4g [CHAR LIMIT=NONE] -->
    <string name="network_4G">4G (recommended)</string>
    <!-- Text for Network 3g [CHAR LIMIT=NONE] -->
    <string name="network_3G" translatable="false">3G</string>
    <!-- Text for Network 2g [CHAR LIMIT=NONE] -->
    <string name="network_2G" translatable="false">2G</string>
    <!-- Text for Network 1x [CHAR LIMIT=NONE] -->
    <string name="network_1x" translatable="false">1x</string>
    <!-- Text for Network global [CHAR LIMIT=NONE] -->
    <string name="network_global" translatable="false">Global</string>
    <!-- Text for Network world mode CDMA LTE [CHAR LIMIT=NONE] -->
    <string name="network_world_mode_cdma_lte" translatable="false">LTE / CDMA</string>
    <!-- Text for Network world mode GSM LTE [CHAR LIMIT=NONE] -->
    <string name="network_world_mode_gsm_lte" translatable="false">LTE / GSM / UMTS</string>

    <!-- Available networks screen, name of switch button for whether to select network automatically [CHAR LIMIT=NONE] -->
    <string name="select_automatically">Automatically select network</string>

    <!-- A menu item in "Mobile network settings" that allows the user to update the phone
     with mobile operator specific settings. [CHAR LIMIT=25] -->
    <string name="carrier_settings_title">Carrier settings</string>
    <!-- Preference title for launching an account manager page for prepaid LTE [CHAR LIMIT=30] -->
    <string name="cdma_lte_data_service">Set up data service</string>
    <!-- Mobile network settings screen, title of Mobile Data switch preference [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_title">Mobile data</string>
    <!-- Mobile network settings screen, summary of Mobile data switch preference [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_summary">Access data using mobile network</string>
    <!-- Mobile network settings screen, summary of Mobile data switch preference when the network
         is opportunistic and will always be used when it is in range. [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_summary_auto_switch">
        Phone will automatically switch to this carrier when in range
    </string>
    <!-- Mobile network setting screen, summary of Mobile data switch preference when the network
         is unavailable, the preference selection will be disabled. [CHAR LIMIT=NONE] -->
    <string name="mobile_data_settings_summary_unavailable">No SIM available</string>

    <!-- Mobile network settings screen, title of item showing the name of the default subscription
     that will be used for calls. This only appears in multi-SIM mode. [CHAR LIMIT=NONE] -->
    <string name="calls_preference">Calls preference</string>
    <!-- Mobile network settings screen, title of item showing the name of the default subscription
     that will be used for SMS messages. This only appears in multi-SIM mode. [CHAR LIMIT=NONE] -->
    <string name="sms_preference">SMS preference</string>
    <!-- Mobile network settings screen, a label in a chooser dialog that appears when choosing the
    default subscription to use for either calls or SMS when in multi-SIM mode. This label means
    that the user will be asked which mobile network subscription to use every time they place a
    call or send an SMS, instead of defaulting to one particular subscription. [CHAR LIMIT=40]-->
    <string name="calls_and_sms_ask_every_time">Ask every time</string>

    <!-- Summary of the 'Mobile network' item on the Network & internet page when there is no mobile
         service setup yet (eg no SIM card inserted and no eSIM configured). Tapping it leads to a
         UI where the user can setup service. [CHAR LIMIT=50] -->
    <string name="mobile_network_summary_add_a_network">Add a network</string>

    <!-- Network & internet page. Summary indicating that a SIM is used by default for calls when
         multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_calls">Default for calls</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for SMS messages
         when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_sms">Default for SMS</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for calls and SMS
         messages when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_calls_and_sms">Default for calls &amp; SMS</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for mobile data
         when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="default_for_mobile_data">Default for mobile data</string>
    <!-- Network & internet page. Summary indicating that a SIM has an active mobile data connection
         when multiple SIMs are present. [CHAR LIMIT=50] -->
    <string name="mobile_data_active">Mobile data active</string>
    <!-- Network & internet page. Summary indicating that a SIM is used by default for mobile data
         when multiple SIMs are present, but mobile data is currently turned off.
         [CHAR LIMIT=50] -->
    <string name="mobile_data_off">Mobile data off</string>
    <!-- Network & internet page. Summary indicating that a SIM is available to be used for services
         such as calls, SMS, or data when multiple SIMs are present, but is not currently the
          default SIM for any of those services. [CHAR LIMIT=50] -->
    <string name="subscription_available">Available</string>

    <!-- Title of item shown at the bottom of the page listing multiple mobile service
         subscriptions; tapping it leads to a UI to add more SIMs [CHAR LIMIT=40] -->
    <string name="mobile_network_list_add_more">Add SIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is active and is tied to a physical SIM card [CHAR LIMIT=40] -->
    <string name="mobile_network_active_sim">Active / SIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is inactive and is tied to a physical SIM card [CHAR LIMIT=40] -->
    <string name="mobile_network_inactive_sim">Inactive / SIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is active and is tied to an eSIM profile [CHAR LIMIT=40] -->
    <string name="mobile_network_active_esim">Active / eSIM</string>
    <!-- Summary for an item in the page listing multiple mobile service subscriptions, indicating
         that service is inactive and is tied to an eSIM profile [CHAR LIMIT=40] -->
    <string name="mobile_network_inactive_esim">Inactive / eSIM</string>
    <!-- Title of a dialog that lets a user modify the display name used for a mobile network
         subscription in various places in the Settings app. The default name is typically just the
         carrier name, but especially in multi-SIM configurations users may want to use a different
         name. [CHAR LIMIT=40] -->
    <string name="mobile_network_sim_name">SIM name &amp; color</string>
    <!-- Label for an item listing the name of the SIM that the user has specified. [CHAR LIMIT=40] -->
    <string name="mobile_network_sim_name_label">Name</string>
    <!-- Label for an item listing the color of the SIM that the user has specified. [CHAR LIMIT=40] -->
    <string name="mobile_network_sim_color_label">Color (used by compatible apps)</string>
    <!-- Label on the confirmation button of a dialog that lets a user set the display name and
         color of a mobile network subscription [CHAR LIMIT=20] -->
    <string name="mobile_network_sim_name_rename">Save</string>
    <!-- Label for the on position of a switch on the mobile network details page which allows
         disabling/enabling a SIM. The SIM is enabled in this state. [CHAR LIMIT=40] -->
    <string name="mobile_network_use_sim_on">Use this SIM</string>
    <!-- Label for the off position of a switch on the mobile network details page which allows
         disabling/enabling a SIM. The SIM is disabled in this state. [CHAR LIMIT=40] -->
    <string name="mobile_network_use_sim_off">Off</string>
    <!-- Text shown in an information footer on the SIM details page for a physical SIM notifying
         the user that the way to disable this SIM is to physically remove it. This is in contrast
         to eSIM's, which can disabled using an on/off toggle switch. [CHAR LIMIT=NONE] -->
    <string name="mobile_network_disable_sim_explanation">
        To turn off this SIM, remove the SIM card
    </string>

    <!--Summary used when a physical SIM is disabled, indicating that tapping on the preference will
        enable the SIM. This may be used as the summary of the 'Mobile network' item on the
        Network & internet page (if there are no other SIMs), or on the mobile network list page.
        [CHAR LIMIT=50] -->
    <string name="mobile_network_tap_to_activate">
        Tap to activate your <xliff:g id="carrier" example="T-mobile">%1$s</xliff:g> SIM
    </string>

    <!-- Mobile network details page. Label for an option that lets the user delete an eSIM from
         the device. [CHAR LIMIT=60] -->
    <string name="mobile_network_erase_sim">Erase eSIM</string>

    <!-- Title for preferred network type [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_title">Preferred network type</string>
    <!-- Summary for preferred network type [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_summary">Change the network operating mode</string>
    <!-- Dialog title for preferred network type [CHAR LIMIT=NONE] -->
    <string name="preferred_network_mode_dialogtitle">Preferred network type</string>
    <!-- Mobile network settings screen, a string showing the version of carrier settings for this
         subscription [CHAR LIMIT=NONE] -->
    <string name="carrier_settings_version">Carrier settings version</string>

    <!-- Mobile network settings screen, name for call settings category [CHAR LIMIT=NONE] -->
    <string name="call_category">Calling</string>
    <!-- Mobile network settings screen, title of Video calling setting [CHAR LIMIT=NONE] -->
    <string name="video_calling_settings_title">Carrier video calling</string>

    <!-- Mobile network settings screen, setting option name [CHAR LIMIT=NONE] -->
    <string name="cdma_system_select_title">System select</string>
    <!-- Mobile network settings screen, setting summary text [CHAR LIMIT=NONE] -->
    <string name="cdma_system_select_summary">Change the CDMA roaming mode</string>
    <!-- System select settings screen title [CHAR LIMIT=NONE] -->
    <string name="cdma_system_select_dialogtitle">System select</string>

    <!-- Mobile network settings screen, name for network operator category [CHAR LIMIT=NONE] -->
    <string name="network_operator_category">Network</string>

    <!-- Title for CDMA subscription [CHAR LIMIT=50] -->
    <string name="cdma_subscription_title">CDMA subscription</string>
    <!-- Summary for CDMA subscription [CHAR LIMIT=NONE] -->
    <string name="cdma_subscription_summary">Change between RUIM/SIM and NV</string>
    <!-- Dialog title for CDMA subscription [CHAR LIMIT=30] -->
    <string name="cdma_subscription_dialogtitle">subscription</string>

    <!-- Title to register automatically [CHAR LIMIT=NONE] -->
    <string name="register_automatically">Automatic registration\u2026</string>
    <!-- Mobile network settings screen, dialog message title when user selects the Data roaming check box [CHAR LIMIT=120] -->
    <string name="roaming_alert_title">Allow data roaming?</string>
    <!-- Mobile network settings screen, message asking the user to check their pricing with their Carrier, when enabling Data roaming. [CHAR LIMIT=NONE] -->
    <string name="roaming_check_price_warning">Check with your network provider for pricing.</string>

    <!-- Title for mobile data preference, to display the mobile data usage for each app. [CHAR LIMIT=NONE]-->
    <string name="mobile_data_usage_title">App data usage</string>
    <!-- Summary to show the current network mode is invalid. [CHAR LIMIT=NONE]-->
    <string name="mobile_network_mode_error">Invalid Network Mode <xliff:g id="networkModeId" example="0">%1$d</xliff:g>. Ignore.</string>
    <!-- Title for _satellite_setting_preference_layout in mobile network settings [CHAR LIMIT=60] -->
    <string name="satellite_setting_title">Satellite messaging</string>
    <!-- Summary for _satellite_setting_preference_layout. [CHAR LIMIT=NONE]-->
    <string name="satellite_setting_enabled_summary">Send and receive text messages by satellite. Included with your account.</string>
    <!-- Summary for _satellite_setting_preference_layout. [CHAR LIMIT=NONE]-->
    <string name="satellite_setting_disabled_summary">Send and receive text messages by satellite. Non included with your account.</string>
    <!-- Search keywords for "_satellite_setting_preference_layout" [CHAR_LIMIT=NONE] -->
    <string name="keywords_satellite_setting">Satellite messaging</string>
    <!-- Category name "About satellite messaging" [CHAR_LIMIT=NONE] -->
    <string name="category_name_about_satellite_messaging">About satellite messaging</string>
    <!-- Summary for category "About satellite messaging" [CHAR_LIMIT=NONE] -->
    <string name="title_about_satellite_setting">You can send and receive text messages by satellite as part of an eligible <xliff:g id="carrier_name" example="T-Mobile">%1$s</xliff:g> account</string>
    <!-- Category title "Your mobile plan" [CHAR_LIMIT=NONE] -->
    <string name="category_title_your_satellite_plan">Your <xliff:g id="carrier_name" example="T-Mobile">%1$s</xliff:g> plan</string>
    <!-- Title for category "Your mobile plan when satellite is included in plan" [CHAR_LIMIT=NONE] -->
    <string name="title_have_satellite_plan">Satellite messaging is included with your account</string>
    <!-- Title for category "Your mobile plan when satellite is not included in plan" [CHAR_LIMIT=NONE] -->
    <string name="title_no_satellite_plan">Satellite messaging isn\u2019t included with your account</string>
    <!-- text view add satellite messaging" [CHAR_LIMIT=NONE] -->
    <string name="summary_add_satellite_setting">Add satellite messaging</string>
    <!-- Category name "How it works" [CHAR_LIMIT=NONE] -->
    <string name="category_name_how_it_works">How it works</string>
    <!-- Title for satellite connection guide [CHAR_LIMIT=NONE] -->
    <string name="title_satellite_connection_guide">When you don\u2019t have a mobile network</string>
    <!-- Summary for satellite connection guide [CHAR_LIMIT=NONE] -->
    <string name="summary_satellite_connection_guide">Your phone will auto-connect to a satellite. For the best connection, keep a clear view of the sky.</string>
    <!-- Title for satellite supported service [CHAR_LIMIT=NONE] -->
    <string name="title_supported_service">After your phone connects to a satellite</string>
    <!-- Summary for satellite supported service [CHAR_LIMIT=NONE] -->
    <string name="summary_supported_service">You can text anyone, including emergency services. Your phone will reconnect to a mobile network when available.</string>
    <!-- learn more text - more about satellite messaging [CHAR_LIMIT=NONE] -->
    <string name="satellite_setting_summary_more_information">Satellite messaging may take longer and is available only in some areas, Weather and certain structures may affect your satellite connection. Calling by satellite isn\u2019t available.\n\nIt may take some time for changes to your account to show in Settings. Contact <xliff:g id="carrier_name" example="T-Mobile">%1$s</xliff:g> for details.</string>
    <!-- more about satellite messaging [CHAR_LIMIT=NONE] -->
    <string name="more_about_satellite_messaging">More about satellite messaging</string>
    <!-- URL for more info about satellite messaging [CHAR LIMIT=60] -->
    <string name="more_info_satellite_messaging_link" translatable="false"></string>

    <!-- Title for Apn settings in mobile network settings [CHAR LIMIT=60] -->
    <string name="mobile_network_apn_title">Access Point Names</string>
    <!-- Search keywords for "Access Point Names" [CHAR_LIMIT=NONE] -->
    <string name="keywords_access_point_names">apn</string>

    <!-- Available networks screen, summary when button disallowed due to permanent automatic mode [CHAR LIMIT=NONE] -->
    <string name="manual_mode_disallowed_summary">Unavailable when connected to <xliff:g id="carrier" example="verizon">%1$s</xliff:g></string>

    <!-- See more items in contextual homepage [CHAR LIMIT=30]-->
    <string name="see_more">See more</string>

    <!-- Strings for toggling subscriptions dialog activity -->
    <!-- Title of confirmation dialog asking the user if they want to enable subscription. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_enable_sub_dialog_title">Turn on <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>?</string>
    <!-- Title of confirmation dialog asking the user if they want to enable subscription without the subscription name. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name">Turn on SIM?</string>
    <!-- Title of confirmation dialog asking the user if they want to switch subscription. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_title">Switch to <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>?</string>
    <!-- Title of confirmation dialog asking the user if they want to switch to the SIM card. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_psim_dialog_title">Switch to using SIM card?</string>
    <!-- Title of confirmation dialog asking the user if they want to switch subscription. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_mep_title">Use <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>?</string>
    <!-- Body text of confirmation dialog for switching subscription that involves switching SIM slots. Indicates that only one SIM can be active at a time. Also that switching will not cancel the user's mobile service plan. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_text">Only 1 SIM can be on at a time.\n\nSwitching to <xliff:g id="to_carrier_name" example="Google Fi">%1$s</xliff:g> won\u2019t cancel your <xliff:g id="from_carrier_name" example="Sprint">%2$s</xliff:g> service.</string>
    <!-- Body text of confirmation dialog for switching subscription between two eSIM profiles. Indicates that only 1 eSIM can be on at a time. Also that switching will not cancel the user's mobile service plan. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_text_downloaded">Only 1 eSIM can be on at a time.\n\nSwitching to <xliff:g id="to_carrier_name" example="Google Fi">%1$s</xliff:g> won\u2019t cancel your <xliff:g id="from_carrier_name" example="Sprint">%2$s</xliff:g> service.</string>
    <!-- Body text of confirmation dialog for switching subscription between two eSIM profiles. Indicates that only one SIM can be active at a time. Also that switching will not cancel the user's mobile service plan. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_text_single_sim">Only 1 SIM can be on at a time.\n\nSwitching won\u2019t cancel your <xliff:g id="to_carrier_name" example="Google Fi">%1$s</xliff:g> service.</string>
    <!-- Body text of confirmation dialog for switching subscription between two eSIM profiles. Indicates that only one downloaded SIM can be active at a time. Also that switching will not cancel the user's mobile service plan. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_mep_text">You can use 2 SIMs at a time. To use <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>, turn off another SIM.</string>
    <!-- Text of confirm button in the confirmation dialog asking the user if they want to switch subscription. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_confirm">Switch to <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g></string>
    <!-- Text of carrier list item in the mep confirmation dialog asking the user if they want to turn off the carrier. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off">Turn off <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g></string>
    <!-- Text of carrier list item in the mep confirmation dialog asking the user if they want to turn off the carrier. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off">Turning off a SIM won\u2019t cancel your service</string>
    <!-- Status message indicating the device is in the process of disconnecting from one mobile network and immediately connecting to another. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_enabling_sim_without_carrier_name">Activating your SIM&#8230;</string>
    <!-- Text of progress dialog indicating the subscription switch is in progress. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_switch_sub_dialog_progress">Switching to <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>&#8230;</string>
    <!-- Title of error message indicating that the device could not disconnect from one mobile network and immediately connect to another. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_enable_sim_fail_title">Can\u2019t switch SIMs</string>
    <!-- Body text of error message indicating the device could not disconnect from one mobile network and immediately connect to another, due to an unspecified issue. [CHAR_LIMIT=NONE] -->
    <string name="sim_action_enable_sim_fail_text">Something went wrong. Can\u2019t switch SIMs.</string>
    <!-- Title of confirmation dialog asking the user if they want to disable subscription. [CHAR_LIMIT=NONE] -->
    <string name="privileged_action_disable_sub_dialog_title">Turn off <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>?</string>
    <!-- Title of confirmation dialog asking the user if they want to disable subscription. [CHAR_LIMIT=NONE] -->
    <string name="privileged_action_disable_sub_dialog_title_without_carrier">Turn off SIM?</string>
    <!-- Disabling SIMs progress dialog message [CHAR LIMIT=NONE] -->
    <string name="privileged_action_disable_sub_dialog_progress">Turning off SIM<xliff:g id="ellipsis" example="...">&#8230;</xliff:g></string>
    <!-- Title of error messaging indicating the device could not disable the mobile network. [CHAR LIMIT=NONE] -->
    <string name="privileged_action_disable_fail_title">Can\u2019t turn off SIM</string>
    <!-- Body text of error message indicating the device could not disable the mobile network, due to an unknown issue. [CHAR LIMIT=NONE] -->
    <string name="privileged_action_disable_fail_text">Something went wrong and your SIM could not be turned off.</string>
    <!-- Title on a dialog asking the users whether they want to enable DSDS mode. [CHAR LIMIT=NONE] -->
    <string name="sim_action_enable_dsds_title">Use 2 SIMs?</string>
    <!-- Message in a dialog indicating the user can enable DSDS mode. [CHAR LIMIT=NONE] -->
    <string name="sim_action_enable_dsds_text">This device can have 2 SIMs active at once. To continue using 1 SIM at a time, tap \"No thanks\".</string>
    <!-- Ask the user whether to restart device. [CHAR LIMIT=NONE] -->
    <string name="sim_action_restart_title">Restart device?</string>
    <!-- Button on a dialog to confirm SIM operations. [CHAR LIMIT=30] -->
    <string name="sim_action_yes">Yes</string>
    <!-- User confirms reboot the phone. [CHAR LIMIT=30] -->
    <string name="sim_action_reboot">Restart</string>
    <!-- Button on a dialog to reject SIM operations. [CHAR LIMIT=30] -->
    <string name="sim_action_no_thanks">No thanks</string>
    <!-- Button text to cancel operations proposed by a sim operation dialog [CHAR LIMIT=20] -->
    <string name="sim_action_cancel">Cancel</string>
    <!-- Button which will disconnect the user from one mobile network and immediately connect to another. [CHAR LIMIT=30] -->
    <string name="sim_switch_button">Switch</string>
    <!-- Button text to turn off the sim. [CHAR LIMIT=30] -->
    <string name="sim_action_turn_off">Turn off</string>
    <!-- Title of DSDS activation failure dialog [CHAR LIMIT=40] -->
    <string name="dsds_activation_failure_title">Can\u2019t activate SIM</string>
    <!-- Body text of DSDS activation failure dialog. Users could toggle the selected SIM again or reboot to recover. [CHAR LIMIT=NONE] -->
    <string name="dsds_activation_failure_body_msg2">Try turning on the SIM again. If the problem continues, restart your device.</string>

    <!-- Strings for dual SIM onboarding -->
    <!-- Title of dual sim onboarding's bottom sheets. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_bottomsheets_title">Set up your SIM</string>
    <!-- Body text of dual sim onboarding's bottom sheets. [CHAR LIMIT=NONE] -->
    <string name="sim_onboarding_bottomsheets_msg">Set your mobile network preferences to use multiple SIMs on this device</string>
    <!-- Title of dual sim onboarding's label sim page. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_label_sim_title">Label your SIMs</string>
    <!-- Body text of dual sim onboarding's label sim page. [CHAR LIMIT=NONE] -->
    <string name="sim_onboarding_label_sim_msg">You’ll see these labels when making calls, sending texts, and using data, and in Settings</string>
    <!-- Title of dual sim onboarding's label sim dialog. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_label_sim_dialog_title">SIM label</string>
    <!-- Label text of dual sim onboarding's label sim dialog. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_label_sim_dialog_label">Label</string>
    <!-- Title of dual sim onboarding's select sim page. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_select_sim_title">Select which SIMs to use</string>
    <!-- Body text of dual sim onboarding's select sim page. [CHAR LIMIT=NONE] -->
    <string name="sim_onboarding_select_sim_msg">You can use 2 SIMs at a time</string>
    <!-- Title of dual sim onboarding's primary sim page. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_primary_sim_title">Set your primary SIMs</string>
    <!-- Body text of dual sim onboarding's primary sim page. [CHAR LIMIT=NONE] -->
    <string name="sim_onboarding_primary_sim_msg">Choose which SIMs to use by default for calls, texts, and data</string>

    <!-- Title of primary sim at SIMs page. [CHAR LIMIT=30] -->
    <string name="primary_sim_title">Your primary SIMs</string>

    <!-- Title of Calls item/dialog at dual sim onboarding's primary sim page or SIMs page. [CHAR LIMIT=30] -->
    <string name="primary_sim_calls_title">Calls</string>
    <!-- Title of Texts item/dialog at dual sim onboarding's primary sim page or SIMs page. [CHAR LIMIT=30] -->
    <string name="primary_sim_texts_title">Texts</string>
    <!-- Title of automatic data switching at dual sim onboarding's primary sim page or SIMs page. [CHAR LIMIT=30] -->
    <string name="primary_sim_automatic_data_title">Automatic data switching</string>
    <!-- Body text of automatic data switching at dual sim onboarding's primary sim page or SIMs page. [CHAR LIMIT=NONE] -->
    <string name="primary_sim_automatic_data_msg">Use data from either SIM depending on coverage and availability</string>

    <!-- Text of phone number item when the sim is data only. [CHAR LIMIT=NONE] -->
    <string name="sim_onboarding_phoneNumber_data_only">Data only</string>

    <!-- Button on the dual sim onboarding to start to set up sim. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_setup">Set up</string>
    <!-- Button on the dual sim onboarding to go to next page. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_next">Next</string>
    <!-- Text on the progressbar of dual sim onboarding for turning sim on. [CHAR LIMIT=30] -->
    <string name="sim_onboarding_progressbar_turning_sim_on">Turning on <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>&#8230;</string>
    <!-- Title of service provider name(SPN) at mobile network settings page. [CHAR LIMIT=30] -->
    <string name="mobile_network_spn_title">Mobile network</string>
    <!-- Title of phone number at mobile network settings page. [CHAR LIMIT=30] -->
    <string name="mobile_network_phone_number_title">Phone number</string>
    <!-- Title of SIM label and color editor dialog at mobile network settings page. [CHAR LIMIT=30] -->
    <string name="mobile_network_sim_label_color_title">SIM label and color</string>

    <!--  Strings for SIM push notifications  -->
    <!-- Category name of the notifications related to SIM setup. [CHAR LIMIT=NONE] -->
    <string name="sim_setup_channel_id">Network activation</string>
    <!-- Title on a push notification indicating that the user's device is in the middle of switching between mobile networks. [CHAR LIMIT=NONE] -->
    <string name="sim_switch_channel_id">Carrier switching</string>
    <!--  The title of post DSDS reboot notification. The title includes carrier's name. [CHAR LIMIT=NONE] -->
    <string name="post_dsds_reboot_notification_title_with_carrier">Your <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g> SIM is active</string>
    <!--  The body text of post DSDS reboot notification. [CHAR LIMIT=NONE] -->
    <string name="post_dsds_reboot_notification_text">Tap to update SIM settings</string>
    <!-- Title on a push notification indicating that the user's device switched to a new mobile network. [CHAR LIMIT=NONE] -->
    <string name="switch_to_removable_notification">Switched to <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g></string>
    <!-- Title on a push notification indicating that the user's device switched to a new mobile network. [CHAR LIMIT=NONE] -->
    <string name="switch_to_removable_notification_no_carrier_name">Switched to another carrier</string>
    <!-- Message in a push notification indicating that the user's phone has connected to a different mobile network. [CHAR LIMIT=NONE] -->
    <string name="network_changed_notification_text">Your mobile network has changed</string>
    <!-- Title on a push notification indicating that the user's device is capable of DSDS. [CHAR LIMIT=NONE] -->
    <string name="dsds_notification_after_suw_title">Set up your other SIM</string>
    <!-- Message in a push notification indicating that the user's device is capable of DSDS. [CHAR LIMIT=NONE] -->
    <string name="dsds_notification_after_suw_text">Choose your active SIM or use 2 SIMs at once</string>

    <!-- Strings for choose SIM activity -->
    <!--  The title text of choose SIM activity. [CHAR LIMIT=NONE] -->
    <string name="choose_sim_title">Choose a SIM to use</string>
    <!--  The body text of choose SIM activity. [CHAR LIMIT=NONE] -->
    <string name="choose_sim_text">{count, plural,
      =1      {1 SIM is available on this device, but only one can be used at a time}
      =2      {2 SIMs are available on this device, but only one can be used at a time}
      other   {# SIMs are available on this device, but only one can be used at a time}
    }</string>
    <!-- String indicating that we are activating the profile [CHAR LIMIT=NONE] -->
    <string name="choose_sim_activating">Turning on<xliff:g id="ellipsis" example="...">&#8230;</xliff:g></string>
    <!-- String indicating that we failed to activate the selected profile [CHAR LIMIT=NONE] -->
    <string name="choose_sim_could_not_activate">Couldn\u2019t turn on this SIM right now</string>

    <!-- Strings for switch SIM confirmation dialog. -->
    <!--  The title text of switch SIM confirmation dialog. [CHAR LIMIT=NONE] -->
    <string name="switch_sim_dialog_title">Use <xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g>?</string>
    <!--  The body text of switch SIM confirmation dialog. [CHAR LIMIT=NONE] -->
    <string name="switch_sim_dialog_text"><xliff:g id="carrier_name" example="Google Fi">%1$s</xliff:g> will be used for mobile data, calls, and SMS.</string>
    <!--  The title text of skip sim switch dialog. [CHAR LIMIT=NONE] -->
    <string name="switch_sim_dialog_no_switch_title">No active SIMs available</string>
    <!--  The body text of skip sim switch dialog. [CHAR LIMIT=NONE] -->
    <string name="switch_sim_dialog_no_switch_text">To use mobile data, call features, and SMS at a later time, go to your network settings</string>

    <!-- Button label of the removable sim. [CHAR LIMIT=NONE] -->
    <string name="sim_card_label">SIM</string>

    <!-- Strings for deleting eUICC subscriptions dialog activity -->
    <!-- Title on confirmation dialog asking the user if they want to erase the eSIM from the device. [CHAR_LIMIT=NONE] -->
    <string name="erase_sim_dialog_title">Erase this eSIM?</string>
    <!-- Body text in confirmation dialog indicating what erasing a SIM entails. [CHAR_LIMIT=NONE] -->
    <string name="erase_sim_dialog_text">This removes <xliff:g id="carrier_name_a" example="Google Fi">%1$s</xliff:g> service from this device, but your <xliff:g id="carrier_name_b" example="Google Fi">%1$s</xliff:g> plan won\'t be canceled.</string>
    <!-- Button label to erase the eSIM [CHAR_LIMIT=20] -->
    <string name="erase_sim_confirm_button">Erase</string>
    <!-- Status message indicating the device is in the process of erasing the SIM. [CHAR_LIMIT=NONE] -->
    <string name="erasing_sim">Erasing eSIM&#8230;</string>
    <!-- Title of error message indicating the device could not erase the SIM. [CHAR_LIMIT=NONE] -->
    <string name="erase_sim_fail_title">Can\'t erase eSIM</string>
    <!-- Body text of error message indicating the device could not erase the SIM due to an error. [CHAR_LIMIT=NONE] -->
    <string name="erase_sim_fail_text">Something went wrong and this eSIM wasn\'t erased.\n\nRestart your device and try again.</string>

    <!-- Title for Network connection request Dialog [CHAR LIMIT=60] -->
    <string name="network_connection_request_dialog_title">Connect to device</string>
    <!-- Summary for Network connection request Dialog [CHAR LIMIT=NONE] -->
    <string name="network_connection_request_dialog_summary">
        <xliff:g id="appName" example="ThirdPartyAppName">%1$s</xliff:g>
        app wants to use a temporary Wi\u2011Fi network to connect to your device
    </string>
    <!-- Message for Network connection timeout Dialog [CHAR LIMIT=NONE] -->
    <string name="network_connection_timeout_dialog_message">No devices found. Make sure devices are turned on and available to connect.</string>
    <!-- OK button for Network connection timeout Dialog [CHAR LIMIT=30] -->
    <string name="network_connection_timeout_dialog_ok">Try again</string>
    <!-- Message for Network connection error state Dialog [CHAR LIMIT=NONE] -->
    <string name="network_connection_errorstate_dialog_message">Something came up. The application has cancelled the request to choose a device.</string>
    <!-- Toast message when connection is successful [CHAR LIMIT=30] -->
    <string name="network_connection_connect_successful">Connection successful</string>
    <!-- Toast message when connection is failure [CHAR LIMIT=30] -->
    <string name="network_connection_connect_failure">Connection failed</string>
    <!-- Neutral button for Network connection request Dialog [CHAR LIMIT=30] -->
    <string name="network_connection_request_dialog_showall">Show all</string>
    <!-- Message for Network connection searching progress Dialog. Searching for wifi ap. [CHAR LIMIT=40] -->
    <string name="network_connection_searching_message">Searching for device\u2026</string>
    <!-- Message for Network connection connecting progress Dialog. Try to connect to wifi ap.[CHAR LIMIT=40] -->
    <string name="network_connection_connecting_message">Connecting to device\u2026</string>

    <!-- Title for left bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_left_name">Left</string>
    <!-- Title for right bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_right_name">Right</string>
    <!-- Title for middle bluetooth device. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_middle_name">Case</string>

    <!-- Default title for the settings panel [CHAR LIMIT=NONE] -->
    <string name="settings_panel_title">Settings Panel</string>

    <!-- UI debug setting: force desktop mode [CHAR LIMIT=50] -->
    <string name="force_desktop_mode">Force desktop mode</string>
    <!-- UI debug setting: force desktop mode summary [CHAR LIMIT=NONE] -->
    <string name="force_desktop_mode_summary">Force experimental desktop mode on secondary displays</string>
    <!-- UI debug setting: enable non-resizables in multi window [CHAR LIMIT=60] -->
    <string name="enable_non_resizable_multi_window">Enable non-resizable in multi window</string>
    <!-- UI debug setting: enable non-resizables in multi window summary [CHAR LIMIT=NONE] -->
    <string name="enable_non_resizable_multi_window_summary">Allows non-resizable apps to be in multi window</string>

    <!-- UI debug setting: Force enable "smart dark" UI rendering feature [CHAR LIMIT=60] -->
    <string name="hwui_force_dark_title">Override force-dark</string>
    <!-- UI debug setting: Force enable "smart dark" UI rendering feature summary [CHAR LIMIT=NONE] -->
    <string name="hwui_force_dark_summary">Overrides the force-dark feature to be always-on</string>

    <!-- Title for the top level Privacy Settings [CHAR LIMIT=30]-->
    <string name="privacy_dashboard_title">Privacy</string>
    <!-- Summary for the top level Privacy Settings [CHAR LIMIT=NONE]-->
    <string name="privacy_dashboard_summary">Permissions, account activity, personal data</string>


    <!-- Title for the privacy controls page [CHAR LIMIT=30]-->
    <string name="privacy_controls_title">Controls</string>


    <!-- Label for button in contextual card for users to remove the card [CHAR LIMIT=30] -->
    <string name="contextual_card_dismiss_remove">Remove</string>
    <!-- Label for button in contextual card for users to keep the card [CHAR LIMIT=30] -->
    <string name="contextual_card_dismiss_keep">Keep</string>
    <!-- String for contextual card dismissal [CHAR LIMIT=NONE] -->
    <string name="contextual_card_dismiss_confirm_message">Remove this suggestion?</string>

    <!-- Summary for low storage slice. [CHAR LIMIT=NONE] -->
    <string name="low_storage_summary">Storage is low. <xliff:g id="percentage" example="54%">%1$s</xliff:g> used - <xliff:g id="free_space" example="32GB">%2$s</xliff:g> free</string>

    <!-- Label for button in contextual card feedback dialog for users to send feedback [CHAR LIMIT=30] -->
    <string name="contextual_card_feedback_send">Send feedback</string>
    <!-- String for contextual card feedback dialog [CHAR LIMIT=NONE] -->
    <string name="contextual_card_feedback_confirm_message">Would you like to give us feedback on this suggestion?</string>

    <!-- Toast message for copy action of Copyable Slice [CHAR LIMIT=NONE] -->
    <string name="copyable_slice_toast"><xliff:g id="copy_content" example="Phone number">%1$s</xliff:g> copied to clipboard.</string>

    <!-- String for talkback on the account avatar of the search bar.  [CHAR LIMIT=NONE] -->
    <string name="search_bar_account_avatar_content_description"></string>

    <!-- Title for the accessibility usage preference in the Privacy page.  [CHAR LIMIT=NONE] -->
    <string name="accessibility_usage_title">Accessibility usage</string>

    <!-- Summary for the accessibility usage preference in the Privacy page.  [CHAR LIMIT=NONE] -->
    <string name="accessibility_usage_summary">{count, plural,
      =1      {1 app has full access to your device}
      other   {# apps have full access to your device}
    }</string>

    <!-- Label for the title on wfc disclaimer fragment. [CHAR LIMIT=40] -->
    <string name="wfc_disclaimer_title_text">Important information</string>

    <!-- Label for the agree button on wfc disclaimer fragment. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_agree_button_text">CONTINUE</string>

    <!-- Label for the disagree button on wfc disclaimer fragment. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_disagree_text">NO THANKS</string>

    <!-- Label for the title on wfc disclaimer location. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_location_title_text">Location</string>

    <!-- Warn the user that the phone may share its location with the carrier. [CHAR LIMIT=NONE] -->
    <string name="wfc_disclaimer_location_desc_text">Your carrier may collect your location when you use this service for emergency calls.\n\nVisit your carrier\u2019s privacy policy for details.</string>

    <!-- Message for forget passpoint dialog [CHAR LIMIT=none] -->
    <string name="forget_passpoint_dialog_message">You may lose access to any remaining time or data. Check with your provider before removing.</string>

    <!-- Title of the 'Content Capture' feature toggle in the Settings -> Privacy screen [CHAR LIMIT=none]-->
    <string name="content_capture">App content</string>
    <!-- Description of the 'Content Capture' feature toggle in the Settings -> Privacy screen [CHAR LIMIT=NONE]-->
    <string name="content_capture_summary">Allow apps to send content to the Android system</string>

    <!-- Title for the button to initiate a heap dump for the system server. [CHAR LIMIT=NONE] -->
    <string name="capture_system_heap_dump_title">Capture system heap dump</string>

    <!-- [CHAR LIMIT=32] Name of MTE page in "Developer Options" and heading of page. -->
    <string name="development_memtag_page_title">Memory Tagging Extension</string>
    <!-- [CHAR LIMIT=NONE] Explanation shown under heading of the page.-->
    <string name="development_memtag_intro">Memory Tagging Extension (MTE) makes it easier to find memory safety issues in your app and make native code in it more secure.</string>
    <!-- [CHAR LIMIT=NONE] Further explanation shown at the bottom of the page.-->
    <string name="development_memtag_footer">Turning on MTE might cause slower device performance.</string>
    <!-- [CHAR LIMIT=NONE] String for link to learn more about MTE.-->
    <string name="development_memtag_learn_more">Learn more about MTE</string>
    <!-- [CHAR LIMIT=52] Label for button to turn on / off MTE protection.-->
    <string name="development_memtag_toggle">Enable MTE until you turn it off</string>
    <!-- [CHAR LIMIT=NONE] Message shown in dialog prompting user to reboot device to turn on MTE.-->
    <string name="development_memtag_reboot_message_on">You\u0027ll need to restart your device to turn on MTE.</string>
    <!-- [CHAR LIMIT=NONE] Message shown in dialog prompting user to reboot device to turn off MTE.-->
    <string name="development_memtag_reboot_message_off">You\u0027ll need to restart your device to turn off MTE.</string>
    <!-- Title for the button to reboot with MTE enabled. [CHAR LIMIT=NONE] -->
    <string name="reboot_with_mte_title">Enable MTE for a single session</string>
    <string name="reboot_with_mte_message">System will restart and allow to experiment with Memory Tagging Extension (MTE). MTE may negatively impact system performance and stability. Will be reset on next subsequent reboot.</string>
    <!-- Subtext for button if MTE is not enabled through Advanced memory protection. -->
    <string name="reboot_with_mte_summary">Restart for a single session with MTE enabled</string>
    <!-- Subtext for button if MTE is already enabled through Advanced memory protection.
         The string for "Advanced memory protection" needs to match "memtag_toggle" above -->
    <string name="reboot_with_mte_already_enabled">MTE is already enabled</string>
    <!-- Toast that is shown when the user initiates capturing a heap dump for the system server. [CHAR LIMIT=NONE] -->
    <string name="capturing_system_heap_dump_message">Capturing system heap dump</string>
    <!-- Toast that is shown if there's an error capturing the user initiated heap dump. [CHAR LIMIT=NONE] -->
    <string name="error_capturing_system_heap_dump_message">Couldn\u2019t capture system heap dump</string>
    <!-- Title of toggle for whether to enable automatic heap dumps for the system server or not. [CHAR LIMIT=NONE] -->
    <string name="automatic_system_heap_dump_title">Automatically capture system heap dumps</string>
    <!-- Summary of toggle for whether to enable automatic heap dumps for the system server or not. [CHAR LIMIT=NONE] -->
    <string name="automatic_system_heap_dump_summary">Automatically capture a heap dump for Android System when it uses too much memory</string>

    <!-- Button label to disconnect a Wi-Fi network. [CHAR LIMIT=40] -->
    <string name="wifi_disconnect_button_text">Disconnect</string>

    <!-- Label for the title on wfc disclaimer location. [CHAR LIMIT=30] -->
    <string name="wfc_disclaimer_emergency_limitation_title_text">Emergency calls</string>

    <!-- Warn the user that the phone have emergency call limitation. [CHAR LIMIT=NONE] -->
    <string name="wfc_disclaimer_emergency_limitation_desc_text">Emergency calls over Wi\u2011Fi Calling are not supported by your carrier.\nThe device switches automatically to a cellular network to place an emergency call.\nEmergency calls are only possible in areas with cellular coverage.</string>

    <!-- Summary for Wi-Fi calling to explain this feature [CHAR LIMIT=NONE] -->
    <string name="wifi_calling_summary">Use Wi\u2011Fi for calls to improve quality</string>

    <!-- Title for enable MMS notification when trying to receive MMS.  [CHAR LIMIT=40] -->
    <string name="enable_receiving_mms_notification_title">Incoming MMS message</string>
    <!-- Title for enable MMS notification when trying to send MMS.  [CHAR LIMIT=40] -->
    <string name="enable_sending_mms_notification_title">Can\u2019t send MMS message</string>
    <!-- Message under title informing the user to touch to go to SIM Cards in Settings.  [CHAR LIMIT=100] -->
    <string name="enable_mms_notification_summary">Tap to allow MMS messaging on <xliff:g id="operator_name" example="T-Mobile">%1$s</xliff:g> when mobile data is off</string>

    <!-- Title for enable MMS notification channel.  [CHAR LIMIT=40] -->
    <string name="enable_mms_notification_channel_title">MMS message</string>

    <!-- Title for SIM combination warning. [CHAR LIMIT=80] -->
    <string name="sim_combination_warning_notification_title">Issue with SIM combination</string>
    <!-- Message for DSDS dual CDMA SIM combination warning. [CHAR LIMIT=100] -->
    <string name="dual_cdma_sim_warning_notification_summary">Using <xliff:g id="operator_names" example="T-Mobile &amp; Verizon">%1$s</xliff:g> may limit functionality. Tap to learn more.</string>

    <!-- Title for enable MMS notification channel.  [CHAR LIMIT=40] -->
    <string name="dual_cdma_sim_warning_notification_channel_title">SIM combination</string>

    <!-- Title of setting on privacy settings screen that will show work policy info. [CHAR LIMIT=NONE] -->
    <string name="work_policy_privacy_settings">Your work policy info</string>
    <!-- Summary for Enterprise Privacy settings, explaining what the user can expect to find under it [CHAR LIMIT=NONE]-->
    <string name="work_policy_privacy_settings_summary">Settings managed by your IT admin</string>

    <!-- Developer Settings: Search keywords for the Profile HWUI rendering. [CHAR_LIMIT=NONE] -->
    <string name="track_frame_time_keywords">GPU</string>

    <!-- setting Checkbox title whether to boot with 16K page size [CHAR_LIMIT=35] -->
    <string name="enable_16k_pages">Boot with 16K page size</string>
    <!-- setting Checkbox summary whether to boot with 16K page size[CHAR_LIMIT=50] -->
    <string name="enable_16k_pages_summary">Boot device using 16K page size supported kernel</string>
    <!-- Confirmation dialog title to ensure user wishes to enable 16K page size -->
    <string name="confirm_enable_16k_pages_title">Reboot with 16KB pages compatible kernel?</string>
    <!-- Warning dialog message to confirm user wishes to enable 16K page size -->
    <string name="confirm_enable_16k_pages_text">WARNING: Some applications may not be compatible with this mode. Device will reboot after confirmation.</string>
    <!-- dialog title to confirm user wishes to revert to 4k page size kernel -->
    <string name="confirm_enable_4k_pages_title">Reboot with 4KB pages compatible kernel?</string>
    <!-- dialog message to confirm user wishes to enable 4K page size -->
    <string name="confirm_enable_4k_pages_text">Device will reboot after confirmation.</string>
    <!-- Toast message when 16k OTA update fails -->
    <string name="toast_16k_update_failed_text">Failed to update kernel to 16KB pages compatible kernel.</string>
    <string name="progress_16k_ota_title">Applying change</string>
    <!-- DSU Loader. Do not translate. -->

    <string name="dsu_loader_title" translatable="false">DSU Loader</string>
    <!-- DSU Loader Description. Do not translate. -->
    <string name="dsu_loader_description" translatable="false">Load a Dynamic System Update Image</string>
    <!-- DSU Loader Loading. Do not translate. -->
    <string name="dsu_loader_loading" translatable="false">Loading\u2026</string>
    <!-- DSU Loader. Do not translate. -->
    <string name="dsu_is_running" translatable="false">DSU is running</string>

    <!-- Name of dev option called "Bug report handler" [CHAR LIMIT=NONE] -->
    <string name="bug_report_handler_title">Bug report handler</string>

    <!-- Developer Settings: Footer text for bug report handler picker [CHAR LIMIT=NONE] -->
    <string name="bug_report_handler_picker_footer_text">Determines which app handles the Bug Report shortcut on your device.</string>

    <!-- Subtext of personal profile app for current setting [CHAR LIMIT=NONE] -->
    <string name="personal_profile_app_subtext">Personal</string>

    <!-- Subtext of work profile app for current setting [CHAR LIMIT=NONE] -->
    <string name="work_profile_app_subtext">Work</string>

    <!-- Subtext of system default app for current setting [CHAR LIMIT=NONE] -->
    <string name="system_default_app_subtext">System default</string>

    <!-- Summary of a default app when there is no app set [CHAR LIMIT=60] -->
    <string name="default_app_none">None</string>

    <!-- Developer settings: text for the bug report handler selection toast shown if an invalid bug report handler was chosen. [CHAR LIMIT=NONE] -->
    <string name="select_invalid_bug_report_handler_toast_text">This choice is no longer valid. Try again.</string>

    <!-- Power menu setting name [CHAR LIMIT=60] -->
    <string name="power_menu_setting_name">Press &amp; hold power button</string>

    <!-- Power menu setting section title for selecting the press and hold power button behavior. [CHAR LIMIT=60] -->
    <string name="power_menu_long_press_category_title">Press &amp; hold power button to access</string>
    <!-- Power menu setting option to make press and hold power button to open Power Menu. [CHAR LIMIT=60] -->
    <string name="power_menu_long_press_for_power_menu_title">Power menu</string>
    <!-- Power menu setting option to make press and hold power button to open Assistant. [CHAR LIMIT=60] -->
    <string name="power_menu_long_press_for_assistant_title">Digital assistant</string>

    <!-- Power menu setting summary to describe press and hold power button will open Assistant. [CHAR LIMIT=NONE] -->
    <string name="power_menu_summary_long_press_for_assistant">Access digital assistant</string>
    <!-- Power menu setting summary to describe press and hold power button will open Power Menu. [CHAR LIMIT=NONE] -->
    <string name="power_menu_summary_long_press_for_power_menu">Access power menu</string>

    <!-- Power menu setting privacy no secure screen lock set [CHAR_LIMIT=NONE] -->
    <string name="lockscreen_privacy_not_secure">To use, first set a screen lock</string>

    <!-- Power menu explanation to press power and volume up to show power menu. [CHAR LIMIT=NONE] -->
    <string name="power_menu_power_volume_up_hint">Power menu:\nPress the power button and the volume up button at the same time</string>
    <!-- Power menu explanation where to find prevent ringing option. [CHAR LIMIT=NONE] -->
    <string name="power_menu_power_prevent_ringing_hint">Prevent ringing:\nPress a volume button for the shortcut</string>

    <!-- Power menu title of the seekbar setting controlling duration of how long the power button must be held to invoke assistant. [CHAR LIMIT=NONE]-->
    <string name="power_menu_long_press_for_assist_sensitivity_title">Press &amp; hold duration</string>
    <!-- Power menu summary of the seekbar setting controlling duration of how long the power button must be held to invoke assistant. [CHAR LIMIT=NONE]-->
    <string name="power_menu_long_press_for_assist_sensitivity_summary">Adjust sensitivity by choosing how long to press &amp; hold the power button</string>
    <!-- Label at the lowest end of duration slider for long press power invocation of assistant. [CHAR LIMIT=30] -->
    <string name="power_menu_long_press_for_assist_sensitivity_low_label">Short</string>
    <!-- Label at the highest end of duration slider for long press power invocation of assistant. [CHAR LIMIT=30] -->
    <string name="power_menu_long_press_for_assist_sensitivity_high_label">Long</string>

    <!-- Wallet (formerly Cards and passes) toggle name [CHAR LIMIT=60] -->
    <string name="lockscreen_privacy_wallet_setting_toggle">Show wallet</string>
    <!-- Wallet (formerly Cards and passes) summary [CHAR LIMIT=NONE] -->
    <string name="lockscreen_privacy_wallet_summary">Allow access to wallet from lock screen</string>

    <!-- QR Code Scanner toggle name [CHAR LIMIT=60] -->
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle">Show QR code scanner</string>
    <!-- QR Code Scanner summary [CHAR LIMIT=NONE] -->
    <string name="lockscreen_privacy_qr_code_scanner_summary">Allow access to QR code scanner from lock screen</string>

    <!-- Device controls toggle name [CHAR LIMIT=60] -->
    <string name="lockscreen_privacy_controls_setting_toggle">Show device controls</string>
    <!-- Device controls summary [CHAR LIMIT=NONE] -->
    <string name="lockscreen_privacy_controls_summary">From the lockscreen</string>
    <!-- Trivial Device controls toggle name [CHAR LIMIT=60] -->
    <string name="lockscreen_trivial_controls_setting_toggle">Use device controls</string>
    <!-- Trivial Device disabled controls summary [CHAR LIMIT=NONE] -->
    <string name="lockscreen_trivial_disabled_controls_summary">To use, first turn on \u0022Show device controls\u0022</string>
    <!-- Lockscreen dynamic clock summary [CHAR LIMIT=NONE] -->
    <string name="lockscreen_double_line_clock_summary">Clock size changes according to lock screen content</string>
    <!-- Lockscreen dynamic clock toggle [CHAR LIMIT=60] -->
    <string name="lockscreen_double_line_clock_setting_toggle">Dynamic clock</string>
    <!-- Lock screen shortcuts preference [CHAR LIMIT=60] -->
    <string name="lockscreen_quick_affordances_title">Shortcuts</string>
    <!-- Summary for the lock screen button preference [CHAR LIMIT=60] -->
    <plurals name="lockscreen_quick_affordances_summary">
        <item quantity="zero">None</item>
        <item quantity="one"><xliff:g id="first">%1$s</xliff:g></item>
        <item quantity="other"><xliff:g id="first">%1$s</xliff:g>, <xliff:g id="second">%2$s</xliff:g></item>
    </plurals>

    <!-- Title for RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_title"></string>
    <!-- Subtext for showing the option of RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_no_visible"></string>
    <!-- Subtext for showing the option of RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_visible_during_call"></string>
    <!-- Subtext for showing the option of RTT setting. [CHAR LIMIT=NONE] -->
    <string name="rtt_settings_always_visible"></string>

    <!-- Title for the 5G limited VoLTE dialog. [CHAR LIMIT=50] -->
    <string name="volte_5G_limited_title">Turn off VoLTE?</string>
    <!-- Content description for the 5G limited VoLTE dialog. [CHAR LIMIT=NONE] -->
    <string name="volte_5G_limited_text">This also turns off your 5G connection.\nDuring a voice call, you can\u2019t use the internet and some apps may not work.</string>
    <!-- Help URI, 5G limitation in DSDS condition. [DO NOT TRANSLATE] -->
    <string name="help_uri_5g_dsds" translatable="false"></string>

    <!-- Developer settings: app freezer title [CHAR LIMIT=50]-->
    <string name="cached_apps_freezer">Suspend execution for cached apps</string>

    <!-- Developer settings - Shared data: label to indicate that the shared data never expires [CHAR LIMIT=80] -->
    <string name="blob_never_expires_text">Never expires.</string>
    <!-- Developer settings - Shared data: label to indicate that the lease acquired by an app never expires [CHAR LIMIT=80] -->
    <string name="accessor_never_expires_text">Lease never expires.</string>

    <!-- Title for allowing screen overlays on Settings app. [CHAR LIMIT=50]-->
    <string name="overlay_settings_title">Allow screen overlays on Settings</string>
    <!-- Summary for allowing screen overlays on Settings app. [CHAR LIMIT=NONE]-->
    <string name="overlay_settings_summary">Allow apps that can display over other apps to overlay Settings screens</string>

    <!-- Developer settings: Title for allowing mock modem service for testing. [CHAR LIMIT=50]-->
    <string name="allow_mock_modem">Allow Mock Modem</string>
    <!-- Developer settings: Summary for allowing mock modem service. [CHAR LIMIT=NONE]-->
    <string name="allow_mock_modem_summary">Allow this device to run Mock Modem service for instrumentation testing. Do not enable this during normal usage of the phone</string>

    <!-- Developer settings: Title for disable app and notification screen share protections [CHAR LIMIT=50] -->
    <string name="disable_screen_share_protections_for_apps_and_notifications">Disable screen share protections</string>
    <!-- Developer settings: Summary for disable app and notification screen share protections summary [CHAR LIMIT=150] -->
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary">Disables system applied app and notifications protections during screen sharing</string>

    <!-- Title for media control settings [CHAR LIMIT=50]-->
    <string name="media_controls_title">Media</string>
    <!-- Title of toggle to enable or disable the media resumption feature in quick settings [CHAR LIMIT=50]-->
    <string name="media_controls_resume_title">Pin media player</string>
    <!-- Description of toggle to enable or disable the media resumption feature in quick settings [CHAR LIMIT=NONE]-->
    <string name="media_controls_resume_description">To quickly resume playback, media player stays open in Quick Settings</string>
    <!-- Title of toggle to enable or disable the media resumption on lockscreen [CHAR LIMIT=NONE]-->
    <string name="media_controls_lockscreen_title">Show media on lock screen</string>
    <!-- Description of toggle to enable or disable the media resumption on lockscreen [CHAR LIMIT=NONE]-->
    <string name="media_controls_lockscreen_description">To quickly resume playback, media player stays open on lock screen</string>
    <!-- Title of toggle to enable or disable media recommendations in quick settings [CHAR LIMIT=NONE] -->
    <string name="media_controls_recommendations_title">Show Assistant media recommendations</string>
    <!-- Description of toggle to enable or disable media recommendations based on user's activity [CHAR LIMIT=NONE] -->
    <string name="media_controls_recommendations_description">Based on your activity</string>
    <!-- Subtext for media settings when the player will be hidden [CHAR LIMIT=50] -->
    <string name="media_controls_hide_player">Hide player</string>
    <!-- Subtext for media settings when the player will be shown [CHAR LIMIT=50] -->
    <string name="media_controls_show_player">Show player</string>
    <!-- Keywords for the media controls setting [CHAR LIMIT=NONE]-->
    <string name="keywords_media_controls">media</string>

    <!-- Title of toggle to enable or disable the media resumption on lockscreen [CHAR LIMIT=NONE]-->
    <string name="camera_extensions_fallback_title">Allow camera software extensions</string>
    <!-- Description of toggle to enable or disable the media resumption on lockscreen [CHAR LIMIT=NONE]-->
    <string name="camera_extensions_fallback_description">Enables the default software implementation of advanced camera features, such as Eyes Free videography.</string>

    <!-- Summary for see all preference when bluetooth is disable [CHAR LIMIT=none]-->
    <string name="connected_device_see_all_summary">Bluetooth will turn on</string>

    <!-- Provider Model: Internet controls settings screen, item title to go into the networks settings -->
    <string name="provider_internet_settings">Internet</string>
    <!-- Provider Model: SIMs controls settings screen, item title to go into the SIMs settings -->
    <string name="provider_network_settings_title">SIMs</string>
    <!-- Provider Model: Calls and SMS controllers settings screen, item title to go into the Calls and SMS settings -->
    <string name="calls_and_sms">Calls &amp; SMS</string>
    <!-- Provider Model: Name for call settings category [CHAR LIMIT=NONE] -->
    <string name="calls_and_sms_category">Wi\u2011Fi calling</string>
    <!-- Provider Model: Summary for calling preference -->
    <string name="calls_sms_wfc_summary">Make and receive calls over Wi\u2011Fi</string>
    <!-- Provider Model: Calls preference title -->
    <string name="calls_preference_title">Calls</string>
    <!-- Provider Model: SMS preference title -->
    <string name="sms_preference_title">SMS</string>
    <!-- Provider Model: Preferred status in summary for Calls & SMS -->
    <string name="calls_sms_preferred">preferred</string>
    <!-- Provider Model: Calls Preferred status in summary for Calls & SMS -->
    <string name="calls_sms_calls_preferred">preferred for calls</string>
    <!-- Provider Model: SMS Preferred status in summary for Calls & SMS -->
    <string name="calls_sms_sms_preferred">preferred for SMS</string>
    <!-- Provider Model: Unavailable status in summary for Calls & SMS -->
    <string name="calls_sms_unavailable">unavailable</string>
    <!-- Provider Model: Temporarily unavailable status in summary for Calls & SMS -->
    <string name="calls_sms_temp_unavailable">Temporarily unavailable</string>
    <!-- Provider Model: No SIM status in summary for Calls & SMS -->
    <string name="calls_sms_no_sim">No SIM</string>
    <!-- Network & internet preferences title [CHAR LIMIT=NONE] -->
    <string name="network_and_internet_preferences_title">Network preferences</string>
    <!-- Search keywords for "Internet" settings [CHAR_LIMIT=NONE] -->
    <string name="keywords_internet">network connection, internet, wireless, data, wifi, wi-fi, wi fi, cellular, mobile, cell carrier, 4g, 3g, 2g, lte</string>
    <!-- Title for interrupting the voice call alert. [CHAR_LIMIT=NONE] -->
    <string name="reset_your_internet_title">Reset your internet?</string>
    <!-- Description to wait device resetting internet networks. [CHAR_LIMIT=NONE] -->
    <string name="resetting_internet_text">Resetting your internet\u2026</string>
    <!-- Menu option for data connectivity recovery for all requested technologies. [CHAR_LIMIT=NONE] -->
    <string name="fix_connectivity">Fix connectivity</string>
    <!-- Summary for networks available (includes no network connected). [CHAR_LIMIT=NONE] -->
    <string name="networks_available">Networks available</string>
    <!-- Summary for warning to disconnect ethernet first then switch to other networks. [CHAR LIMIT=60] -->
    <string name="to_switch_networks_disconnect_ethernet">To switch networks, disconnect ethernet</string>
    <!-- Title for merged carrier Wi-Fi offload toggle. [CHAR LIMIT=NONE] -->
    <string name="carrier_wifi_offload_title">W+ connections</string>
    <!-- Summary for merged carrier Wi-Fi offload toggle. [CHAR LIMIT=NONE] -->
    <string name="carrier_wifi_offload_summary">Allow Google Fi to use W+ networks to improve speed and coverage</string>
    <!-- Title for merged carrier Wi-Fi network information. [CHAR LIMIT=NONE] -->
    <string name="carrier_wifi_network_title">W+ network</string>
    <!-- Provider Model: title of SIM category -->
    <string name="sim_category_title">SIM</string>
    <!-- Provider Model: title of eSIM category. [CHAR LIMIT=50] -->
    <string name="downloaded_sim_category_title">eSIM</string>
    <!-- Provider Model: title of eSIMs category. [CHAR LIMIT=50] -->
    <string name="downloaded_sims_category_title">eSIMs</string>
    <!-- Provider Model: summary of Active in SIM category. [CHAR LIMIT=50] -->
    <string name="sim_category_active_sim">On</string>
    <!-- Provider Model: summary of Inactive in SIM category. [CHAR LIMIT=50] -->
    <string name="sim_category_inactive_sim">Off</string>
    <!-- Provider Model: summary of default config. [CHAR LIMIT=50] -->
    <string name="sim_category_default_active_sim">\u0020/ Default for <xliff:g name="default_sim_config" example=" / Default for calls">%1$s</xliff:g></string>
    <!-- Provider Model: summary of default call. [CHAR LIMIT=50] -->
    <string name="default_active_sim_calls">calls</string>
    <!-- Provider Model: summary of default SMS. [CHAR LIMIT=50] -->
    <string name="default_active_sim_sms">SMS</string>
    <!-- Provider Model: summary of default mobile data. [CHAR LIMIT=50] -->
    <string name="default_active_sim_mobile_data">mobile data</string>
    <!-- Provider Model: Message to describe "Wi-Fi scan always available feature" when Wi-Fi is off and Wi-Fi
    scanning is on. To mark a link to bring the user to "scanning settings" screen. [CHAR LIMIT=NONE]-->
    <string name="wifi_scan_notify_message">To improve device experience, 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 Wi\u2011Fi scanning settings.</string>
    <!-- Provider Model: Link text to bring the user to "scanning settings" screen. [CHAR LIMIT=NONE]-->
    <string name="wifi_scan_change">Change</string>

    <!-- Summary text separator for preferences including a short description
         (eg. "Connected / 5G"). [CHAR LIMIT=50] -->
    <string name="preference_summary_default_combination"><xliff:g id="state" example="Connected">%1$s</xliff:g> / <xliff:g id="networkMode" example="LTE">%2$s</xliff:g></string>
    <!-- Provider Model:
         Summary indicating that a SIM has an active mobile data connection [CHAR LIMIT=50] -->
    <string name="mobile_data_connection_active">Connected</string>
    <!-- Provider Model:
     Summary indicating that a SIM has an active mobile data connection [CHAR LIMIT=50] -->
    <string name="mobile_data_temp_connection_active">Temporarily connected</string>
    <!-- Provider Model:
     Summary indicating that a SIM is temporarily connected to mobile data [CHAR LIMIT=50] -->
    <string name="mobile_data_temp_using">Temporarily using <xliff:g id="subName" example="Google Fi">%1$s</xliff:g></string>
    <!-- Provider Model:
         Summary indicating that a active SIM and no network available [CHAR LIMIT=50] -->
    <string name="mobile_data_no_connection">No connection</string>
    <!-- Provider Model:
         Summary indicating that a SIM has no mobile data connection [CHAR LIMIT=50] -->
    <string name="mobile_data_off_summary">Mobile data won\u0027t auto\u2011connect</string>
    <!-- Title of the dialog to turn off data usage [CHAR LIMIT=NONE] -->
    <string name="mobile_data_disable_title">Turn off mobile data?</string>
    <!-- Message body of the dialog to turn off data usage [CHAR LIMIT=NONE] -->
    <string name="mobile_data_disable_message">You won\’t have access to data or the internet through <xliff:g id="carrier" example="T-Mobile">%s</xliff:g>. Internet will only be available via Wi\u2011Fi.</string>
    <!-- Text used to refer to the user's current carrier in mobile_data_disable_message if the users's mobile network carrier name is not available [CHAR LIMIT=NONE] -->
    <string name="mobile_data_disable_message_default_carrier">your carrier</string>
    <!-- Summary for enterprise restriction not allow to use [CHAR LIMIT=NONE] -->
    <string name="not_allowed_by_ent">Not allowed by your organization</string>

    <!-- Summary for preference when Bedtime mode is on [CHAR LIMIT=NONE] -->
    <string name="aware_summary_when_bedtime_on">Unavailable because bedtime mode is on</string>

    <!-- Toast message to inform reset notification importance is completed [CHAR LIMIT=NONE] -->
    <string name="reset_importance_completed">Reset notification importance completed.</string>

    <!-- Title for setting tile leading to Apps settings [CHAR LIMIT=40]-->
    <string name="apps_dashboard_title">Apps</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>

    <!-- Brightness category name in Display Settings [CHAR LIMIT=none] -->
    <string name="category_name_brightness">Brightness</string>
    <!-- Lock screen category name in Display Settings [CHAR LIMIT=none] -->
    <string name="category_name_lock_display">Lock display</string>
    <!-- Appearance category name in Display Settings [CHAR LIMIT=none] -->
    <string name="category_name_appearance">Appearance</string>
    <!-- Color category name in Display Settings [CHAR LIMIT=none] -->
    <string name="category_name_color">Color</string>
    <!-- Name of Other display controls category in Display Settings [CHAR LIMIT=none] -->
    <string name="category_name_display_controls">Other display controls</string>
    <!-- General category name [CHAR LIMIT=none] -->
    <string name="category_name_general">General</string>
    <!-- Title for Dark theme main switch preferences. [CHAR LIMIT=50] -->
    <string name="dark_theme_main_switch_title">Use Dark theme</string>
    <!-- Title for bluetooth main switch. [CHAR LIMIT=50] -->
    <string name="bluetooth_main_switch_title">Use Bluetooth</string>

    <!-- Title for prevent ringing main switch. [CHAR LIMIT=50] -->
    <string name="prevent_ringing_main_switch_title">Use prevent ringing</string>
    <!-- Title for use wifi hotspot main switch [CHAR LIMIT=50]-->
    <string name="use_wifi_hotsopt_main_switch_title">Use Wi\u2011Fi hotspot</string>
    <!-- Title for app pinning main switch. [CHAR LIMIT=50] -->
    <string name="app_pinning_main_switch_title">Use app pinning</string>
    <!-- Title for developer options main switch. [CHAR LIMIT=50] -->
    <string name="developer_options_main_switch_title">Use developer options</string>
    <!-- Title for default print service main switch. [CHAR LIMIT=50] -->
    <string name="default_print_service_main_switch_title">Use print service</string>

    <!-- Title for multiple users main switch. [CHAR LIMIT=50] -->
    <string name="multiple_users_main_switch_title">Allow multiple users</string>
    <!-- Search keywords for the "Allow Multiple Users" section in Multiple Users Screen. [CHAR LIMIT=NONE] -->
    <string name="multiple_users_main_switch_keywords">allow, multiple, user, permit, many</string>

    <!-- Title for wireless debugging main switch. [CHAR LIMIT=50] -->
    <string name="wireless_debugging_main_switch_title">Use wireless debugging</string>
    <!-- Title for graphics driver main switch. [CHAR LIMIT=50] -->
    <string name="graphics_driver_main_switch_title">Use graphics driver preferences</string>
    <!-- Title for Night Light main switch preferences. [CHAR LIMIT=50] -->
    <string name="night_light_main_switch_title">Use Night Light</string>
    <!-- Title for NFC main switch preferences. [CHAR LIMIT=50] -->
    <string name="nfc_main_switch_title">Use NFC</string>
    <!-- Title for adaptive brightness main switch preferences. [CHAR LIMIT=50] -->
    <string name="adaptive_brightness_main_switch_title">Use adaptive brightness</string>
    <!-- Title for wifi calling main switch preferences. [CHAR LIMIT=50] -->
    <string name="wifi_calling_main_switch_title">Use Wi‑Fi calling</string>

    <!-- Default preference title for showing all apps on device [CHAR_LIMIT=50]-->
    <string name="default_see_all_apps_title">See all apps</string>

    <!-- Title for smart forwarding [CHAR LIMIT=50]-->
    <string name="smart_forwarding_title">Smart Forwarding</string>
    <!-- Summary for smart forwarding enabled [CHAR LIMIT=50]-->
    <string name="smart_forwarding_summary_enabled">Smart Forwarding Enabled</string>
    <!-- Summary for smart forwarding disabled [CHAR LIMIT=50]-->
    <string name="smart_forwarding_summary_disabled">Smart Forwarding Disabled</string>
    <!-- Dialog title for smart forwarding ongoing [CHAR LIMIT=50]-->
    <string name="smart_forwarding_ongoing_title">Call Settings</string>
    <!-- Subtext for smart forwarding ongoing [CHAR LIMIT=50]-->
    <string name="smart_forwarding_ongoing_text">Updating Settings...</string>
    <!-- Dialog title for smart forwarding failed [CHAR LIMIT=50]-->
    <string name="smart_forwarding_failed_title">Call Settings error</string>
    <!-- Subtext for smart forwarding failed [CHAR LIMIT=50]-->
    <string name="smart_forwarding_failed_text">Network or SIM error.</string>
    <!-- Subtext for sim is not activated [CHAR LIMIT=50]-->
    <string name="smart_forwarding_failed_not_activated_text">Sim is not activated.</string>
    <!-- Title when smart forwarding can't get the phone number [CHAR LIMIT=50]-->
    <string name="smart_forwarding_input_mdn_title">Enter Phone numbers</string>
    <!-- Dialog title when user update the phone number [CHAR LIMIT=50]-->
    <string name="smart_forwarding_input_mdn_dialog_title">Enter Phone number</string>
    <!-- Alert Dialog text when user didn't input the phone number [CHAR LIMIT=50]-->
    <string name="smart_forwarding_missing_mdn_text">Phone number is missing.</string>
    <!-- Alert Dialog text when user didn't input the phone number [CHAR LIMIT=50]-->
    <string name="smart_forwarding_missing_alert_dialog_text">OK</string>

    <!-- Title for toggle if user wants to enable 2G [CHAR LIMIT=40] -->
    <string name="enable_2g_title">Allow 2G</string>
    <!-- Title for toggle if user wants to enable 2G [CHAR LIMIT=NONE] -->
    <string name="enable_2g_summary">2G is less secure, but may improve your connection in some locations. For emergency calls, 2G is always allowed.</string>
    <!-- Title for if toggle access is disabled by carrier [CHAR LIMIT=NONE] -->
    <string name="enable_2g_summary_disabled_carrier"><xliff:g id="carrier_name_2g" example="Google Fi">%1$s</xliff:g> requires 2G to be available</string>

    <!-- Title for toggle if user wants to require cellular encryption [CHAR LIMIT=40] -->
    <string name="require_cellular_encryption_title">Require encryption</string>
    <!-- Summary for if the user wants to require cellular encryption [CHAR LIMIT=NONE] -->
    <string name="require_cellular_encryption_summary">Encryption is more secure, but you might not be able to connect in some locations. For emergency calls, encryption is never required</string>

    <!-- Label for All services preference in App info settings [CHAR LIMIT=40] -->
    <string name="app_info_all_services_label">All services</string>

    <!-- Title for toggle controlling whether notifications are shown when an app pastes from clipboard. [CHAR LIMIT=50] -->
    <string name="show_clip_access_notification">Show clipboard access</string>

    <!-- Summary for toggle controlling whether notifications are shown when an app pastes from clipboard. [CHAR LIMIT=NONE] -->
    <string name="show_clip_access_notification_summary">Show a message when apps access text, images, or other content you\u2019ve copied</string>

    <!-- All apps screen title, entry name on Apps page for the user to go to the all apps page. [CHAR LIMIT=30] -->
    <string name="all_apps">All apps</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>

    <!-- Title for UWB preference [CHAR_LIMIT=60] -->
    <string name="uwb_settings_title">Ultra-Wideband (UWB)</string>

    <!-- Summary for UWB preference. [CHAR_LIMIT=NONE]-->
    <string name="uwb_settings_summary">Helps identify the relative position of nearby devices that have UWB</string>

    <!-- Summary for UWB preference when airplane mode is enabled. [CHAR_LIMIT=NONE]-->
    <string name="uwb_settings_summary_airplane_mode">Turn off airplane mode to use UWB </string>

    <!-- Summary for UWB preference when UWB is unavailable due to regulatory requirements. [CHAR_LIMIT=NONE]-->
    <string name="uwb_settings_summary_no_uwb_regulatory">UWB is unavailable in the current location</string>

    <!-- Label for the camera use toggle [CHAR LIMIT=40] -->
    <string name="camera_toggle_title">Camera access</string>
    <!-- Label for the camera use toggle [CHAR LIMIT=40] -->
    <string name="mic_toggle_title">Microphone access</string>
    <!-- Describes what is affected by a permission toggle [CHAR LIMIT=NONE] -->
    <string name="perm_toggle_description">For apps and services</string>
    <!-- Describes what is affected by the mic toggle [CHAR LIMIT=NONE] -->
    <string name="mic_toggle_description">For apps and services. If this setting is off, microphone data may still be shared when you call an emergency number.</string>

    <!-- Content description of the previous button to bring user to the previous preview page. -->
    <string name="previous_page_content_description">Previous</string>

    <!-- Content description of the next button to bring user to the next preview page. -->
    <string name="next_page_content_description">Next</string>

    <!-- Content description of preview pager in colors preview -->
    <string name="colors_viewpager_content_description">Color preview</string>

    <!-- Bluetooth sim permission alert for notification title [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_notification_title">SIM access request</string>
    <!-- Bluetooth sim permission alert for notification content [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_notification_content">A device wants to access your SIM. Tap for details.</string>
    <!-- Bluetooth sim permission alert for dialog title [CHAR LIMIT=none] -->
    <string name="bluetooth_sim_card_access_dialog_title">Allow access to SIM?</string>
    <!-- Bluetooth sim 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 from your SIM. 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>

    <!-- Title for the button to edit The Android Resource Economy settings. "TARE" is the name of
    the feature that contains the AlarmManager and JobScheduler policies which are both android
    APIs. AlarmManager and JobScheduler are the names of Android system services and cannot be
    translated. "TARE" is not translatable. [CHAR LIMIT=NONE] -->
    <string name="tare_title" translatable="false">TARE</string>
    <!-- TARE settings title in developer options; "TARE" is the name of the feature and cannot be
     translated. [CHAR LIMIT=40] -->
    <string name="tare_settings">TARE Settings</string>
    <!-- Summary for the TARE feature being on (ie. enabled) [CHAR LIMIT=NONE] -->
    <string name="tare_on">On</string>
    <!-- Summary for the TARE feature being off (ie. disabled) [CHAR LIMIT=NONE] -->
    <string name="tare_off">Off</string>
    <!-- Allows user to revert the TARE settings to their default values [CHAR LIMIT=40] -->
    <string name="tare_revert">Revert to Default Settings</string>
    <!-- Allows user to view AlarmManager policy factors. Alarm in this context is referring to the
    possible alarm cases in the AlarmManager policy. AlarmManager is the name of an Android system
    service and cannot be translated. [CHAR LIMIT=40]-->
    <string name="tare_alarmmanager" translatable="false">AlarmManager</string>
    <!-- Allows user to view JobScheduler policy factors. JobScheduler is the name of an Android
    system service and cannot be translated.[CHAR LIMIT=40]-->
    <string name="tare_jobscheduler" translatable="false">JobScheduler</string>
    <!-- Toast notifying the developer that settings were reverted to their default values in
    TARE [CHAR LIMIT=40]-->
    <string name="tare_settings_reverted_toast">Settings reverted to default.</string>
    <!-- Title for the TARE policy factor that determines the maximum credits an app can have in one
    battery life cycle. Satiated means battery is fully charged; If this is not easily translatable,
    translate "maximum balance when device is fully charged" instead. Balance is the same meaning as
    having money in a bank account. Balance in our feature is the amount of Android Resource Credits
    an app can have. Android Resource Credits are a form of payment used by apps to be able to
    perform tasks. [CHAR LIMIT=80]-->
    <string name="tare_max_satiated_balance">Maximum Satiated Balance</string>
    <!-- Title for the TARE policy factors that affect how many credits an app may have. Balance
    in this context is the same as "bank balance" or "account balance" (ie. how much "money" may be
    in a bank account). [CHAR LIMIT=55]-->
    <string name="tare_balances">Balances</string>
    <!-- Title for the TARE section to modify consumption limits. "Consumption" refers to the idea
     using resources that are not replenished. [CHAR LIMIT=55]-->
    <string name="tare_consumption_limits">Consumption Limits</string>
    <!-- Title for the TARE policy factor that determines the initial maximum amount of credits that
    can be consumed by all the apps [CHAR LIMIT=80]-->
    <string name="tare_initial_consumption_limit">Initial Consumption Limit</string>
    <!-- Title for the TARE policy factor that determines the minimum consumption limit the system
     can have [CHAR LIMIT=80]-->
    <string name="tare_min_consumption_limit">Minimum Consumption Limit</string>
    <!-- Title for the TARE policy factor that determines the maximum consumption limit the system
     can have [CHAR LIMIT=80]-->
    <string name="tare_max_consumption_limit">Maximum Consumption Limit</string>
    <!-- Titles for the consumption limits factors. [CHAR LIMIT=40]-->
    <string-array name="tare_consumption_limit_subfactors" translatable="false">
        <item>@string/tare_initial_consumption_limit</item>
        <item>@string/tare_min_consumption_limit</item>
        <item>@string/tare_max_consumption_limit</item>
    </string-array>
    <!-- Title for the various modifiers that alter the cost of TARE tasks based on battery status
    (charging, power save mode, etc.) [CHAR LIMIT=40]-->
    <string name="tare_modifiers">Modifiers</string>
    <!-- Title for the various TARE policy's actions' cost to produce. "Cost to produce" refers to
     how many credits it costs the system to perform (produce) the action. [CHAR LIMIT=40]-->
    <string name="tare_actions_ctp">Actions (Cost to Produce)</string>
    <!-- Title for the various TARE policy's actions' starting prices [CHAR LIMIT=40]-->
    <string name="tare_actions_base_price">Actions (Base Price)</string>
    <!-- Title for the rewards apps can obtain for each instance of an event that implies the user
    finds the app behavior useful. [CHAR LIMIT=40]-->
    <string name="tare_rewards_instantaneous">Rewards per single event</string>
    <!-- Title for the rewards apps can obtain for the total duration (in seconds) of an event that
    implies the user finds the app behavior useful. [CHAR LIMIT=40]-->
    <string name="tare_rewards_ongoing">Rewards per second of event duration</string>
    <!-- Title for the max rewards apps can obtain within a 24 hour period for different actions
    that benefit the user. [CHAR LIMIT=40]-->
    <string name="tare_rewards_max">Maximum Rewards Per Day</string>
    <!-- Title for the Allow While Idle Exact Wakeup Alarm set via
    AlarmManager.setExactAndAllowWhileIdle() [CHAR LIMIT=50]-->
    <string name="tare_wakeup_exact_idle" translatable="false">
        Allow While Idle Exact Wakeup Alarm</string>
    <!-- Title for the Allow While Idle Inexact Wakeup Alarm set via
    AlarmManager.setAndAllowWhileIdle() [CHAR LIMIT=50]-->
    <string name="tare_wakeup_inexact_idle" translatable="false">
        Allow While Idle Inexact Wakeup Alarm</string>
    <!-- Title for the Exact Wakeup Alarm set via AlarmManager.setExact() [CHAR LIMIT=50]-->
    <string name="tare_wakeup_exact" translatable="false">Exact Wakeup Alarm</string>
    <!-- Title for the Inexact Wakeup Alarm set via AlarmManager.set() [CHAR LIMIT=50]-->
    <string name="tare_wakeup_inexact" translatable="false">Inexact Wakeup Alarm</string>
    <!-- Title for the Allow While Idle Exact NonWakeup Alarm set via
    AlarmManager.setExactAndAllowWhileIdle() [CHAR LIMIT=50]-->
    <string name="tare_nonwakeup_exact_idle" translatable="false">
        Allow While Idle Exact NonWakeup Alarm</string>
    <!-- Title for the Exact NonWakeup Alarm set via AlarmManager.setExact() [CHAR LIMIT=50]-->
    <string name="tare_nonwakeup_exact" translatable="false">Exact NonWakeup Alarm</string>
    <!-- Title for the Allow While Idle Inexact NonWakeup Alarm set via
    AlarmManager.setAndAllowWhileIdle() [CHAR LIMIT=50]-->
    <string name="tare_nonwakeup_inexact_idle" translatable="false">
        Allow While Idle Inexact NonWakeup Alarm</string>
    <!-- Title for the Inexact NonWakeup Alarm set via AlarmManager.set() [CHAR LIMIT=50]-->
    <string name="tare_nonwakeup_inexact" translatable="false">Inexact NonWakeup Alarm</string>
    <!-- Title for the AlarmClock alarm set via AlarmManager.setAlarmClock() [CHAR LIMIT=50]-->
    <string name="tare_alarm_clock" translatable="false">AlarmClock</string>
    <!-- The action of installing an application onto the device [CHAR LIMIT=50]-->
    <string name="tare_app_install">App Install</string>
    <!-- Top activity means an app is in the TOP android process state and is thus visible to the
    user[CHAR LIMIT=50]-->
    <string name="tare_top_activity">Top Activity</string>
    <!-- An event type denoting that a notification was viewed by the user, as defined in
    UsageEvents.java [CHAR LIMIT=50]-->
    <string name="tare_notification_seen">Notification Seen</string>
    <!-- An event type denoting that a notification was viewed by the user within 15 minutes
    [CHAR LIMIT=50]-->
    <string name="tare_notification_seen_15_min">Notification Seen Within 15 Minutes</string>
    <!-- An event type denoting that a notification was interacted with in some way by the user
    [CHAR LIMIT=50]-->
    <string name="tare_notification_interaction">Notification Interaction</string>
    <!-- An event type denoting that an app's widget was interacted with in some way by the user
    [CHAR LIMIT=50]-->
    <string name="tare_widget_interaction">Widget Interaction</string>
    <!-- An event type denoting that an app was interacted with in some way by the user
    [CHAR LIMIT=50]-->
    <string name="tare_other_interaction">Other User Interaction</string>
    <!-- Title for the initiation of a max priority job by an app as defined in the JobScheduler
     API [CHAR LIMIT=50]-->
    <string name="tare_job_max_start">Job Max Start</string>
    <!-- Title of an event where a job with max priority is running, but it does not necessarily
     mean the max priority job is running at that moment. In this context, running is a synonym for
     “ongoing execution of a job with max priority”. [CHAR LIMIT=50]-->
    <string name="tare_job_max_running">Job Max Running</string>
    <!-- Title for the initiation of a high priority job by an app as defined in the JobScheduler
    API [CHAR LIMIT=50]-->
    <string name="tare_job_high_start">Job High Start</string>
    <!-- Title of an event where a job with high priority is running, but it does not necessarily
     mean the high priority job is running at that moment. In this context, running is a synonym for
     “ongoing execution of a job with high priority”. [CHAR LIMIT=50]-->
    <string name="tare_job_high_running">Job High Running</string>
    <!-- Title for the initiation of a default priority job by an app as defined in the JobScheduler
    API [CHAR LIMIT=50]-->
    <string name="tare_job_default_start">Job Default Start</string>
    <!-- Title of an event where a job with default priority is running, but it does not necessarily
     mean the default job is running at that moment. In this context, running is a synonym for
     “ongoing execution of a job with default priority”. [CHAR LIMIT=50]-->
    <string name="tare_job_default_running">Job Default Running</string>
    <!-- Title for the initiation of a low priority job by an app as defined in the JobScheduler
    API [CHAR LIMIT=50]-->
    <string name="tare_job_low_start">Job Low Start</string>
    <!-- Title of an event where a job with low priority is running, but it does not necessarily
     mean the low priority job is running at that moment. In this context, running is a synonym for
     “ongoing execution of a job with low priority”. [CHAR LIMIT=50]-->
    <string name="tare_job_low_running">Job Low Running</string>
    <!-- Title for the initiation of a minimum priority job by an app as defined in the JobScheduler
    API [CHAR LIMIT=50]-->
    <string name="tare_job_min_start">Job Min Start</string>
    <!-- Title of an event where a job with minimum priority is running, but it does not necessarily
     mean the job is running at that moment. In this context, running is a synonym for
     “ongoing execution of a job with minimum priority”. [CHAR LIMIT=50]-->
    <string name="tare_job_min_running">Job Min Running</string>
    <!-- Title for the penalty an app receives for letting a job use the maximum execution time and
     time out [CHAR LIMIT=50]-->
    <string name="tare_job_timeout_penalty">Job Timeout Penalty</string>
    <!-- Title for the TARE factor that determines the minimum credits an app should have when the
    device is fully charged. "Satiated" in this context means that the battery is fully charged.
    Balance is the same meaning as having money in a bank account.
    Exempted apps are those apps exempted from most power saving features. [CHAR LIMIT=80]-->
    <string name="tare_min_balance_exempted">Minimum Satiated Balance (Exempted)</string>
    <!-- Title for the TARE factor that determines the minimum credits an app should have when the
    device is fully charged. "Satiated" in this context means that the battery is fully charged.
    Balance is the same meaning as having money in a bank account.
    A headless system app is a preinstalled app that does not have any activities/UI that the
    user can interact with. [CHAR LIMIT=80]-->
    <string name="tare_min_balance_headless_app">Minimum Satiated Balance (Headless System App)</string>
    <!-- Title for the TARE factor that determines the minimum credits an app should have when the
    device is fully charged. "Satiated" in this context means that the battery is fully charged.
    Balance is the same meaning as having money in a bank account.
    Remaining apps are those apps that don't fit into predefined categories. [CHAR LIMIT=80]-->
    <string name="tare_min_balance_other_app">Minimum Satiated Balance (Remaining Apps)</string>
    <!-- Title for the TARE factor that app updaters (for example, an app store) additional
    credits. "Satiated" in this context means that the battery is fully charged.
    Balance is the same meaning as having money in a bank account. [CHAR LIMIT=80]-->
    <string name="tare_min_balance_addition_app_updater">Minimum Satiated Balance Addition (App Updaters)</string>
    <!-- Titles for the minimum satiated credit balances for different types of apps
    (per battery cycle). Satiated means battery is fully charged. [CHAR LIMIT=40]-->
    <string-array name="tare_app_balance_subfactors" translatable="false">
        <item>@string/tare_max_satiated_balance</item>
        <item>@string/tare_min_balance_exempted</item>
        <item>@string/tare_min_balance_headless_app</item>
        <item>@string/tare_min_balance_other_app</item>
    </string-array>
    <!-- Titles for the minimum satiated credit balances for different types of apps
    (per battery cycle). Satiated means battery is fully charged. [CHAR LIMIT=40]-->
    <string-array name="tare_job_scheduler_app_balance_subfactors" translatable="false">
        <item>@string/tare_max_satiated_balance</item>
        <item>@string/tare_min_balance_exempted</item>
        <item>@string/tare_min_balance_headless_app</item>
        <item>@string/tare_min_balance_other_app</item>
        <item>@string/tare_min_balance_addition_app_updater</item>
    </string-array>
    <!-- Various modifier subfactors that alter the cost of TARE tasks depending on what battery
    state the device is in [CHAR LIMIT=50]-->
    <string-array name="tare_modifiers_subfactors">
        <item>Charging</item>
        <!-- Doze refers to the Android Doze feature -->
        <item>Doze</item>
        <item>Power Save Mode</item>
        <!-- An app's process state is the internal level of an app's process inside the system -->
        <item>Process State</item>
    </string-array>
    <!-- Various AlarmManager alarms with different costs to produce and price paid by apps
    if they want to produce these alarms. Alarm in this context refers to the possible alarm cases
    in AlarmManager. [CHAR LIMIT=50]-->
    <string-array name="tare_alarm_manager_actions" translatable="false">
        <item>@string/tare_wakeup_exact_idle</item>
        <item>@string/tare_wakeup_inexact_idle</item>
        <item>@string/tare_wakeup_exact</item>
        <item>@string/tare_wakeup_inexact</item>
        <item>@string/tare_nonwakeup_exact_idle</item>
        <item>@string/tare_nonwakeup_exact</item>
        <item>@string/tare_nonwakeup_inexact_idle</item>
        <item>@string/tare_nonwakeup_inexact</item>
        <item>@string/tare_alarm_clock</item>
    </string-array>
    <!-- Titles for the different rewards apps could obtain for actions that benefit the user;
    each has instant, ongoing, and max credit rewards apps could gain [CHAR LIMIT=50]-->
    <string-array name="tare_rewards_subfactors" translatable="false">
        <item>@string/tare_top_activity</item>
        <item>@string/tare_notification_seen</item>
        <!-- TODO: add back once supported  <item>@string/tare_notification_seen_15_min</item> -->
        <item>@string/tare_notification_interaction</item>
        <item>@string/tare_widget_interaction</item>
        <item>@string/tare_other_interaction</item>
    </string-array>
    <!-- Titles for the different rewards apps could obtain for actions that benefit the user;
    each has instant, ongoing, and max credit rewards apps could gain [CHAR LIMIT=50]-->
    <string-array name="tare_job_scheduler_rewards_subfactors" translatable="false">
        <item>@string/tare_top_activity</item>
        <item>@string/tare_notification_seen</item>
        <item>@string/tare_notification_interaction</item>
        <item>@string/tare_widget_interaction</item>
        <item>@string/tare_other_interaction</item>
        <item>@string/tare_app_install</item>
    </string-array>
    <!-- Various JobScheduler tasks with different costs to produce and willingness to pay by apps
    if they want to carry out these different tasks [CHAR LIMIT=50]-->
    <string-array name="tare_job_scheduler_actions" translatable="false">
        <item>@string/tare_job_max_start</item>
        <item>@string/tare_job_max_running</item>
        <item>@string/tare_job_high_start</item>
        <item>@string/tare_job_high_running</item>
        <item>@string/tare_job_default_start</item>
        <item>@string/tare_job_default_running</item>
        <item>@string/tare_job_low_start</item>
        <item>@string/tare_job_low_running</item>
        <item>@string/tare_job_min_start</item>
        <item>@string/tare_job_min_running</item>
        <item>@string/tare_job_timeout_penalty</item>
    </string-array>
    <!-- Array used to populate dropdown menu with the different policies in the TARE
    settings [CHAR LIMIT=40]-->
    <string-array name="tare_policies" translatable="false">
        <item>@string/tare_alarmmanager</item>
        <item>@string/tare_jobscheduler</item>
    </string-array>
    <!-- TARE dialog button to proceed with a value change [CHAR LIMIT=none] -->
    <string name="tare_dialog_confirm_button_title">Confirm</string>
    <!-- Array used to populate dropdown menu to select the units of the factor value. Not
    translatable since they're base units. [CHAR LIMIT=40]-->
    <string-array name="tare_units" translatable="false">
        <item>ARC</item>
        <item>Cake</item>
    </string-array>

    <!-- Button to preview the selected screensaver in settings [CHAR LIMIT=40] -->
    <string name="dream_preview_button_title">Preview</string>
    <!-- The title of the category to show for the screensaver selector in settings [CHAR LIMIT=none] -->
    <string name="dream_picker_category">Choose a screen saver</string>
    <!-- The title of the toggle which enables/disables overlays on top of the screen saver [CHAR LIMIT=none] -->
    <string name="dream_complications_toggle_title">Show additional information</string>
    <!-- The summary of what overlays this toggle controls [CHAR LIMIT=none] -->
    <string name="dream_complications_toggle_summary">Display things like the time, weather, or other information on the screen saver</string>
    <!-- The title of the toggle which enables/disables the home controls button on top of the screen saver [CHAR LIMIT=none] -->
    <string name="dream_home_controls_toggle_title">Show home controls</string>
    <!-- The summary of the home controls toggle [CHAR LIMIT=none] -->
    <string name="dream_home_controls_toggle_summary">Show home controls button from the screen saver</string>
    <!-- The title of the category to show for the screensaver miscellaneous settings [CHAR LIMIT=none] -->
    <string name="dream_more_settings_category">More settings</string>
    <!-- The title of the screen saver setup page [CHAR LIMIT=none] -->
    <string name="dream_setup_title">Choose your screen saver</string>
    <!-- The description of the screen saver setup page [CHAR LIMIT=none] -->
    <string name="dream_setup_description">Choose what you’ll see on your screen when your tablet is docked. Your device may use more energy when a screen saver is used.</string>

    <!-- Button to customize the screensaver [CHAR LIMIT=20] -->
    <string name="customize_button_title">Customize</string>
    <!-- The content description for accessibility tools of the customize button. It specifies which screensaver the user is customizing [CHAR LIMIT=NONE] -->
    <string name="customize_button_description">Customize <xliff:g id="screensaver_name" example="Art Gallery">%1$s</xliff:g></string>

    <!-- Dialog body text used to explain a reboot is required after enabling freeform support for
    it to work [CHAR LIMIT=none] -->
    <string name="reboot_dialog_enable_freeform_support">A reboot is required to enable freeform
    support.</string>
    <!-- Dialog body text used to explain a reboot is required after forcing desktop mode on
    secondary dislays. [CHAR LIMIT=none] -->
    <string name="reboot_dialog_force_desktop_mode">A reboot is required to force desktop mode on
    secondary displays.</string>
    <!-- Text on the dialog button to reboot the device now [CHAR LIMIT=50] -->
    <string name="reboot_dialog_reboot_now">Reboot now</string>
    <!-- Text on the dialog button to reboot the device later [CHAR LIMIT=50] -->
    <string name="reboot_dialog_reboot_later">Reboot later</string>

    <!-- The title of the spatial audio [CHAR LIMIT=none] -->
    <string name="bluetooth_details_spatial_audio_title">Spatial Audio</string>
    <!-- The summary of the spatial audio [CHAR LIMIT=none] -->
    <string name="bluetooth_details_spatial_audio_summary">Audio from compatible media becomes more immersive</string>
    <!-- The title of the head tracking [CHAR LIMIT=none] -->
    <string name="bluetooth_details_head_tracking_title">Head tracking</string>
    <!-- The summary of the head tracking [CHAR LIMIT=none] -->
    <string name="bluetooth_details_head_tracking_summary">Audio changes as you move your head to sound more natural</string>

    <!-- The title of CDM Permissions Sync -->
    <string name="bluetooth_details_permissions_sync_title">Sync permissions from phone</string>
    <!-- The summary of CDM Permissions Sync -->
    <string name="bluetooth_details_permissions_sync_summary">Give your watch the same app permissions that you’ve allowed on this phone</string>

    <!-- The title of the bluetooth audio device type selection [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_types_title">Audio Device Type</string>
    <!-- The audio device type corresponding to unknown device type [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_type_unknown">Unknown</string>
    <!-- The audio device type corresponding to speakers [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_type_speaker">Speaker</string>
    <!-- The audio device type corresponding to headphones [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_type_headphones">Headphones</string>
    <!-- The audio device type corresponding to hearing aid [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_type_hearing_aid">Hearing Aid</string>
    <!-- The audio device type corresponding to car kit [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_type_carkit">Car Kit</string>
    <!-- The audio device type corresponding to other device type [CHAR LIMIT=none] -->
    <string name="bluetooth_details_audio_device_type_other">Other</string>

    <!-- Developer Settings: Title for network bandwidth ingress rate limit [CHAR LIMIT=none] -->
    <string name="ingress_rate_limit_title">Network download rate limit</string>
    <!-- Developer Settings: Summary for network bandwidth ingress rate limit [CHAR LIMIT=none] -->
    <string name="ingress_rate_limit_summary">Configure the network bandwidth ingress rate limit which is applied to all networks that provide internet connectivity.</string>
    <!-- Developer Settings: Dialog for network bandwidth ingress rate limit [CHAR LIMIT=none] -->
    <string name="ingress_rate_limit_dialog_title">Configure network download rate limit</string>
    <!-- Developer Settings: Dialog ListPreference option to disable network bandwidth ingress rate limit [CHAR LIMIT=none] -->
    <string name="ingress_rate_limit_no_limit_entry">No limit</string>

    <!-- Developer settings: Title for disabling phantom process monitoring. [CHAR LIMIT=50]-->
    <string name="disable_phantom_process_monitor_title">Disable child process restrictions</string>
    <!-- Developer settings: Summary for disabling phantom process monitoring. [CHAR LIMIT=NONE]-->
    <string name="disable_phantom_process_monitor_summary">Disable restrictions on the system resource usage of the app child processes</string>

    <!-- Developer settings: Title for force enabling Notes role. [CHAR LIMIT=50]-->
    <string name="enable_notes_role_title">Force enable Notes role</string>
    <!-- Developer settings: Summary for disabling phantom process monitoring. [CHAR LIMIT=NONE]-->
    <string name="enable_notes_role_summary">Enable note-taking system integrations via the Notes role. If the Notes role is already enabled, does nothing. Requires reboot.</string>


    <!-- BT LE Audio Device: Media Broadcast -->
    <!-- The title of the Media Broadcast Dialog [CHAR LIMIT=none] -->
    <string name="bluetooth_broadcast_dialog_title">Broadcast</string>
    <!-- [CHAR LIMIT=NONE] Le audio broadcast dialog, switch to others app. -->
    <string name="bluetooth_broadcast_dialog_broadcast_app">Broadcast <xliff:g id="currentApp" example="App Name 2">%1$s</xliff:g></string>
    <!-- The message of the Media Broadcast Dialog for finding broadcast [CHAR LIMIT=none] -->
    <string name="bluetooth_broadcast_dialog_find_message">Listen to broadcasts that are playing near you</string>
    <!-- The message of the Media Broadcast Dialog for broadcast [CHAR LIMIT=none] -->
    <string name="bluetooth_broadcast_dialog_broadcast_message">Broadcast media to devices near you, or listen to someone else’s broadcast</string>
    <!-- The title of the Media Find Broadcast activity [CHAR LIMIT=none] -->
    <string name="bluetooth_find_broadcast_title">Broadcasts</string>
    <!-- The summary of the Media Find Broadcast activity [CHAR LIMIT=none] -->
    <string name="bluetooth_find_broadcast_summary">Listening to</string>
    <!-- The Button of the action to find broadcasts [CHAR LIMIT=none] -->
    <string name="bluetooth_find_broadcast">Find broadcasts</string>
    <!-- The Button of the action to leave the broadcast [CHAR LIMIT=none] -->
    <string name="bluetooth_find_broadcast_button_leave">Leave broadcast</string>
    <!-- The Button of the action to scan QR code [CHAR LIMIT=none] -->
    <string name="bluetooth_find_broadcast_button_scan">Scan QR code</string>
    <!-- The title of enter password dialog in bluetooth find broadcast page. [CHAR LIMIT=none] -->
    <string name="find_broadcast_password_dialog_title">Enter password</string>
    <!-- The error message of enter password dialog in bluetooth find broadcast page [CHAR LIMIT=none] -->
    <string name="find_broadcast_password_dialog_connection_error">Can\u2019t connect. Try again.</string>
    <!-- The error message of enter password dialog in bluetooth find broadcast page [CHAR LIMIT=none] -->
    <string name="find_broadcast_password_dialog_password_error">Wrong password</string>
    <!-- The error message of join the broadcast session by scanning the QR code [CHAR LIMIT=none] -->
    <string name="find_broadcast_join_broadcast_error">Can\u2019t join the broadcast</string>

    <!-- [CHAR LIMIT=NONE] Le audio QR code scanner sub-title -->
    <string name="bt_le_audio_scan_qr_code_scanner">To start listening, center the QR code below</string>
    <!-- [CHAR LIMIT=NONE] Hint for QR code process failure -->
    <string name="bt_le_audio_qr_code_is_not_valid_format">QR code isn\u0027t a valid format</string>

    <!-- Accessibility Software Cursor -->

    <!-- [CHAR LIMIT=NONE] Title for Accessibility Software Cursor setting for trigger hints. -->
    <string name="software_cursor_trigger_hints_enabled_title" translatable="false">Gesture detection area hints</string>
    <!-- [CHAR LIMIT=NONE] Title for Accessibility Software Cursor setting for keyboard shift. -->
    <string name="software_cursor_trigger_keyboard_shift_enabled_title" translatable="false">Shift gesture detection region above keyboard</string>

    <!-- [CHAR LIMIT=NONE] Title for preference: Convert to eSIM -->
    <string name="convert_to_esim_title">Convert to eSIM</string>
    <!-- [CHAR LIMIT=NONE] Title for preference: Transfer eSIM to another device -->
    <string name="transfer_esim_to_another_device_title">Transfer eSIM to another device</string>

    <!-- Background Install Control UI -->
    <!-- [CHAR LIMIT=NONE] Preference Feature Summary -->
    <string name="background_install_preference_summary">{count, plural,
    =1    {# app}
    other {# apps}
    }</string>

    <!-- [CHAR LIMIT=NONE] Feature Title -->
    <string name="background_install_title">Apps installed in the background</string>
    <!-- [CHAR LIMIT=NONE] Feature summary -->
    <string name="background_install_summary">Your device manufacturer may install apps on your device in the background, or allow your carrier and other partners to do so.\u000a\u000aAny apps listed here aren\u0027t required for your device to function normally. You can uninstall apps you don\u0027t want. </string>
    <!-- [CHAR LIMIT=NONE] Group list no entry -->
    <string name="background_install_feature_list_no_entry">No apps installed in the background</string>
    <!-- [CHAR LIMIT=NONE] Uninstall app button content description -->
    <string name="background_install_uninstall_button_description">Uninstall app</string>
    <!-- [CHAR LIMIT=NONE] Before time period group list title -->
    <string name="background_install_before">{count, plural,
    =1    {Apps installed in the last # month}
    other {Apps installed in the last # months}
    }</string>
    <!-- [CHAR LIMIT=NONE] After time period group list title -->
    <string name="background_install_after">{count, plural,
    =1    {Apps installed more than # month ago}
    other {Apps installed more than # months ago}
    }</string>

    <!-- App Aspect Ratio (User Aspect Ratio Override) -->
    <!-- [CHAR LIMIT=60] Aspect ratio title setting to choose app aspect ratio -->
    <string name="aspect_ratio_title">Aspect ratio</string>
    <!-- [CHAR LIMIT=NONE] Aspect ratio setting summary to choose aspect ratio for apps unoptimized for device -->
    <string name="aspect_ratio_summary">Try a new aspect ratio to view this app if it hasn\'t been designed to fit your <xliff:g id="device_name">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Aspect ratio setting main summary on page to choose aspect ratio for apps unoptimized for device -->
    <string name="aspect_ratio_main_summary">Try a new aspect ratio to view this app if it hasn\'t been designed to fit your <xliff:g id="device_name">%1$s</xliff:g>. Some apps may not be optimized for certain aspect ratios.</string>
    <!-- [CHAR LIMIT=NONE] Aspect ratio setting summary to choose aspect ratio for apps unoptimized for device -->
    <string name="aspect_ratio_summary_text">Try a new aspect ratio to view an app if it hasn\'t been designed to fit your <xliff:g id="device_name">%1$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Aspect ratio setting main summary on page to choose aspect ratio for apps unoptimized for device -->
    <string name="aspect_ratio_main_summary_text">Try a new aspect ratio to view an app if it hasn\'t been designed to fit your <xliff:g id="device_name">%1$s</xliff:g>. Some apps may not be optimized for certain aspect ratios.</string>
    <!-- [CHAR LIMIT=NONE] Aspect ratio suggested apps filter label -->
    <string name="user_aspect_ratio_suggested_apps_label">Suggested apps</string>
    <!-- [CHAR LIMIT=14] Filter label for apps that have user aspect ratio changed -->
    <string name="user_aspect_ratio_changed_apps_label">Changed apps</string>
    <!-- [CHAR LIMIT=NONE] App default aspect ratio entry -->
    <string name="user_aspect_ratio_app_default">App default</string>
    <!-- [CHAR LIMIT=NONE] Fullscreen aspect ratio entry -->
    <string name="user_aspect_ratio_fullscreen">Full screen</string>
    <!-- [CHAR LIMIT=NONE] Half screen aspect ratio entry -->
    <string name="user_aspect_ratio_half_screen">Half screen</string>
    <!-- [CHAR LIMIT=NONE] Device display size aspect ratio entry -->
    <string name="user_aspect_ratio_device_size">Device aspect ratio</string>
    <!-- [CHAR LIMIT=NONE] 16:9 aspect ratio entry -->
    <string name="user_aspect_ratio_16_9">16:9</string>
    <!-- [CHAR LIMIT=NONE] 3:2 aspect ratio entry -->
    <string name="user_aspect_ratio_3_2">3:2</string>
    <!-- [CHAR LIMIT=NONE] 4:3 aspect ratio entry -->
    <string name="user_aspect_ratio_4_3">4:3</string>
    <!-- [CHAR LIMIT=NONE] Aspect ratio a11y message announced to replace colon in aspect ratio entry e.g. 3 by 2 -->
    <string name="user_aspect_ratio_option_a11y"><xliff:g id="numerator">%1$s</xliff:g> by <xliff:g id="denominator">%2$s</xliff:g></string>
    <!-- [CHAR LIMIT=NONE] Warning description for app info aspect ratio page -->
    <string name="app_aspect_ratio_footer">The app will restart when you change aspect ratio. You may lose unsaved changes. Some apps may not be optimized for certain aspect ratios.</string>

    <!-- TODO(b/300219974): Change aspect ratio title and clean up unused titles -->
    <!-- [CHAR LIMIT=60] Aspect ratio experimental title settings to choose app aspect ratio -->
    <string name="aspect_ratio_experimental_title">Aspect ratio (experimental)</string>
    <!-- [CHAR LIMIT=60] Aspect ratio experiment title settings to choose app aspect ratio -->
    <string name="aspect_ratio_experiment_title">Aspect ratio (experiment)</string>
    <!-- [CHAR LIMIT=60] Aspect ratio labs title settings to choose app aspect ratio -->
    <string name="aspect_ratio_labs_title">Aspect ratio (labs)</string>
    <!-- [CHAR LIMIT=60] Aspect ratio experimental title label -->
    <string name="aspect_ratio_experimental_label">Experimental</string>
    <!-- [CHAR LIMIT=60] Aspect ratio experiment title label -->
    <string name="aspect_ratio_experiment_label">Experiment</string>
    <!-- [CHAR LIMIT=60] Aspect ratio labs title label -->
    <string name="aspect_ratio_labs_label">Labs</string>

    <!-- Accessibility label for fingerprint sensor [CHAR LIMIT=NONE] -->
    <string name="accessibility_fingerprint_label">Fingerprint sensor</string>

    <!-- Accessibility Flash Notification -->
    <!-- Title of the Flash Notifications entry. [CHAR LIMIT=35] -->
    <string name="flash_notifications_title">Flash notifications</string>
    <!-- Title of the Flash Notifications page footer. [CHAR LIMIT=45] -->
    <string name="flash_notifications_about_title">About flash notifications</string>
    <!-- Summary of the Flash Notifications preference if all flash alerts are off. [CHAR LIMIT=60] -->
    <string name="flash_notifications_summary_off">Off</string>
    <!-- Summary of the Flash Notifications preference if only camera flash is on. [CHAR LIMIT=60] -->
    <string name="flash_notifications_summary_on_camera">On / Camera flash</string>
    <!-- Summary of the Flash Notifications preference if only screen flash is on. [CHAR LIMIT=60] -->
    <string name="flash_notifications_summary_on_screen">On / Screen flash</string>
    <!-- Summary of the Flash Notifications preference if both flash alerts are on. [CHAR LIMIT=60] -->
    <string name="flash_notifications_summary_on_camera_and_screen">On / Camera and screen flash</string>
    <!-- Introduction in Flash Notifications page to introduce flash notifications feature. [CHAR LIMIT=NONE]  -->
    <string name="flash_notifications_intro">Flash the camera light or the screen when you receive notifications or when alarms sound</string>
    <!-- Introduction in Flash Notifications page to introduce flash notifications feature without camera flash option. [CHAR LIMIT=NONE]  -->
    <string name="flash_notifications_intro_without_camera_flash">Flash the screen when you receive notifications or when alarms sound</string>
    <!-- Notes in Flash Notifications page footer for something should be aware. [CHAR LIMIT=NONE]  -->
    <string name="flash_notifications_note">Use flash notifications with caution if you\u0027re light sensitive</string>
    <!-- Search keywords for Flash Notifications settings. [CHAR LIMIT=NONE]  -->
    <string name="flash_notifications_keywords">flash, light, hard of hearing, hearing loss</string>
    <!-- Label of the button to preview the selected Flash Notification effects. [CHAR LIMIT=20]-->
    <string name="flash_notifications_preview">Preview</string>
    <!-- Title of the camera flash in Flash Notification page. [CHAR LIMIT=60] -->
    <string name="camera_flash_notification_title">Camera flash</string>
    <!-- Title of the screen flash in Flash Notification page. [CHAR LIMIT=60] -->
    <string name="screen_flash_notification_title">Screen flash</string>
    <!-- Title of the screen flash color selection dialog. [CHAR LIMIT=NONE] -->
    <string name="screen_flash_notification_color_title">Screen flash color</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_blue">Blue</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_azure">Azure</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_cyan">Cyan</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_spring_green">Spring green</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_green">Green</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_chartreuse_green">Chartreuse green</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_yellow">Yellow</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_orange">Orange</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_red">Red</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_rose">Rose</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_magenta">Magenta</string>
    <!-- Label of the color option show in the summary of screen flash preference. [CHAR LIMIT=60] -->
    <string name="screen_flash_color_violet">Violet</string>
    <!-- Button to save the selection in screen flash color selection dialog. [CHAR LIMIT=20] -->
    <string name="color_selector_dialog_done">Done</string>
    <!-- Button to close the dialog without saving in screen flash color selection dialog. [CHAR LIMIT=20] -->
    <string name="color_selector_dialog_cancel">Cancel</string>

    <!-- Title for the contrast preference fragment [CHAR LIMIT=35] -->
    <string name="contrast_title">Contrast</string>
    <!-- 'Standard' contrast option [CHAR LIMIT=20] -->
    <string name="contrast_standard">Standard</string>
    <!-- 'Medium' contrast option [CHAR LIMIT=20] -->
    <string name="contrast_medium">Medium</string>
    <!-- 'High' contrast option [CHAR LIMIT=20] -->
    <string name="contrast_high">High</string>

    <!-- Warning message when we try to dock an app not supporting multiple instances split into multiple sides [CHAR LIMIT=NONE] -->
    <string name="dock_multi_instances_not_supported_text">"This app can only be opened in 1 window"</string>

    <!-- Shown when an accessibility feature is turned on. Note: for gendered languages, suggest to translate as "Feature on" because the accessibility feature it refers to can be in any gender. [CHAR LIMIT=NONE] -->
    <string name="generic_accessibility_service_on">On</string>
    <!-- Shown when an accessibility feature is turned off. Note: for gendered languages, suggest to translate as "Feature off" because the accessibility feature it refers to can be in any gender. [CHAR LIMIT=NONE] -->
    <string name="generic_accessibility_service_off">Off</string>
    <!-- Shows when the shortcut of an accessibility feature is turned off. The "off" refers to the state of "shortcut". Note: for gendered languages, suggest to translate as "Shortcut off". [CHAR LIMIT=NONE] -->
    <string name="generic_accessibility_feature_shortcut_off">Off</string>
    <!--
        Summary for the disabled state of the accessibility shortcut.
        This is shown as a summary for "[Service] shortcut" from the string resource accessibility_shortcut_title,
        where "off" refers to the state of "shortcut" and
        should match the same gender as the noun used in the string accessibility_shortcut_title.
    -->
    <string name="accessibility_shortcut_state_off">Off</string>

    <!-- Representing daltonizer (color filter) feature is turned on -->
    <string name="daltonizer_state_on">On</string>
    <!-- Representing daltonizer (color filter) feature is turned off -->
    <string name="daltonizer_state_off">Off</string>
    <!-- Representing color inversion feature is turned on -->
    <string name="color_inversion_state_on">On</string>
    <!-- Representing color inversion feature is turned off -->
    <string name="color_inversion_state_off">Off</string>
    <!-- The color inversion feature summary displayed as a subtext as an item in a list. -->
    <string name="color_inversion_feature_summary">Turns light screens dark and dark screens light</string>
    <!-- Summary for the accessibility preference screen to enable screen magnification. [CHAR LIMIT=none] -->
    <string name="magnification_feature_summary">Zoom in on the screen</string>
    <!-- Summary of the AutoClick feature disabled state. -->
    <string name="autoclick_disabled">Off</string>
    <!-- Summary of the show captions preference disabled state. -->
    <string name="show_captions_disabled">Off</string>
    <!-- Summary of the show captions preference enabled state. -->
    <string name="show_captions_enabled">On</string>
    <!-- Summary of the Live Caption disabled state. -->
    <string name="live_caption_disabled">Off</string>
    <!-- Summary of the Live Caption enabled state. -->
    <string name="live_caption_enabled">On</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 you installed. It may also be seen by other people when you connect to Bluetooth devices, connect to a Wi-Fi network or set up a Wi-Fi hotspot.</string>

    <!-- Developer settings: grammatical gender title [CHAR LIMIT=50]-->
    <string name="grammatical_gender_title">Grammatical gender</string>
    <!-- Developer settings: select Grammatical gender dialog title [CHAR LIMIT=50]-->
    <string name="grammatical_gender_dialog_title">Select Grammatical gender</string>

    <!-- Do not translate. Developer settings: Title for the screen allowing user to control Quarantined apps [CHAR LIMIT=50] -->
    <string name="quarantined_apps_title" translatable="false">Quarantined Apps</string>
    <!-- Do not translate. Developer settings: Button to unquarantine an app [CHAR LIMIT=20] -->
    <string name="unquarantine_app_button" translatable="false">Unquarantine app</string>

    <!-- Title of preference to manage content protection settings -->
    <string name="content_protection_preference_title">Scanning for deceptive apps</string>
    <!-- Summary of the preference to manage content protection settings -->
    <string name="content_protection_preference_summary">Check app activity for phishing</string>
    <!-- Title of the switch bar on the subpage of content protection settings -->
    <string name="content_protection_preference_user_consent_switch_title">Use scanning for deceptive apps</string>
    <!-- Title of the toggle switch of work apps on the subpage of content protection settings -->
    <string name="content_protection_preference_user_consent_work_profile_switch_title">Use scanning for deceptive apps for work</string>

    <!-- Default summary of the subpage of content protection settings. Will be overlaid by OEM. -->
    <string name="content_protection_preference_subpage_summary"></string>
    <!-- Default information at the bottom of the subpage of content protection settings. Will be overlaid by OEM. -->
    <string name="content_protection_preference_subpage_info"></string>

    <!-- Content description for setting password complete-->
    <string name="accessibility_setup_password_complete">Password is now set up</string>

    <!-- Authority of the content provider that support methods restartPhoneProcess and restartRild. Will be overlaid by OEM.-->
    <string name="reset_telephony_stack_content_provider_authority" translatable="false"></string>

    <!--Text for Stylus Pointer Icon preference -->
    <string name="show_stylus_pointer_icon">Show pointer while hovering</string>
</resources>
