<?xml version="1.0" encoding="utf-8"?>
<!--
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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">
    <!-- Suffix added to a number to signify size in bytes. -->
    <string name="byteShort">B</string>
    <!-- Suffix added to a number to signify size in kilobytes (1000 bytes).
        If you retain the Latin script for the localization, please use the lowercase
        'k', as it signifies 1000 bytes as opposed to 1024 bytes. -->
    <string name="kilobyteShort">kB</string>
    <!-- Suffix added to a number to signify size in megabytes. -->
    <string name="megabyteShort">MB</string>
    <!-- Suffix added to a number to signify size in gigabytes. -->
    <string name="gigabyteShort">GB</string>
    <!-- Suffix added to a number to signify size in terabytes. -->
    <string name="terabyteShort">TB</string>
    <!-- Suffix added to a number to signify size in petabytes. -->
    <string name="petabyteShort">PB</string>
    <!-- Format string used to add a suffix like "kB" or "MB" to a number
         to display a size in kilobytes, megabytes, or other size units.
         Some languages (like French) will want to add a space between
         the placeholders. -->
    <string name="fileSizeSuffix"><xliff:g id="number" example="123">%1$s</xliff:g> <xliff:g id="unit" example="MB">%2$s</xliff:g></string>

    <!-- Used in Contacts for a field that has no label and in Note Pad
         for a note with no name. -->
    <string name="untitled">&lt;Untitled&gt;</string>

    <!-- How to display the lack of a phone number -->
    <string name="emptyPhoneNumber">(No phone number)</string>

    <!-- How to display the lack of a name -->
    <string name="unknownName">Unknown</string>

    <!-- What the UI should display for "voice mail" unless overridden by the SIM-->
    <string name="defaultVoiceMailAlphaTag">Voicemail</string>

    <!-- What the UI should display for "Msisdn" unless overridden by the SIM-->
    <string name="defaultMsisdnAlphaTag">MSISDN1</string>

    <!-- For GsmMmiCode.java --> <skip />
    <!-- Displayed when the user dialed an MMI code whose function
         could not be performed. This will be displayed in a toast. -->
    <string name="mmiError">Connection problem or invalid MMI code.</string>
    <!-- Displayed when the user dialed an MMI code whose function
         could not be performed because FDN is enabled. This will be displayed in a toast. -->
    <string name="mmiFdnError">Operation is restricted to fixed dialing numbers only.</string>
    <!-- Displayed when a carrier does not support call forwarding queries when roaming. -->
    <string name="mmiErrorWhileRoaming">Can not change call forwarding settings from your phone while you are roaming.</string>

    <!-- Displayed when a phone feature such as call barring was activated. -->
    <string name="serviceEnabled">Service was enabled.</string>
    <!-- Displayed in front of the list of a set of service classes
         (voice, data, fax, etc.) that were enabled. -->
    <string name="serviceEnabledFor">Service was enabled for:</string>
    <!-- Displayed when a phone feature such as call forwarding was deactivated. -->
    <string name="serviceDisabled">Service has been disabled.</string>
    <!-- Displayed when a phone property such as a SIM password was registered. -->
    <string name="serviceRegistered">Registration was successful.</string>
    <!-- Displayed when a phone property such as a SIM password was erased. -->
    <string name="serviceErased">Erasure was successful.</string>
    <!-- Displayed when a SIM password was entered incorrectly. -->
    <string name="passwordIncorrect">Incorrect password.</string>
    <!-- Displayed when a phone feature triggered by an MMI code is complete. -->
    <string name="mmiComplete">MMI complete.</string>
    <!-- Displayed when a SIM PIN password is entered incorrectly. -->
    <string name="badPin">The old PIN you typed isn\'t correct.</string>
    <!-- Displayed when a SIM PUK password is entered incorrectly. -->
    <string name="badPuk">The PUK you typed isn\'t correct.</string>
    <!-- Displayed when SIM PIN passwords are entered inconsistently. -->
    <string name="mismatchPin">The PINs you typed don\'t match.</string>
    <!-- Displayed when a SIM PIN password is too long or too short. -->
    <string name="invalidPin">Type a PIN that is 4 to 8 numbers.</string>
    <!-- Displayed when a SIM PUK password is too short. -->
    <string name="invalidPuk">Type a PUK that is 8 numbers or longer.</string>
    <!-- Displayed to prompt the user to type the PUK password to unlock
         the SIM card. -->
    <string name="needPuk">Your SIM card is PUK-locked. Type the PUK code to unlock it.</string>
    <string name="needPuk2">Type PUK2 to unblock SIM card.</string>
    <!-- Displayed when user attempts to change SIM PIN1 without enabling PIN1. -->
    <string name="enablePin">Unsuccessful, enable SIM/RUIM Lock.</string>
    <!-- Displayed when a SIM PIN/PUK is entered incorrectly. -->
    <plurals name="pinpuk_attempts">
        <item quantity="one">You have <xliff:g id="number">%d</xliff:g> remaining attempt before SIM is locked.</item>
        <item quantity="other">You have <xliff:g id="number">%d</xliff:g> remaining attempts before SIM is locked.</item>
    </plurals>
    <!-- Title for the dialog used to display the user's IMEI number [CHAR LIMIT=10] -->
    <string name="imei">IMEI</string>

    <!-- Title for the dialog used to display the user's MEID number on CDMA network
         [CHAR LIMIT=10] -->
    <string name="meid">MEID</string>

    <!-- Displayed as the title for a success/failure report enabling/disabling caller ID. -->
    <string name="ClipMmi">Incoming Caller ID</string>
    <!-- Displayed as the title for a success/failure report enabling/disabling caller ID. -->
    <string name="ClirMmi">Outgoing Caller ID</string>
    <!-- Displayed as the title for a success/failure report enabling/disabling connected line ID. -->
    <string name="ColpMmi">Connected Line ID</string>
    <!-- Displayed as the title for a success/failure report enabling/disabling connected line ID restriction. -->
    <string name="ColrMmi">Connected Line ID Restriction</string>
    <!-- Displayed as the title for a success/failure report enabling/disabling call forwarding. -->
    <string name="CfMmi">Call forwarding</string>
    <!-- Displayed as the title for a success/failure report enabling/disabling call waiting. -->
    <string name="CwMmi">Call waiting</string>
    <!-- Displayed as the title for a success/failure report enabling/disabling call barring. -->
    <string name="BaMmi">Call barring</string>
    <!-- Displayed as the title for a success/failure report changing the SIM password. -->
    <string name="PwdMmi">Password change</string>
    <!-- Displayed as the title for a success/failure report changing the SIM PIN. -->
    <string name="PinMmi">PIN change</string>
    <string name="CnipMmi">Calling number present</string>
    <string name="CnirMmi">Calling number restricted</string>
    <string name="ThreeWCMmi">Three way calling</string>
    <string name="RuacMmi">Rejection of undesired annoying calls</string>
    <string name="CndMmi">Calling number delivery</string>
    <string name="DndMmi">Do not disturb</string>

    <!-- Displayed to confirm to the user that caller ID will be restricted on the next call as usual. -->
    <string name="CLIRDefaultOnNextCallOn">Caller ID defaults to restricted. Next call: Restricted</string>
    <!-- Displayed to confirm to the user that caller ID will be not restricted on the next call even though it usually is. -->
    <string name="CLIRDefaultOnNextCallOff">Caller ID defaults to restricted. Next call: Not restricted</string>
    <!-- Displayed to confirm to the user that caller ID will not be restricted on the next call but usually is. -->
    <string name="CLIRDefaultOffNextCallOn">Caller ID defaults to not restricted. Next call: Restricted</string>
    <!-- Displayed to confirm to the user that caller ID will not be restricted on the next call or in general. -->
    <string name="CLIRDefaultOffNextCallOff">Caller ID defaults to not restricted. Next call: Not restricted</string>


    <!-- Displayed to tell the user that caller ID is not provisioned for their SIM. -->
    <string name="serviceNotProvisioned">Service not provisioned.</string>
    <!-- Displayed to tell the user that they cannot change the caller ID setting. -->
    <string name="CLIRPermanent">You can\'t change the caller ID setting.</string>

    <!-- Notification title to tell the user that data service is blocked by access control. [CHAR LIMIT=NOTIF_TITLE] -->
    <string name="RestrictedOnDataTitle">No mobile data service</string>
    <!-- Notification title to tell the user that emergency calling is blocked by access control. [CHAR LIMIT=NOTIF_TITLE] -->
    <string name="RestrictedOnEmergencyTitle">Emergency calling unavailable</string>
    <!-- Notification title to tell the user that normal service is blocked by access control. [CHAR LIMIT=NOTIF_TITLE] -->
    <string name="RestrictedOnNormalTitle">No voice service</string>
    <!-- Notification title to tell the user that all emergency and normal voice services are blocked by access control. [CHAR LIMIT=NOTIF_TITLE] -->
    <string name="RestrictedOnAllVoiceTitle">No voice service or emergency calling</string>

    <!-- Notification content to tell the user that voice/data/emergency service is blocked by access control. [CHAR LIMIT=NOTIF_BODY] -->
    <string name="RestrictedStateContent">Temporarily turned off by your carrier</string>

    <!-- Notification content to tell the user that voice/data/emergency service is blocked by access control when multiple SIMs are active. [CHAR LIMIT=NOTIF_BODY] -->
    <string name="RestrictedStateContentMsimTemplate">Temporarily turned off by your carrier for SIM <xliff:g id="simNumber" example="1">%d</xliff:g></string>

    <!-- Displayed to tell the user that they should switch their network preference. -->
    <string name="NetworkPreferenceSwitchTitle">Can\u2019t reach mobile network</string>
    <!-- Displayed to tell the user that they should switch their network preference. -->
    <string name="NetworkPreferenceSwitchSummary">Try changing preferred network. Tap to change.</string>
    <!-- Displayed to tell the user that emergency calls might not be available. -->
    <string name="EmergencyCallWarningTitle">Emergency calling unavailable</string>
    <!-- Displayed to tell the user that emergency calls might not be available. -->
    <string name="EmergencyCallWarningSummary">Can\u2019t make emergency calls over Wi\u2011Fi</string>

    <!-- Telephony notification channel name for a channel containing network alert notifications. -->
    <string name="notification_channel_network_alert">Alerts</string>
    <!-- Telephony notification channel name for a channel containing call forwarding notifications. -->
    <string name="notification_channel_call_forward">Call forwarding</string>
    <!-- Telephony notification channel name for a channel containing emergency callback mode notifications. -->
    <string name="notification_channel_emergency_callback">Emergency callback mode</string>
    <!-- Telephony notification channel name for a channel containing mobile data status notifications. -->
    <string name="notification_channel_mobile_data_status">Mobile data status</string>
    <!-- Telephony notification channel name for a channel containing sms notifications. -->
    <string name="notification_channel_sms">SMS messages</string>
    <!-- Telephony notification channel name for a channel containing voice mail notifications. -->
    <string name="notification_channel_voice_mail">Voicemail messages</string>
    <!-- Telephony notification channel name for a channel containing wifi calling status notifications. -->
    <string name="notification_channel_wfc">Wi-Fi calling</string>
    <!-- Telephony notification channel name for a channel containing SIM notifications -->
    <string name="notification_channel_sim">SIM status</string>
    <!-- Telephony notification channel name for a channel containing high priority SIM notifications -->
    <string name="notification_channel_sim_high_prio">High priority SIM status</string>


    <!-- Displayed to tell the user that peer changed TTY mode -->
    <string name="peerTtyModeFull">Peer requested TTY Mode FULL</string>
    <string name="peerTtyModeHco">Peer requested TTY Mode HCO</string>
    <string name="peerTtyModeVco">Peer requested TTY Mode VCO</string>
    <string name="peerTtyModeOff">Peer requested TTY Mode OFF</string>

    <!-- Mappings between TS 27.007 +CFCC/+CLCK "service classes" and human-readable strings--> <skip />
    <!-- Example: Service was enabled for: Voice, Data -->
    <string name="serviceClassVoice">Voice</string>
    <!-- Example: Service was enabled for: Voice, Data -->
    <string name="serviceClassData">Data</string>
    <!-- Example: Service was enabled for: Voice, FAX -->
    <string name="serviceClassFAX">FAX</string>
    <!-- Example: Service was enabled for: Voice, SMS -->
    <string name="serviceClassSMS">SMS</string>
    <!-- Meaning: asynchronous data.  Example: Service was enabled for: Voice, Async -->
    <string name="serviceClassDataAsync">Async</string>
    <!-- Meaning: synchronous data.  Example: Service was enabled for: Voice, Async -->
    <string name="serviceClassDataSync">Sync</string>
    <!-- Meaning: packet data.  Example: Service was enabled for: Voice, Packet -->
    <string name="serviceClassPacket">Packet</string>
    <!-- Meaning: unknown.  Example: Service was enabled for: Voice, PAD -->
    <string name="serviceClassPAD">PAD</string>

    <!-- CDMA Roaming Indicator Strings (non ERI)--> <skip />
    <!-- Default roaming indicator text -->
    <string name="roamingText0">Roaming Indicator On</string>
    <string name="roamingText1">Roaming Indicator Off</string>
    <string name="roamingText2">Roaming Indicator Flashing</string>
    <string name="roamingText3">Out of Neighborhood</string>
    <string name="roamingText4">Out of Building</string>
    <string name="roamingText5">Roaming - Preferred System</string>
    <string name="roamingText6">Roaming - Available System</string>
    <string name="roamingText7">Roaming - Alliance Partner</string>
    <string name="roamingText8">Roaming - Premium Partner</string>
    <string name="roamingText9">Roaming - Full Service Functionality</string>
    <string name="roamingText10">Roaming - Partial Service Functionality</string>
    <string name="roamingText11">Roaming Banner On</string>
    <string name="roamingText12">Roaming Banner Off</string>
    <string name="roamingTextSearching">Searching for Service</string>

    <!-- Displayed when WFC registration fails -->
    <string name="wfcRegErrorTitle">Couldn\u2019t set up Wi\u2011Fi calling</string>
    <!-- WFC Operator Error Messages showed as alerts -->
    <string-array name="wfcOperatorErrorAlertMessages">
        <item>To make calls and send messages over Wi-Fi, first ask your carrier to set up this service. Then turn on Wi-Fi calling again from Settings. (Error code: <xliff:g id="code" example="REG09 - No 911 Address">%1$s</xliff:g>)</item>
    </string-array>
    <!-- WFC Operator Error Messages showed as notifications -->
    <string-array name="wfcOperatorErrorNotificationMessages">
        <item>Issue registering Wi\u2011Fi calling with your carrier: <xliff:g id="code" example="REG09 - No 911 Address">%1$s</xliff:g></item>
    </string-array>
    <!-- Template for showing mobile network operator name while WFC is active -->
    <string-array name="wfcSpnFormats" translatable="false">
        <item>@string/wfcSpnFormat_spn</item>
        <item>@string/wfcSpnFormat_spn_wifi_calling</item>
        <item>@string/wfcSpnFormat_wlan_call</item>
        <item>@string/wfcSpnFormat_spn_wlan_call</item>
        <item>@string/wfcSpnFormat_spn_wifi</item>
        <item>@string/wfcSpnFormat_wifi_calling_bar_spn</item>
        <item>@string/wfcSpnFormat_spn_vowifi</item>
        <item>@string/wfcSpnFormat_wifi_calling</item>
        <item>@string/wfcSpnFormat_wifi</item>
        <item>@string/wfcSpnFormat_wifi_calling_wo_hyphen</item>
        <item>@string/wfcSpnFormat_vowifi</item>
        <item>@string/wfcSpnFormat_spn_wifi_calling_vo_hyphen</item>
    </string-array>

    <!-- Spn during Wi-Fi Calling: "<operator>" -->
    <string name="wfcSpnFormat_spn"><xliff:g id="spn" example="Operator">%s</xliff:g></string>
    <!-- Spn during Wi-Fi Calling: "<operator> Wi-Fi Calling" -->
    <string name="wfcSpnFormat_spn_wifi_calling"><xliff:g id="spn" example="Operator">%s</xliff:g> Wi-Fi Calling</string>
    <!-- Spn during Wi-Fi Calling: "<operator> WiFi Calling" -->
    <string name="wfcSpnFormat_spn_wifi_calling_vo_hyphen"><xliff:g id="spn" example="Operator">%s</xliff:g> WiFi Calling</string>
    <!-- Spn during Wi-Fi Calling: "WLAN Call" -->
    <string name="wfcSpnFormat_wlan_call">WLAN Call</string>
    <!-- Spn during Wi-Fi Calling: "<operator> WLAN Call" -->
    <string name="wfcSpnFormat_spn_wlan_call"><xliff:g id="spn" example="Operator">%s</xliff:g> WLAN Call</string>
    <!-- Spn during Wi-Fi Calling: "<operator> Wi-Fi" -->
    <string name="wfcSpnFormat_spn_wifi"><xliff:g id="spn" example="Operator">%s</xliff:g> Wi-Fi</string>
    <!-- Spn during Wi-Fi Calling: "WiFi Calling | <operator>" -->
    <string name="wfcSpnFormat_wifi_calling_bar_spn">WiFi Calling | <xliff:g id="spn" example="Operator">%s</xliff:g></string>
    <!-- Spn during Wi-Fi Calling: "<operator> VoWifi" -->
    <string name="wfcSpnFormat_spn_vowifi"><xliff:g id="spn" example="Operator">%s</xliff:g> VoWifi</string>
    <!-- Spn during Wi-Fi Calling: "Wi-Fi Calling" -->
    <string name="wfcSpnFormat_wifi_calling">Wi-Fi Calling</string>
    <!-- Spn during Wi-Fi Calling: "Wi-Fi" -->
    <string name="wfcSpnFormat_wifi">Wi-Fi</string>
    <!-- Spn during Wi-Fi Calling: "WiFi Calling" (without hyphen) -->
    <string name="wfcSpnFormat_wifi_calling_wo_hyphen">WiFi Calling</string>
    <!-- Spn during Wi-Fi Calling: "VoWifi" -->
    <string name="wfcSpnFormat_vowifi">VoWifi</string>

    <!-- WFC, summary for Disabled -->
    <string name="wifi_calling_off_summary">Off</string>
    <!-- WFC, summary for Wi-Fi Preferred -->
    <string name="wfc_mode_wifi_preferred_summary">Call over Wi-Fi</string>
    <!-- WFC, summary for Mobile data Preferred -->
    <string name="wfc_mode_cellular_preferred_summary">Call over mobile network</string>
    <!-- WFC, summary for Wi-Fi Only -->
    <string name="wfc_mode_wifi_only_summary">Wi-Fi only</string>

    <!--
        {0} is one of "bearerServiceCode*"
        {1} is dialing number
        {2} is time in seconds

        cfTemplateRegistered and cfTemplateRegisteredTime mean that a phone number
        has been set but forwarding is not on.
    --> <skip />
    <!-- Displayed when the call forwarding query was not able to be forwarded. -->
    <string name="cfTemplateNotForwarded"><xliff:g id="bearer_service_code">{0}</xliff:g>: Not forwarded</string>
    <!-- Displayed when the call forwarding query was forwarded. -->
    <string name="cfTemplateForwarded"><xliff:g id="bearer_service_code">{0}</xliff:g>: <xliff:g id="dialing_number">{1}</xliff:g></string>
    <!-- Displayed when the call forwarding query will be forwarded after some time. -->
    <string name="cfTemplateForwardedTime"><xliff:g id="bearer_service_code">{0}</xliff:g>: <xliff:g id="dialing_number">{1}</xliff:g> after <xliff:g id="time_delay">{2}</xliff:g> seconds</string>
    <!-- Displayed when the call forwarding query was set but forwarding is not enabled. -->
    <string name="cfTemplateRegistered"><xliff:g id="bearer_service_code">{0}</xliff:g>: Not forwarded</string>
    <!-- Displayed when the call forwarding query was set but forwarding is not enabled. -->
    <string name="cfTemplateRegisteredTime"><xliff:g id="bearer_service_code">{0}</xliff:g>: Not forwarded</string>

    <!-- android.net.http Error strings --> <skip />
    <!-- Displayed when a feature code (non-phone number) is dialed and completes successfully. -->
    <string name="fcComplete">Feature code complete.</string>
    <!-- Displayed when a feature code (non-phone number) is dialed and completes unsuccessfully. -->
    <string name="fcError">Connection problem or invalid feature code.</string>
    <!-- android.net.http Error strings --> <skip />
    <!-- Displayed when a web request was successful. -->
    <string name="httpErrorOk">OK</string>
    <!-- Displayed when a web request failed with a generic network error. -->
    <string name="httpError">There was a network error.</string>
    <!-- Displayed when a web request failed because the URL could not be found. -->
    <string name="httpErrorLookup">Couldn\'t find the URL.</string>
    <!-- Displayed when a web request failed because the site's authentication scheme is not supported by us. -->
    <string name="httpErrorUnsupportedAuthScheme">The site authentication scheme isn\'t supported.</string>
    <!-- Displayed when a web request failed because the authentication failed. -->
    <string name="httpErrorAuth">Couldn\'t authenticate.</string>
    <!-- Displayed when a web request failed because the authentication with the proxy failed. -->
    <string name="httpErrorProxyAuth">Authentication via the proxy server was unsuccessful.</string>
    <!-- Displayed when a web request failed because there was a connection error. -->
    <string name="httpErrorConnect">Couldn\'t connect to the server.</string>
    <!-- Displayed when a web request failed because there was an input or output error. -->
    <string name="httpErrorIO">Couldn\'t communicate with the server. Try again later.</string>
    <!-- Displayed when a web request failed because the request timed out -->
    <string name="httpErrorTimeout">The connection to the server timed out.</string>
    <!-- Displayed when a web request failed because the site tried to redirect us one too many times -->
    <string name="httpErrorRedirectLoop">The page contains too many server redirects.</string>
    <!-- Displayed when a web request failed because the protocol of the server is not supported. -->
    <string name="httpErrorUnsupportedScheme">The protocol isn\'t supported.</string>
    <!-- Displayed when a web request failed because the a secure connection couldn't be made to the server.-->
    <string name="httpErrorFailedSslHandshake">Couldn\'t establish a secure connection.</string>
    <!-- Displayed when a web request failed because the URL isn't in a valid form. -->
    <string name="httpErrorBadUrl">Couldn\'t open the page because the URL is invalid.</string>
    <!-- Displayed when a request failed because we failed to open the file. -->
    <string name="httpErrorFile">Couldn\'t access the file.</string>
    <!-- Displayed when a request failed because the file wasn't found. -->
    <string name="httpErrorFileNotFound">Couldn\'t find the requested file.</string>
    <!-- Displayed when a request failed because there are too many requests right now. -->
    <string name="httpErrorTooManyRequests">Too many requests are being processed. Try again later.</string>

    <!-- Account notifications --> <skip />
    <!-- A notification is shown when the AccountManager is unable to
    supply an auth token without prompting the user to re-enter the
    password.  This is the text that will scroll through the
    notification bar (will be seen by the user as he uses another application). -->
    <string name="notification_title">Signin error for <xliff:g id="account" example="foo@gmail.com">%1$s</xliff:g></string>

    <!-- Sync notifications --> <skip />
    <!-- A notification is shown when there is a sync error.  This is the text that will scroll through the notification bar (will be seen by the user as he uses another application). -->
    <string name="contentServiceSync">Sync</string>
    <!-- A notification is shown when there is a sync error.  This is the title of the notification.  It will be seen in the pull-down notification tray. [CHAR LIMIT=NOTIF_TITLE] -->
    <string name="contentServiceSyncNotificationTitle">Can\'t sync</string>
    <!-- A notification is shown when there is a sync error.  This is the message of the notification.  It describes the error, in this case is there were too many deletes. The argument is the type of content, for example Gmail or Calendar. It will be seen in the pull-down notification tray. [CHAR LIMIT=NOTIF_BODY] -->
    <string name="contentServiceTooManyDeletesNotificationDesc">Attempted to delete too many <xliff:g id="content_type">%s</xliff:g>.</string>

    <!-- If MMS discovers there isn't much space left on the device, it will show a toast with this message. [CHAR LIMIT=TOAST] -->
    <string name="low_memory" product="tablet">Tablet storage is full. Delete some files to free space.</string>
    <!-- If MMS discovers there isn't much space left on the device, it will show a toast with this message. [CHAR LIMIT=TOAST] -->
    <string name="low_memory" product="watch">Watch storage is full. Delete some files to free space.</string>
    <!-- If MMS discovers there isn't much space left on the device, it will show a toast with this message. [CHAR LIMIT=TOAST] -->
    <string name="low_memory" product="tv">Android TV device storage is full. Delete some files to free space.</string>
    <!-- If MMS discovers there isn't much space left on the device, it will show a toast with this message. [CHAR LIMIT=TOAST] -->
    <string name="low_memory" product="default">Phone storage is full. Delete some files to free space.</string>

    <!-- SSL CA cert notification --> <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] -->
    <plurals name="ssl_ca_cert_warning">
        <item quantity="one">Certificate authority installed</item>
        <item quantity="other">Certificate authorities installed</item>
    </plurals>
    <!-- Content text for a notification. The Title of the notification is "ssl_ca_cert_warning".
         This says that an unknown party is doing the monitoring. [CHAR LIMIT=100]-->
    <string name="ssl_ca_cert_noti_by_unknown">By an unknown third party</string>
    <!-- Content text for a notification. The Title of the notification is "ssl_ca_cert_warning".
         This indicates that an unspecified administrator is doing the monitoring. [CHAR LIMIT=100]-->
    <string name="ssl_ca_cert_noti_by_administrator">By your work profile admin</string>
    <!-- Content text for a notification. The Title of the notification is "ssl_ca_cert_warning".
         This indicates who is doing the monitoring. [CHAR LIMIT=100]-->
    <string name="ssl_ca_cert_noti_managed">By <xliff:g id="managing_domain">%s</xliff:g></string>

    <!-- Work profile deleted notification--> <skip />
    <!-- Shows up in the notification's title when the system deletes the work profile. [CHAR LIMIT=NONE] -->
    <string name="work_profile_deleted">Work profile deleted</string>
    <!-- Content text for an expanded notification. The Title of the notification is "Work profile deleted".
        This further explains that the profile is deleted by the system as a result of the current profile admin gone missing. [CHAR LIMIT=NONE]-->
    <string name="work_profile_deleted_details">The work profile admin app is either missing or corrupted.
         As a result, your work profile and related data have been deleted. Contact your admin for assistance.</string>
    <!-- Content text for a notification. The Title of the notification is "Work profile deleted",
        This indicates that a work profile has been deleted. [CHAR LIMIT=NONE]-->
    <string name="work_profile_deleted_description_dpm_wipe">Your work profile is no longer available on this device</string>
    <!-- Content text for a notification. The Title of the notification is "Work profile deleted",
        This indicates that a work profile has been deleted because the maximum failed password attempts as been reached. [CHAR LIMIT=NONE]-->
    <string name="work_profile_deleted_reason_maximum_password_failure">Too many password attempts</string>
    <!-- Shows up as the reason for the work profile deletion when the admin of an organization-owend device relinquishes it. [CHAR LIMIT=NONE] -->
    <string name="device_ownership_relinquished">Admin relinquished device for personal use</string>

    <!-- Content title for a notification. This notification indicates that the device is managed
         and network logging was activated by a device owner. [CHAR LIMIT=NONE]-->
    <string name="network_logging_notification_title">Device is managed</string>
    <!-- Content text for a notification. Tapping opens a dialog with more information on device management and network
         logging. [CHAR LIMIT=NONE]-->
    <string name="network_logging_notification_text">Your organization manages this device and may monitor network traffic. Tap for details.</string>

    <!-- Content title for a notification. This notification indicates that the device owner has
         changed the location settings. [CHAR LIMIT=NONE] -->
    <string name="location_changed_notification_title">Location settings changed by your admin</string>
    <!-- Content text for a notification. Tapping opens device location settings.
         [CHAR LIMIT=NONE] -->
    <string name="location_changed_notification_text">Tap to see your location settings.</string>


    <!-- Factory reset warning dialog strings--> <skip />
    <!-- Shows up in the dialog's title to warn about an impeding factory reset. [CHAR LIMIT=NONE] -->
    <string name="factory_reset_warning">Your device will be erased</string>
    <!-- Text message in the factory reset warning dialog. This says that the the device admin app
         is missing or corrupted. As a result the device will be erased. [CHAR LIMIT=NONE]-->
    <string name="factory_reset_message">The admin app can\'t be used. Your device will now be
        erased.\n\nIf you have questions, contact your organization\'s admin.</string>

    <!-- A toast message displayed when printing is attempted but disabled by policy. -->
    <string name="printing_disabled_by">Printing disabled by <xliff:g id="owner_app">%s</xliff:g>.</string>

    <!-- Content title for a notification that personal apps are suspended [CHAR LIMIT=NONE] -->
    <string name="personal_apps_suspended_notification_title">Personal apps have been suspended by an admin</string>

    <!-- Message for a notification about personal apps suspension when work profile is off. [CHAR LIMIT=NONE] -->
    <string name="personal_apps_suspended_notification_text">Tap here to check policy compliance.</string>

    <!-- Display name for any time a piece of data refers to the owner of the phone. For example, this could be used in place of the phone's phone number. -->
    <string name="me">Me</string>

    <!-- Power Dialog --> <skip />
    <!-- Title for the Phone Options dialog to lock the screen, turn off the phone etc. -->
    <string name="power_dialog" product="tablet">Tablet options</string>
    <!-- Title for the Phone Options dialog to lock the screen, turn off the phone etc. -->
    <string name="power_dialog" product="tv">Android TV options</string>
    <!-- Title for the Phone Options dialog to lock the screen, turn off the phone etc. -->
    <string name="power_dialog" product="default">Phone options</string>
    <!-- Button to turn on silent mode, within the Phone Options dialog -->
    <string name="silent_mode">Silent mode</string>
    <!-- Button to turn on the radio, within the Phone Options dialog -->
    <string name="turn_on_radio">Turn on wireless</string>
    <!-- Button to turn off the radio, within the Phone Options dialog -->
    <string name="turn_off_radio">Turn off wireless</string>
    <!-- Button to lock the screen, within the Phone Options dialog -->
    <string name="screen_lock">Screen lock</string>
    <!-- Button to turn off the phone, within the Phone Options dialog -->
    <string name="power_off">Power off</string>
    <!-- Spoken description for ringer silent option. [CHAR LIMIT=NONE] -->
    <string name="silent_mode_silent">Ringer off</string>
    <!-- Spoken description for ringer vibrate option. [CHAR LIMIT=NONE] -->
    <string name="silent_mode_vibrate">Ringer vibrate</string>
    <!-- Spoken description for ringer normal option. [CHAR LIMIT=NONE] -->
    <string name="silent_mode_ring">Ringer on</string>

    <!-- Reboot to Recovery Progress Dialog. This is shown before it reboots to recovery. -->
    <string name="reboot_to_update_title">Android system update</string>
    <string name="reboot_to_update_prepare">Preparing to update\u2026</string>
    <string name="reboot_to_update_package">Processing the update package\u2026</string>
    <string name="reboot_to_update_reboot">Restarting\u2026</string>

    <!-- Reboot to Recovery for factory reset. -->
    <string name="reboot_to_reset_title">Factory data reset</string>
    <string name="reboot_to_reset_message">Restarting\u2026</string>

    <!-- Shutdown Progress Dialog. This is shown if the user chooses to power off the phone. -->
    <string name="shutdown_progress">Shutting down\u2026</string>

    <!-- Shutdown Confirmation Dialog.  When the user chooses to power off the phone, there will
         be a confirmation dialog.  This is the message. -->
    <string name="shutdown_confirm" product="tablet">Your tablet will shut down.</string>
    <!-- Shutdown Confirmation Dialog.  When the user chooses to power off the TV, there will
         be a confirmation dialog.  This is the message. -->
    <string name="shutdown_confirm" product="tv">Your Android TV device will shut down.</string>
    <!-- Shutdown Confirmation Dialog.  When the user chooses to power off the watch, there will
         be a confirmation dialog.  This is the message. -->
    <string name="shutdown_confirm" product="watch">Your watch will shut down.</string>
    <!-- Shutdown Confirmation Dialog.  When the user chooses to power off the phone, there will
         be a confirmation dialog.  This is the message. -->
    <string name="shutdown_confirm" product="default">Your phone will shut down.</string>

    <!-- Shutdown Confirmation Dialog.  When the user chooses to power off the phone, it asks
         the user if they'd like to shut down.  This is the message.  This is used instead of
         shutdown_confirm when the system is configured to use long press to go directly to the
         power off dialog instead of the global actions menu. -->
    <string name="shutdown_confirm_question">Do you want to shut down?</string>

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

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

    <!-- Recent Tasks dialog: title
     TODO: this should move to SystemUI.apk, but the code for the old
            recent dialog is still in the framework
     -->
    <string name="recent_tasks_title">Recent</string>
    <!-- Recent Tasks dialog: message when there are no recent applications
     TODO: this should move to SystemUI.apk, but the code for the old
            recent dialog is still in the framework
     -->
    <string name="no_recent_tasks">No recent apps.</string>

    <!-- Title of the Global Actions Dialog -->
    <string name="global_actions" product="tablet">Tablet options</string>
    <!-- Title of the Global Actions Dialog -->
    <string name="global_actions" product="tv">Android TV options</string>
    <!-- Title of the Global Actions Dialog -->
    <string name="global_actions" product="default">Phone options</string>

    <!-- label for item that locks the phone in the phone options dialog -->
    <string name="global_action_lock">Screen lock</string>

    <!-- label for item that turns off power in phone options dialog -->
    <string name="global_action_power_off">Power off</string>

    <!-- label for item that restarts phone in phone options dialog -->
    <!-- TODO: promote to separate string-->
    <string name="global_action_restart" translatable="false">@string/sim_restart_button</string>

    <!-- label for item that starts emergency call -->
    <string name="global_action_emergency">Emergency</string>

    <!-- label for item that generates a bug report in the phone options dialog -->
    <string name="global_action_bug_report">Bug report</string>

    <!-- label for item that logouts the current user -->
    <string name="global_action_logout">End session</string>

    <!-- label for screenshot item in power menu -->
    <string name="global_action_screenshot">Screenshot</string>

    <!-- Take bug report menu title [CHAR LIMIT=30] -->
    <string name="bugreport_title">Bug report</string>
    <!-- Message in bugreport dialog describing what it does [CHAR LIMIT=NONE] -->
    <!-- TODO: remove if not used anymore -->
    <string name="bugreport_message">This will collect information about your
        current device state, to send as an e-mail message.  It will take a little
        time from starting the bug report until it is ready to be sent; please be
        patient.</string>
    <!-- Title in the bugreport dialog for the interactive workflow. Should fit in one line. [CHAR LIMIT=30] -->
    <string name="bugreport_option_interactive_title">Interactive report</string>
    <!-- Summary in the bugreport dialog for the interactive workflow. [CHAR LIMIT=NONE] -->
    <string name="bugreport_option_interactive_summary">Use this under most circumstances.
        It allows you to track progress of the report, enter more details about the problem, and take screenshots.
        It might omit some less-used sections that take a long time to report.</string>
    <!-- Title in the bugreport dialog for the full workflow. Should fit in one line. [CHAR LIMIT=30] -->
    <string name="bugreport_option_full_title">Full report</string>
    <!-- Summary in the bugreport dialog for the full workflow. [CHAR LIMIT=NONE] -->
    <string name="bugreport_option_full_summary">Use this option for minimal system interference when
        your device is unresponsive or too slow, or when you need all report sections.
        Does not allow you to enter more details or take additional screenshots.</string>
    <!--  Toast message informing user in how many seconds a bugreport screenshot will be taken -->
    <plurals name="bugreport_countdown">
        <item quantity="one">Taking screenshot for bug report in <xliff:g id="number">%d</xliff:g> second.</item>
        <item quantity="other">Taking screenshot for bug report in <xliff:g id="number">%d</xliff:g> seconds.</item>
    </plurals>

    <!-- Format for build summary info [CHAR LIMIT=NONE] -->
    <string name="bugreport_status" translatable="false">%s (%s)</string>

    <!-- label for item that enables silent mode in phone options dialog -->
    <string name="global_action_toggle_silent_mode">Silent mode</string>

    <!-- status message in phone options dialog for when silent mode is enabled -->
    <string name="global_action_silent_mode_on_status">Sound is OFF</string>

    <!-- status message in phone options dialog for when silent mode is disabled -->
    <string name="global_action_silent_mode_off_status">Sound is ON</string>

    <!-- label for item that toggles airplane mode -->
    <string name="global_actions_toggle_airplane_mode">Airplane mode</string>

    <!-- status message in phone options dialog for when airplane mode is on -->
    <string name="global_actions_airplane_mode_on_status">Airplane mode is ON</string>

    <!-- status message in phone options dialog for when airplane mode is off -->
    <string name="global_actions_airplane_mode_off_status">Airplane mode is OFF</string>

    <!-- label for item that launches settings in phone options dialog [CHAR LIMIT=15]-->
    <string name="global_action_settings">Settings</string>

    <!-- label for item that launches assist in phone options dialog [CHAR LIMIT=15]-->
    <string name="global_action_assist">Assist</string>

    <!-- label for item that launches voice assist in phone options dialog [CHAR LIMIT=15]-->
    <string name="global_action_voice_assist">Voice Assist</string>

    <!-- label for item that locks the phone and enforces that it can't be unlocked without strong authentication. [CHAR LIMIT=15] -->
    <string name="global_action_lockdown">Lockdown</string>

    <!-- Text to use when the number in a notification info is too large
         (greater than status_bar_notification_info_maxnum, defined in
         values/config.xml) and must be truncated. May need to be localized
         for most appropriate textual indicator of "more than X".
         [CHAR LIMIT=4] -->
    <string name="status_bar_notification_info_overflow">999+</string>

    <!-- The divider symbol between different parts of the notification header. not translatable [CHAR LIMIT=1] -->
    <string name="notification_header_divider_symbol" translatable="false">•</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>

    <!-- Text shown in place of notification contents when the notification is hidden on a secure lockscreen -->
    <string name="notification_hidden_text">New notification</string>

    <!-- Text shown when viewing channel settings for notifications related to the virtual keyboard -->
    <string name="notification_channel_virtual_keyboard">Virtual keyboard</string>

    <!-- Text shown when viewing channel settings for notifications related to the hardware keyboard -->
    <string name="notification_channel_physical_keyboard">Physical keyboard</string>

    <!-- Text shown when viewing channel settings for notifications related to security -->
    <string name="notification_channel_security">Security</string>

    <!-- Text shown when viewing channel settings for notifications related to car mode -->
    <string name="notification_channel_car_mode">Car mode</string>

    <!-- Text shown when viewing channel settings for notifications related to account status -->
    <string name="notification_channel_account">Account status</string>

    <!-- Text shown when viewing channel settings for notifications related to developers -->
    <string name="notification_channel_developer">Developer messages</string>

    <!-- Text shown when viewing channel settings for high importance notifications related to developers [CHAR LIMIT=60]-->
    <string name="notification_channel_developer_important">Important developer messages</string>

    <!-- Text shown when viewing channel settings for notifications related to system updates -->
    <string name="notification_channel_updates">Updates</string>

    <!-- Text shown when viewing channel settings for notifications related to network status -->
    <string name="notification_channel_network_status">Network status</string>

    <!-- Text shown when viewing channel settings for notifications related to network alerts -->
    <string name="notification_channel_network_alerts">Network alerts</string>

    <!-- Text shown when viewing the channel settings for notification about open nearby wireless networks. -->
    <string name="notification_channel_network_available">Network available</string>

    <!-- Text shown when viewing channel settings for notifications related to vpn status -->
    <string name="notification_channel_vpn">VPN status</string>

    <!-- Notification channel name. This channel sends high-priority alerts from the user's IT admin for key updates about the user's work device or work profile. -->
    <string name="notification_channel_device_admin">Alerts from your IT admin</string>

    <!-- Text shown when viewing channel settings for notifications related to important alerts -->
    <string name="notification_channel_alerts">Alerts</string>

    <!-- Text shown when viewing channel settings for notifications related to being in retail mode -->
    <string name="notification_channel_retail_mode">Retail demo</string>

    <!-- Text shown when viewing channel settings for notifications related to a usb connection -->
    <string name="notification_channel_usb">USB connection</string>

    <!-- Text shown when viewing channel settings for notification about a heavy-weight app
         currently running.
         [CHAR_LIMIT=NONE] -->
    <string name="notification_channel_heavy_weight_app">App running</string>

    <!-- This is the label for the notification channel settings that controls the behavior
        of the notification about applications that are running in the background (that is,
        perhaps confusingly, running foreground services but not the foreground UI on the screen).
        [CHAR LIMIT=NONE BACKUP_MESSAGE_ID=6665375982962336520] -->
    <string name="notification_channel_foreground_service">Apps consuming battery</string>

    <!-- Label for foreground service notification when one app is running.
    [CHAR LIMIT=NONE BACKUP_MESSAGE_ID=6826789589341671842] -->
    <string name="foreground_service_app_in_background"><xliff:g id="app_name">%1$s</xliff:g> is
        using battery</string>

    <!-- Label for foreground service notification when multiple apps are running.
        [CHAR LIMIT=NONE BACKUP_MESSAGE_ID=7150914856893450380] -->
    <string name="foreground_service_apps_in_background"><xliff:g id="number">%1$d</xliff:g> apps
        are using battery</string>

    <!-- Content for foreground service notification when one app is running.
        [CHAR LIMIT=NONE] -->
    <string name="foreground_service_tap_for_details">Tap for details on battery and
        data usage</string>

    <!-- Separator for foreground service notification content listing all apps when there
        are multiple apps running.  The left and right side may both already be compound
        (constructed using this separator).  Should be kept as short as possible, this is
        for summary text in the notification where there is not a lot of space.
        [CHAR LIMIT=NONE] -->
    <string name="foreground_service_multiple_separator"><xliff:g id="left_side">%1$s</xliff:g>,
        <xliff:g id="right_side">%2$s</xliff:g></string>

    <!-- Displayed to the user to tell them that they have started up the phone in "safe mode" -->
    <string name="safeMode">Safe mode</string>

    <!-- Label for the Android system components when they are shown to the user. -->
    <string name="android_system_label">Android System</string>

    <!-- "Switch" is a verb; it means to change user profile by tapping another user profile name. -->
    <string name="user_owner_label">Switch to personal profile</string>

    <!-- "Switch" is a verb; it means to change user profile by tapping another user profile name. -->
    <string name="managed_profile_label">Switch to work profile</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_contacts">Contacts</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_contacts">access your contacts</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_location">Location</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_location">access this device\'s location</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_calendar">Calendar</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_calendar">access your calendar</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_sms">SMS</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_sms">send and view SMS messages</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_storage">Files and media</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_storage">access photos, media, and files on your device</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_microphone">Microphone</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_microphone">record audio</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=40]-->
    <string name="permgrouplab_activityRecognition">Physical activity</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=40]-->
    <string name="permgroupdesc_activityRecognition">access your physical activity</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_camera">Camera</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_camera">take pictures and record video</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_calllog">Call logs</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_calllog">read and write phone call log</string>

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_phone">Phone</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_phone">make and manage phone calls</string>
    <!-- Message shown to the user when the apps requests permission from this group. If ever possible this should stay below 80 characters (assuming the parameters takes 20 characters). Don't abbreviate until the message reaches 120 characters though. [CHAR LIMIT=120] -->

    <!-- Title of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgrouplab_sensors">Body sensors</string>
    <!-- Description of a category of application permissions, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permgroupdesc_sensors">access sensor data about your vital signs</string>

    <!-- Title for the capability of an accessibility service to retrieve window content. -->
    <string name="capability_title_canRetrieveWindowContent">Retrieve window content</string>
    <!-- Description for the capability of an accessibility service to retrieve window content. -->
    <string name="capability_desc_canRetrieveWindowContent">Inspect the content of a window you\'re
        interacting with.</string>

    <!-- Title for the capability of an accessibility service to request touch exploration. -->
    <string name="capability_title_canRequestTouchExploration">Turn on Explore by Touch</string>
    <!-- Description for the capability of an accessibility service to request touch exploration. -->
    <string name="capability_desc_canRequestTouchExploration">Tapped items will be spoken aloud
        and the screen can be explored using gestures.</string>

    <!-- Title for the capability of an accessibility service to request to filter key events. -->
    <string name="capability_title_canRequestFilterKeyEvents">Observe text you type</string>
    <!-- Description for the capability of an accessibility service to request to filter key events. -->
    <string name="capability_desc_canRequestFilterKeyEvents">Includes personal data such as credit
        card numbers and passwords.</string>

    <!-- Title for the capability of an accessibility service to control display magnification. -->
    <string name="capability_title_canControlMagnification">Control display magnification</string>
    <!-- Description for the capability of an accessibility service to control display magnification. -->
    <string name="capability_desc_canControlMagnification">Control the display\'s zoom level and
        positioning.</string>

    <!-- Title for the capability of an accessibility service to perform gestures. -->
    <string name="capability_title_canPerformGestures">Perform gestures</string>
    <!-- Description for the capability of an accessibility service to perform gestures. -->
    <string name="capability_desc_canPerformGestures">Can tap, swipe, pinch, and perform other
        gestures.</string>

    <!-- Title for the capability of an accessibility service to capture fingerprint gestures. -->
    <string name="capability_title_canCaptureFingerprintGestures">Fingerprint gestures</string>
    <!-- Description for the capability of an accessibility service to perform gestures. -->
    <string name="capability_desc_canCaptureFingerprintGestures">Can capture gestures performed on
        the device\'s fingerprint sensor.</string>

    <!-- Title for the capability of an accessibility service to take screenshot. [CHAR LIMIT=32] -->
    <string name="capability_title_canTakeScreenshot">Take screenshot</string>
    <!-- Description for the capability of an accessibility service to take screenshot. [CHAR LIMIT=NONE] -->
    <string name="capability_desc_canTakeScreenshot">Can take a screenshot of the display.</string>

    <!--  Permissions -->

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_statusBar">disable or modify status bar</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_statusBar">Allows the app to disable the status bar or add and remove system icons.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_statusBarService">be the status bar</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_statusBarService">Allows the app to be the status bar.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_expandStatusBar">expand/collapse status bar</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_expandStatusBar">Allows the app to expand or collapse the status bar.</string>

    <!-- Title of an application permission, listed so the user can install application shortcuts
    in their Launcher -->
    <string name="permlab_install_shortcut">install shortcuts</string>
    <!-- Description of an application permission, listed so the user can install application shortcuts
    in their Launcher -->
    <string name="permdesc_install_shortcut">Allows an application to add
        Homescreen shortcuts without user intervention.</string>

    <!-- Title of an application permission, listed so the user can uninstall application shortcuts
    in their Launcher -->
    <string name="permlab_uninstall_shortcut">uninstall shortcuts</string>
    <!-- Description of an application permission, listed so the user can install application shortcuts
    in their Launcher -->
    <string name="permdesc_uninstall_shortcut">Allows the application to remove
        Homescreen shortcuts without user intervention.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_processOutgoingCalls">reroute outgoing calls</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_processOutgoingCalls">Allows the app to see the
        number being dialed during an outgoing call with the option to redirect
        the call to a different number or abort the call altogether.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_answerPhoneCalls">answer phone calls</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_answerPhoneCalls">Allows the app to answer an incoming phone call.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_receiveSms">receive text messages (SMS)</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_receiveSms">Allows the app to receive and process SMS
      messages. This means the app could monitor or delete messages sent to your
      device without showing them to you.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_receiveMms">receive text messages (MMS)</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_receiveMms">Allows the app to receive and process MMS
      messages. This means the app could monitor or delete messages sent to your
      device without showing them to you.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this.[CHAR LIMIT=NONE] -->
    <string name="permlab_bindCellBroadcastService">Forward cell broadcast messages</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=NONE] -->
    <string name="permdesc_bindCellBroadcastService">Allows the app to bind to the
        cell broadcast module in order to forward cell broadcast messages
        as they are received. Cell broadcast alerts are delivered in some
        locations to warn you of emergency situations. Malicious apps may
        interfere with the performance or operation of your device when an
        emergency cell broadcast is received.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readCellBroadcasts">read cell broadcast messages</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readCellBroadcasts">Allows the app to read
        cell broadcast messages received by your device. Cell broadcast alerts
        are delivered in some locations to warn you of emergency situations.
        Malicious apps may interfere with the performance or operation of your
        device when an emergency cell broadcast is received.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_subscribedFeedsRead">read subscribed feeds</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_subscribedFeedsRead">Allows the app to get details about the currently synced feeds.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_sendSms">send and view SMS messages</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_sendSms">Allows the app to send SMS messages.
     This may result in unexpected charges. Malicious apps may cost you money by
     sending messages without your confirmation.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readSms">read your text messages (SMS or MMS)</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readSms" product="tablet">This app can read all SMS (text) messages stored on your tablet.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readSms" product="tv">This app can read all SMS (text) messages stored on your Android TV device.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readSms" product="default">This app can read all SMS (text) messages stored on your phone.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_receiveWapPush">receive text messages (WAP)</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_receiveWapPush">Allows the app to receive and process
     WAP messages.  This permission includes the ability to monitor or delete
     messages sent to you without showing them to you.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_getTasks">retrieve running apps</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_getTasks">Allows the app to retrieve information
       about currently and recently running tasks.  This may allow the app to
       discover information about which applications are used on the device.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_manageProfileAndDeviceOwners">manage profile and device owners</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to set the profile/device owners.
     [CHAR LIMIT=NONE] -->
    <string name="permdesc_manageProfileAndDeviceOwners">Allows apps to set the profile owners and the device owner.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_reorderTasks">reorder running apps</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_reorderTasks">Allows the app to move tasks to the
      foreground and background.  The app may do this without your input.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_enableCarMode">enable car mode</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_enableCarMode">Allows the app to
        enable the car mode.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_killBackgroundProcesses">close other apps</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_killBackgroundProcesses">Allows the app to end
      background processes of other apps.  This may cause other apps to stop
      running.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_systemAlertWindow">This app can appear on top of other apps</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_systemAlertWindow">This app can appear on top of other apps or other parts of the screen. This may interfere with normal app usage and change the way that other apps appear.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_runInBackground">run in the background</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_runInBackground">This app can run in the background. This may drain battery faster.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_useDataInBackground">use data in the background</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_useDataInBackground">This app can use data in the background. This may increase data usage.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_persistentActivity">make app always run</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_persistentActivity" product="tablet">Allows the app to make parts of itself persistent in memory.  This can limit memory available to other apps slowing down the tablet.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_persistentActivity" product="tv">Allows the app to make parts of itself persistent in memory.  This can limit memory available to other apps slowing down your Android TV device.</string>
    <string name="permdesc_persistentActivity" product="default">Allows the app to make parts of itself persistent in memory.  This can limit memory available to other apps slowing down the phone.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_foregroundService">run foreground service</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_foregroundService">Allows the app to make use of foreground services.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_getPackageSize">measure app storage space</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_getPackageSize">Allows the app to retrieve its code, data, and cache sizes</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_writeSettings">modify system settings</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeSettings">Allows the app to modify the
        system\'s settings data. Malicious apps may corrupt your system\'s
        configuration.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_receiveBootCompleted">run at startup</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_receiveBootCompleted" product="tablet">Allows the app to
        have itself started as soon as the system has finished booting.
        This can make it take longer to start the tablet and allow the
        app to slow down the overall tablet by always running.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_receiveBootCompleted" product="tv">Allows the app to
        have itself started as soon as the system has finished booting.
        This can make it take longer to start your Android TV device and allow the
        app to slow down the overall device by always running.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_receiveBootCompleted" product="default">Allows the app to
        have itself started as soon as the system has finished booting.
        This can make it take longer to start the phone and allow the
        app to slow down the overall phone by always running.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_broadcastSticky">send sticky broadcast</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_broadcastSticky" product="tablet">Allows the app to
    send sticky broadcasts, which remain after the broadcast ends. Excessive use
    may make the tablet slow or unstable by causing it to use too much memory.
    </string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_broadcastSticky" product="tv">Allows the app to
    send sticky broadcasts, which remain after the broadcast ends. Excessive use
    may make your Android TV device slow or unstable by causing it to use too much memory.
    </string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_broadcastSticky" product="default">Allows the app to
    send sticky broadcasts, which remain after the broadcast ends. Excessive
    use may make the phone slow or unstable by causing it to use too
    much memory.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readContacts">read your contacts</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readContacts" product="tablet">Allows the app to read data about your contacts stored on your tablet.
      Apps will also have access to the accounts on your tablet that have created contacts.
      This may include accounts created by apps you have installed.
      This permission allows apps to save your contact data, and malicious apps may share contact data without your knowledge.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readContacts" product="tv">Allows the app to read data about your contacts stored on your Android TV device.
      Apps will also have access to the accounts on your Android TV device that have created contacts.
      This may include accounts created by apps you have installed.
      This permission allows apps to save your contact data, and malicious apps may share contact data without your knowledge.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readContacts" product="default">Allows the app to read data about your contacts stored on your phone.
      Apps will also have access to the accounts on your phone that have created contacts.
      This may include accounts created by apps you have installed.
      This permission allows apps to save your contact data, and malicious apps may share contact data without your knowledge.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_writeContacts">modify your contacts</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeContacts" product="tablet">Allows the app to modify the data about your contacts stored on your tablet.
      This permission allows apps to delete contact data.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeContacts" product="tv">Allows the app to modify the data about your contacts stored on your Android TV device.
      This permission allows apps to delete contact data.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeContacts" product="default">Allows the app to modify the data about your contacts stored on your phone.
      This permission allows apps to delete contact data.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readCallLog">read call log</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readCallLog">This app can read your call history.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_writeCallLog">write call log</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeCallLog" product="tablet">Allows the app to modify your tablet\'s call log, including data about incoming and outgoing calls.
        Malicious apps may use this to erase or modify your call log.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeCallLog" product="tv">Allows the app to modify your Android TV device\'s call log, including data about incoming and outgoing calls.
        Malicious apps may use this to erase or modify your call log.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeCallLog" product="default">Allows the app to modify your phone\'s call log, including data about incoming and outgoing calls.
        Malicious apps may use this to erase or modify your call log.</string>

    <!-- Title of the body sensors permission, listed so the user can decide whether to allow the application to access body sensor data. [CHAR LIMIT=80] -->
    <string name="permlab_bodySensors">access body sensors (like heart rate monitors)
    </string>
    <!-- Description of the body sensors permission, listed so the user can decide whether to allow the application to access data from body sensors. [CHAR LIMIT=NONE] -->
    <string name="permdesc_bodySensors" product="default">Allows the app to access data from sensors
    that monitor your physical condition, such as your heart rate.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readCalendar">Read calendar events and details</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readCalendar" product="tablet">This app can read all calendar events stored on your tablet and share or save your calendar data.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readCalendar" product="tv">This app can read all calendar events stored on your Android TV device and share or save your calendar data.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readCalendar" product="default">This app can read all calendar events stored on your phone and share or save your calendar data.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_writeCalendar">add or modify calendar events and send email to guests without owners\' knowledge</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeCalendar" product="tablet">This app can add, remove, or change calendar events on your tablet. This app can send messages that may appear to come from calendar owners, or change events without notifying their owners.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeCalendar" product="tv">This app can add, remove, or change calendar events on your Android TV device. This app can send messages that may appear to come from calendar owners, or change events without notifying their owners.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeCalendar" product="default">This app can add, remove, or change calendar events on your phone. This app can send messages that may appear to come from calendar owners, or change events without notifying their owners.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the applicatfion to do this. -->
    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessLocationExtraCommands">access extra location provider commands</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessLocationExtraCommands">Allows the app to access
        extra location provider commands.  This may allow the app to interfere
        with the operation of the GPS or other location sources.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessFineLocation">access precise location only in the foreground</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessFineLocation">This app can get your exact location only when it is in the foreground. Location services must be turned on and available on your device for the app to be able to use them. This may increase battery consumption.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessCoarseLocation">access approximate location only in the foreground</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessCoarseLocation">This app can get your approximate location only when it is in the foreground. Location services must be turned on and available on your device for the app to be able to use them.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessBackgroundLocation">access location in the background</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessBackgroundLocation">This app can access location while running in the background, in addition to foreground location access.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_modifyAudioSettings">change your audio settings</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_modifyAudioSettings">Allows the app to modify global audio settings such as volume and which speaker is used for output.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_recordAudio">record audio</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_recordAudio">This app can record audio using the microphone at any time.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_sim_communication">send commands to the SIM</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_sim_communication">Allows the app to send commands to the SIM. This is very dangerous.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=50]-->
    <string name="permlab_activityRecognition">recognize physical activity</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=120]-->
    <string name="permdesc_activityRecognition">This app can recognize your physical activity.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_camera">take pictures and videos</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_camera">This app can take pictures and record videos using the camera at any time.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR_LIMIT=NONE] -->
    <string name="permlab_systemCamera">Allow an application or service access to system cameras to take pictures and videos</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR_LIMIT=NONE] -->
    <string name="permdesc_systemCamera">This privileged | system app can take pictures and record videos using a system camera at any time. Requires the android.permission.CAMERA permission to be held by the app as well</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_vibrate">control vibration</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_vibrate">Allows the app to control the vibrator.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_vibrator_state">Allows the app to access the vibrator state.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_callPhone">directly call phone numbers</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_callPhone">Allows the app to call phone numbers
      without your intervention. This may result in unexpected charges or calls.
      Note that this doesn\'t allow the app to call emergency numbers.
      Malicious apps may cost you money by making calls without your
      confirmation.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessImsCallService">access IMS call service</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessImsCallService">Allows the app to use the IMS service to make calls without your intervention.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readPhoneState">read phone status and identity</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readPhoneState">Allows the app to access the phone
      features of the device.  This permission allows the app to determine the
      phone number and device IDs, whether a call is active, and the remote number
      connected by a call.</string>

    <!-- Title of an application permission.  When granted the user is giving access to a third
         party app to route its calls through the system. -->
    <string name="permlab_manageOwnCalls">route calls through the system</string>
    <!-- Description of an application permission.  When granted the user is giving access to a
         third party app to route its calls through the system. -->
    <string name="permdesc_manageOwnCalls">Allows the app to route its calls through the system in
        order to improve the calling experience.</string>

    <!-- Title of an application permission. When granted the app is allowed to be enabled as
        a companion app. [CHAR LIMIT=NONE]-->
    <string name="permlab_callCompanionApp">see and control calls through the system.</string>
    <!-- Description of an application permission. When granted the app is allowed to be enabled as
        a companion app. [CHAR LIMIT=NONE]-->
    <string name="permdesc_callCompanionApp">Allows the app to see and control ongoing calls on the
        device. This includes information such as call numbers for calls and the state of the
        calls.</string>

    <!-- Title of an application permission.  When granted the user is giving access to a third
         party app to continue a call which originated in another app.  For example, the user
         could be in a voice call over their carrier's mobile network, and a third party video
         calling app wants to continue that voice call as a video call. -->
    <string name="permlab_acceptHandover">continue a call from another app</string>
    <!-- Description of an application permission.  When granted the user is giving access to a
         third party app to continue a call which originated in another app.  For example, the user
         could be in a voice call over their carrier's mobile network, and a third party video
         calling app wants to continue that voice call as a video call -->
    <string name="permdesc_acceptHandovers">Allows the app to continue a call which was started in another app.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readPhoneNumbers">read phone numbers</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readPhoneNumbers">Allows the app to access the phone numbers of the device.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_wakeLock" product="tablet">prevent tablet from sleeping</string>
    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_wakeLock" product="tv">prevent your Android TV device from sleeping</string>
    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_wakeLock" product="default">prevent phone from sleeping</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_wakeLock" product="tablet">Allows the app to prevent the tablet from going to sleep.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_wakeLock" product="tv">Allows the app to prevent your Android TV device from going to sleep.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_wakeLock" product="default">Allows the app to prevent the phone from going to sleep.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_transmitIr">transmit infrared</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_transmitIr" product="tablet">Allows the app to use the tablet\'s infrared transmitter.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_transmitIr" product="tv">Allows the app to use your Android TV device\'s infrared transmitter.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_transmitIr" product="default">Allows the app to use the phone\'s infrared transmitter.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_setWallpaper">set wallpaper</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_setWallpaper">Allows the app to set the system wallpaper.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_setWallpaperHints">adjust your wallpaper size</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_setWallpaperHints">Allows the app to set the system wallpaper size hints.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_setTimeZone">set time zone</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_setTimeZone" product="tablet">Allows the app to change the tablet\'s time zone.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_setTimeZone" product="tv">Allows the app to change your Android TV device\'s time zone.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_setTimeZone" product="default">Allows the app to change the phone\'s time zone.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_getAccounts">find accounts on the device</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_getAccounts" product="tablet">Allows the app to get
      the list of accounts known by the tablet.  This may include any accounts
      created by applications you have installed.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_getAccounts" product="tv">Allows the app to get
      the list of accounts known by your Android TV device.  This may include any accounts
      created by applications you have installed.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_getAccounts" product="default">Allows the app to get
      the list of accounts known by the phone.  This may include any accounts
      created by applications you have installed.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessNetworkState">view network connections</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessNetworkState">Allows the app to view
      information about network connections such as which networks exist and are
      connected.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_createNetworkSockets">have full network access</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_createNetworkSockets">Allows the app to create
     network sockets and use custom network protocols. The browser and other
     applications provide means to send data to the internet, so this
     permission is not required to send data to the internet.</string>

 <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_changeNetworkState">change network connectivity</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_changeNetworkState">Allows the app to change the state of network connectivity.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_changeTetherState">change tethered connectivity</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the applicaiton to do this. -->
    <string name="permdesc_changeTetherState">Allows the app to change the state of tethered network connectivity.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessWifiState">view Wi-Fi connections</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessWifiState">Allows the app to view information
      about Wi-Fi networking, such as whether Wi-Fi is enabled and name of
      connected Wi-Fi devices.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_changeWifiState">connect and disconnect from Wi-Fi</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_changeWifiState">Allows the app to connect to and
      disconnect from Wi-Fi access points and to make changes to device
      configuration for Wi-Fi networks.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_changeWifiMulticastState">allow Wi-Fi Multicast reception</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_changeWifiMulticastState" product="tablet">Allows the app to receive
      packets sent to all devices on a Wi-Fi network using multicast addresses,
      not just your tablet.  It uses more power than the non-multicast mode.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_changeWifiMulticastState" product="tv">Allows the app to receive
      packets sent to all devices on a Wi-Fi network using multicast addresses,
      not just your Android TV device.  It uses more power than the non-multicast mode.</string>
    <string name="permdesc_changeWifiMulticastState" product="default">Allows the app to receive
      packets sent to all devices on a Wi-Fi network using multicast addresses,
      not just your phone.  It uses more power than the non-multicast mode.</string>

 <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bluetoothAdmin">access Bluetooth settings</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bluetoothAdmin" product="tablet">Allows the app to
      configure the local Bluetooth tablet, and to discover and pair with remote
      devices.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bluetoothAdmin" product="tv">Allows the app to
      configure Bluetooth on your Android TV device, and to discover and pair with remote
      devices.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bluetoothAdmin" product="default">Allows the app to configure
      the local Bluetooth phone, and to discover and pair with remote devices.</string>

    <string name="permlab_accessWimaxState">connect and disconnect from WiMAX</string>
    <string name="permdesc_accessWimaxState">Allows the app to determine whether
     WiMAX is enabled and information about any WiMAX networks that are
     connected. </string>

    <string name="permlab_changeWimaxState">change WiMAX state</string>
    <string name="permdesc_changeWimaxState" product="tablet">Allows the app to
      connect the tablet to and disconnect the tablet from WiMAX networks.</string>
    <string name="permdesc_changeWimaxState" product="tv">Allows the app to
      connect your Android TV device to and disconnect your Android TV device from WiMAX networks.</string>
    <string name="permdesc_changeWimaxState" product="default">Allows the app to
      connect the phone to and disconnect the phone from WiMAX networks.</string>

 <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bluetooth">pair with Bluetooth devices</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bluetooth" product="tablet">Allows the app to view the
      configuration of Bluetooth on the tablet, and to make and accept
      connections with paired devices.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bluetooth" product="tv">Allows the app to view the
      configuration of Bluetooth on your Android TV device, and to make and accept
      connections with paired devices.</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bluetooth" product="default">Allows the app to view the
      configuration of the Bluetooth on the phone, and to make and accept
      connections with paired devices.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_preferredPaymentInfo">Preferred NFC Payment Service Information</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_preferredPaymentInfo">Allows the app to get preferred nfc payment service information like
      registered aids and route destination.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_nfc">control Near Field Communication</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_nfc">Allows the app to communicate
      with Near Field Communication (NFC) tags, cards, and readers.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_disableKeyguard">disable your screen lock</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_disableKeyguard">Allows the app to disable the
      keylock and any associated password security.  For example, the phone
      disables the keylock when receiving an incoming phone call, then
      re-enables the keylock when the call is finished.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR_LIMIT=NONE] -->
    <string name="permlab_requestPasswordComplexity">request screen lock complexity</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR_LIMIT=NONE] -->
    <string name="permdesc_requestPasswordComplexity">Allows the app to learn the screen
        lock complexity level (high, medium, low or none), which indicates the possible range of
        length and type of the screen lock. The app can also suggest to users that they update the
        screen lock to a certain level but users can freely ignore and navigate away. Note that the
        screen lock is not stored in plaintext so the app does not know the exact password.
    </string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR_LIMIT=NONE] -->
    <string name="permlab_useBiometric">use biometric hardware</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this.[CHAR_LIMIT=NONE] -->
    <string name="permdesc_useBiometric">Allows the app to use biometric hardware for authentication</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_manageFingerprint">manage fingerprint hardware</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_manageFingerprint">Allows the app to invoke methods to add and delete fingerprint templates for use.</string>
    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_useFingerprint">use fingerprint hardware</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_useFingerprint">Allows the app to use fingerprint hardware for authentication</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_audioWrite">modify your music collection</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_audioWrite">Allows the app to modify your music collection.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_videoWrite">modify your video collection</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_videoWrite">Allows the app to modify your video collection.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_imagesWrite">modify your photo collection</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_imagesWrite">Allows the app to modify your photo collection.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_mediaLocation">read locations from your media collection</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_mediaLocation">Allows the app to read locations from your media collection.</string>

    <!-- Title shown when the system-provided biometric dialog is shown, asking the user to authenticate. [CHAR LIMIT=40] -->
    <string name="biometric_dialog_default_title">Verify it\u2018s you</string>
    <!-- Message shown when biometric hardware is not available [CHAR LIMIT=50] -->
    <string name="biometric_error_hw_unavailable">Biometric hardware unavailable</string>
    <!-- Message shown when biometric authentication was canceled by the user [CHAR LIMIT=50] -->
    <string name="biometric_error_user_canceled">Authentication canceled</string>
    <!-- Message shown by the biometric dialog when biometric is not recognized -->
    <string name="biometric_not_recognized">Not recognized</string>
    <!-- Message shown when biometric authentication has been canceled [CHAR LIMIT=50] -->
    <string name="biometric_error_canceled">Authentication canceled</string>
    <!-- Message returned to applications if BiometricPrompt setAllowDeviceCredentials is enabled but no pin, pattern, or password is set. [CHAR LIMIT=NONE] -->
    <string name="biometric_error_device_not_secured">No pin, pattern, or password set</string>

    <!-- Message shown during fingerprint acquisision when the fingerprint cannot be recognized -->
    <string name="fingerprint_acquired_partial">Partial fingerprint detected. Please try again.</string>
    <!-- Message shown during fingerprint acquisision when the fingerprint cannot be recognized -->
    <string name="fingerprint_acquired_insufficient">Couldn\'t process fingerprint. Please try again.</string>
    <!-- Message shown during fingerprint acquisision when the fingerprint sensor needs cleaning -->
    <string name="fingerprint_acquired_imager_dirty">Fingerprint sensor is dirty. Please clean and try again.</string>
    <!-- Message shown during fingerprint acquisision when the user removes their finger from the sensor too quickly -->
    <string name="fingerprint_acquired_too_fast">Finger moved too fast. Please try again.</string>
    <!-- Message shown during fingerprint acquisision when the user moves their finger too slowly -->
    <string name="fingerprint_acquired_too_slow">Finger moved too slow. Please try again.</string>
    <!-- Array containing custom messages shown during fingerprint acquisision from vendor.  Vendor is expected to add and translate these strings -->
    <string-array name="fingerprint_acquired_vendor">
    </string-array>

    <!-- Accessibility message announced when a fingerprint has been authenticated [CHAR LIMIT=NONE] -->
    <string name="fingerprint_authenticated">Fingerprint authenticated</string>
    <!-- Accessibility message announced when a face has been authenticated [CHAR LIMIT=NONE] -->
    <string name="face_authenticated_no_confirmation_required">Face authenticated</string>
    <!-- Accessibility message announced when a face has been authenticated, but requires the user to press the confirm button [CHAR LIMIT=NONE] -->
    <string name="face_authenticated_confirmation_required">Face authenticated, please press confirm</string>

    <!-- Error message shown when the fingerprint hardware can't be accessed -->
    <string name="fingerprint_error_hw_not_available">Fingerprint hardware not available.</string>
    <!-- Error message shown when the fingerprint hardware has run out of room for storing fingerprints -->
    <string name="fingerprint_error_no_space">Fingerprint can\'t be stored. Please remove an existing fingerprint.</string>
    <!-- Error message shown when the fingerprint hardware timer has expired and the user needs to restart the operation. -->
    <string name="fingerprint_error_timeout">Fingerprint time out reached. Try again.</string>
    <!-- Generic error message shown when the fingerprint operation (e.g. enrollment or authentication) is canceled. Generally not shown to the user-->
    <string name="fingerprint_error_canceled">Fingerprint operation canceled.</string>
    <!-- Generic error message shown when the fingerprint authentication operation is canceled due to user input. Generally not shown to the user -->
    <string name="fingerprint_error_user_canceled">Fingerprint operation canceled by user.</string>
    <!-- Generic error message shown when the fingerprint operation fails because too many attempts have been made. -->
    <string name="fingerprint_error_lockout">Too many attempts. Try again later.</string>
    <!-- Generic error message shown when the fingerprint operation fails because strong authentication is required -->
    <string name="fingerprint_error_lockout_permanent">Too many attempts. Fingerprint sensor disabled.</string>
    <!-- Generic error message shown when the fingerprint hardware can't recognize the fingerprint -->
    <string name="fingerprint_error_unable_to_process">Try again.</string>
    <!-- Generic error message shown when the user has no enrolled fingerprints -->
    <string name="fingerprint_error_no_fingerprints">No fingerprints enrolled.</string>
    <!-- Generic error message shown when the app requests fingerprint authentication on a device without a sensor -->
    <string name="fingerprint_error_hw_not_present">This device does not have a fingerprint sensor.</string>
    <!-- Generic error message shown when fingerprint is not available due to a security vulnerability. [CHAR LIMIT=50] -->
    <string name="fingerprint_error_security_update_required">Sensor temporarily disabled.</string>

    <!-- Template to be used to name enrolled fingerprints by default. -->
    <string name="fingerprint_name_template">Finger <xliff:g id="fingerId" example="1">%d</xliff:g></string>

    <!-- Array containing custom error messages from vendor.  Vendor is expected to add and translate these strings -->
    <string-array name="fingerprint_error_vendor">
    </string-array>

    <!-- Content description which should be used for the fingerprint icon. -->
    <string name="fingerprint_icon_content_description">Fingerprint icon</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=70] -->
    <string name="permlab_manageFace">manage face unlock hardware</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=90] -->
    <string name="permdesc_manageFace">Allows the app to invoke methods to add and delete facial templates for use.</string>
    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=70] -->
    <string name="permlab_useFaceAuthentication">use face unlock hardware</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. [CHAR LIMIT=90] -->
    <string name="permdesc_useFaceAuthentication">Allows the app to use face unlock hardware for authentication</string>

    <!-- Notification name shown when the system requires the user to re-enroll their face. [CHAR LIMIT=NONE] -->
    <string name="face_recalibrate_notification_name">Face unlock</string>
    <!-- Notification title shown when the system requires the user to re-enroll their face. [CHAR LIMIT=NONE] -->
    <string name="face_recalibrate_notification_title">Re-enroll your face</string>
    <!-- Notification content shown when the system requires the user to re-enroll their face. [CHAR LIMIT=NONE] -->
    <string name="face_recalibrate_notification_content">To improve recognition, please re-enroll your face</string>

    <!-- Message shown during face acquisition when the face cannot be recognized [CHAR LIMIT=50] -->
    <string name="face_acquired_insufficient">Couldn\u2019t capture accurate face data. Try again.</string>
    <!-- Message shown during face acquisition when the image is too bright [CHAR LIMIT=50] -->
    <string name="face_acquired_too_bright">Too bright. Try gentler lighting.</string>
    <!-- Message shown during face acquisition when the image is too dark [CHAR LIMIT=50] -->
    <string name="face_acquired_too_dark">Too dark. Try brighter lighting.</string>
    <!-- Message shown during face acquisition when the user is too close to sensor [CHAR LIMIT=50] -->
    <string name="face_acquired_too_close">Move phone farther away.</string>
    <!-- Message shown during face acquisition when the user is too far from sensor [CHAR LIMIT=50] -->
    <string name="face_acquired_too_far">Move phone closer.</string>
    <!-- Message shown during face acquisition when the user is too high relatively to sensor [CHAR LIMIT=50] -->
    <string name="face_acquired_too_high">Move phone higher.</string>
    <!-- Message shown during face acquisition when the user is too low relatively to sensor [CHAR LIMIT=50] -->
    <string name="face_acquired_too_low">Move phone lower.</string>
    <!-- Message shown during face acquisition when only the right part of the user's face was detected [CHAR LIMIT=50] -->
    <string name="face_acquired_too_right">Move phone to the left.</string>
    <!-- Message shown during face acquisition when only the left part of the user's face was detected [CHAR LIMIT=50] -->
    <string name="face_acquired_too_left">Move phone to the right.</string>
    <!-- Message shown during face acquisition when the user is not front facing the sensor [CHAR LIMIT=50] -->
    <string name="face_acquired_poor_gaze">Please look more directly at your device.</string>
    <!-- Message shown during face acquisition when the user is not detected [CHAR LIMIT=50] -->
    <string name="face_acquired_not_detected">Position your face directly in front of the phone.</string>
    <!-- Message shown during face acquisition when the device is not steady [CHAR LIMIT=50] -->
    <string name="face_acquired_too_much_motion">Too much motion. Hold phone steady.</string>
    <!-- Message shown during face acquisition when the sensor needs to be recalibrated [CHAR LIMIT=50] -->
    <string name="face_acquired_recalibrate">Please re-enroll your face.</string>
    <!-- Message shown during face enrollment when a different person's face is detected [CHAR LIMIT=50] -->
    <string name="face_acquired_too_different">No longer able to recognize face. Try again.</string>
    <!-- Message shown during face enrollment when the face is too similar to a previous acquisition [CHAR LIMIT=50] -->
    <string name="face_acquired_too_similar">Too similar, please change your pose.</string>
    <!-- Message shown during acqusition when the user's face is turned too far left or right [CHAR LIMIT=50] -->
    <string name="face_acquired_pan_too_extreme">Turn your head a little less.</string>
    <!-- Message shown during acqusition when the user's face is tilted too high or too low [CHAR LIMIT=50] -->
    <string name="face_acquired_tilt_too_extreme">Turn your head a little less.</string>
    <!-- Message shown during acquisiton when the user's face is tilted too far left or right [CHAR LIMIT=50] -->
    <string name="face_acquired_roll_too_extreme">Turn your head a little less.</string>
    <!-- Message shown during acquisition when the user's face is obscured [CHAR LIMIT=50] -->
    <string name="face_acquired_obscured">Remove anything hiding your face.</string>
    <!-- Message shown during acquisition when the sensor is dirty [CHAR LIMIT=100] -->
    <string name="face_acquired_sensor_dirty">Clean the top of your screen, including the black bar</string>
    <!-- Array containing custom messages shown during face acquisition from vendor.  Vendor is expected to add and translate these strings -->
    <string-array name="face_acquired_vendor">
    </string-array>

    <!-- Error message shown when the face hardware can't be accessed. [CHAR LIMIT=69] -->
    <string name="face_error_hw_not_available">Can\u2019t verify face. Hardware not available.</string>
    <!-- Error message shown when the face hardware timer has expired and the user needs to restart the operation. [CHAR LIMIT=50] -->
    <string name="face_error_timeout">Try face unlock again.</string>
    <!-- Error message shown when the face hardware has run out of room for storing faces. [CHAR LIMIT=69] -->
    <string name="face_error_no_space">Can\u2019t store new face data. Delete an old one first.</string>
    <!-- Generic error message shown when the face operation (e.g. enrollment or authentication) is canceled. Generally not shown to the user. [CHAR LIMIT=50] -->
    <string name="face_error_canceled">Face operation canceled.</string>
    <!-- Generic error message shown when the face unlock operation is canceled due to user input. Generally not shown to the user [CHAR LIMIT=54] -->
    <string name="face_error_user_canceled">Face unlock canceled by user.</string>
    <!-- Generic error message shown when the face operation fails because too many attempts have been made. [CHAR LIMIT=50] -->
    <string name="face_error_lockout">Too many attempts. Try again later.</string>
    <!-- Generic error message shown when the face operation fails because strong authentication is required. [CHAR LIMIT=71] -->
    <string name="face_error_lockout_permanent">Too many attempts. Face unlock disabled.</string>
    <!-- Generic error message shown when the face hardware can't recognize the face. [CHAR LIMIT=50] -->
    <string name="face_error_unable_to_process">Can\u2019t verify face. Try again.</string>
    <!-- Generic error message shown when the user has no enrolled face. [CHAR LIMIT=52] -->
    <string name="face_error_not_enrolled">You haven\u2019t set up face unlock.</string>
    <!-- Generic error message shown when the app requests face unlock on a device without a sensor. [CHAR LIMIT=61] -->
    <string name="face_error_hw_not_present">Face unlock is not supported on this device.</string>
    <!-- Generic error message shown when face unlock is not available due to a security vulnerability. [CHAR LIMIT=50] -->
    <string name="face_error_security_update_required">Sensor temporarily disabled.</string>

    <!-- Template to be used to name enrolled faces by default. [CHAR LIMIT=10] -->
    <string name="face_name_template">Face <xliff:g id="faceId" example="1">%d</xliff:g></string>

    <!-- Array containing custom error messages from vendor.  Vendor is expected to add and translate these strings -->
    <string-array name="face_error_vendor">
    </string-array>

    <!-- Content description which should be used for the face icon. [CHAR LIMIT=10] -->
    <string name="face_icon_content_description">Face icon</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readSyncSettings">read sync settings</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readSyncSettings">Allows the app to read the sync settings for an account. For example, this can determine whether the People app is synced with an account.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_writeSyncSettings">toggle sync on and off</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_writeSyncSettings">Allows an app to modify the sync settings for an account.  For example, this can be used to enable sync of the People app with an account.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readSyncStats">read sync statistics</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readSyncStats">Allows an app to read the sync stats for an account, including the history of sync events and how much data is synced. </string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. "shared storage" refers to a storage space on the device that all apps with this permission can read from. [CHAR LIMIT=none] -->
    <string name="permlab_sdcardRead">read the contents of your shared storage</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. "shared storage" refers to a storage space on the device that all apps with this permission can read from. [CHAR LIMIT=none] -->
    <string name="permdesc_sdcardRead">Allows the app to read the contents of your shared storage.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. "shared storage" refers to a storage space on the device that all apps with this permission can write to. [CHAR LIMIT=none] -->
    <string name="permlab_sdcardWrite">modify or delete the contents of your shared storage</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. "shared storage" refers to a storage space on the device that all apps with this permission can write to. [CHAR LIMIT=none] -->
    <string name="permdesc_sdcardWrite">Allows the app to write the contents of your shared storage.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_use_sip">make/receive SIP calls</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_use_sip">Allows the app to make and receive SIP calls.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_register_sim_subscription">register new telecom SIM connections</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_register_sim_subscription">Allows the app to register new telecom SIM connections.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_register_call_provider">register new telecom connections</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_register_call_provider">Allows the app to register new telecom connections.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_connection_manager">manage telecom connections</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_connection_manager">Allows the app to manage telecom connections.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bind_incall_service">interact with in-call screen</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bind_incall_service">Allows the app to control when and how the user sees the in-call screen.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bind_connection_service">interact with telephony services</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bind_connection_service">Allows the app to interact with telephony services to make/receive calls.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_control_incall_experience">provide an in-call user experience</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_control_incall_experience">Allows the app to provide an in-call user experience.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_readNetworkUsageHistory">read historical network usage</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_readNetworkUsageHistory">Allows the app to read historical network usage for specific networks and apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_manageNetworkPolicy">manage network policy</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_manageNetworkPolicy">Allows the app to manage network policies and define app-specific rules.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_modifyNetworkAccounting">modify network usage accounting</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_modifyNetworkAccounting">Allows the app to modify how network usage is accounted against apps. Not for use by normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessNotifications">access notifications</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessNotifications">Allows the app to retrieve, examine, and clear notifications, including those posted by other apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bindNotificationListenerService">bind to a notification listener service</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bindNotificationListenerService">Allows the holder to bind to the top-level interface of a notification listener service. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bindConditionProviderService">bind to a condition provider service</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bindConditionProviderService">Allows the holder to bind to the top-level interface of a condition provider service. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bindDreamService">bind to a dream service</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bindDreamService">Allows the holder to bind to the top-level interface of a dream service. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_invokeCarrierSetup">invoke the carrier-provided configuration app</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_invokeCarrierSetup">Allows the holder to invoke the carrier-provided configuration app. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessNetworkConditions">listen for observations on network conditions</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessNetworkConditions">Allows an application to listen for observations on network conditions. Should never be needed for normal apps.</string>

    <string name="permlab_setInputCalibration">change input device calibration</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_setInputCalibration">Allows the app to modify the calibration parameters of the touch screen. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_accessDrmCertificates">access DRM certificates</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_accessDrmCertificates">Allows an application to provision and use DRM certficates. Should never be needed for normal apps.</string>

    <string name="permlab_handoverStatus">receive Android Beam transfer status</string>
    <string name="permdesc_handoverStatus">Allows this application to receive information about current Android Beam transfers</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_removeDrmCertificates">remove DRM certificates</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_removeDrmCertificates">Allows an application to remove DRM certficates. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bindCarrierMessagingService">bind to a carrier messaging service</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bindCarrierMessagingService">Allows the holder to bind to the top-level interface of a carrier messaging service. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_bindCarrierServices">bind to carrier services</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_bindCarrierServices">Allows the holder to bind to carrier services. Should never be needed for normal apps.</string>

    <!-- Title of an application permission, for applications that wish to access notification policy. -->
    <string name="permlab_access_notification_policy">access Do Not Disturb</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_access_notification_policy">Allows the app to read and write Do Not Disturb configuration.</string>

    <!-- Title of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permlab_startViewPermissionUsage">start view permission usage</string>
    <!-- Description of an application permission, listed so the user can choose whether they want to allow the application to do this. -->
    <string name="permdesc_startViewPermissionUsage">Allows the holder to start the permission usage for an app. Should never be needed for normal apps.</string>

    <!-- Policy administration -->

    <!-- Title of policy access to limiting the user's password choices -->
    <string name="policylab_limitPassword">Set password rules</string>
    <!-- Description of policy access to limiting the user's password choices -->
    <string name="policydesc_limitPassword">Control the length and the characters allowed in screen lock passwords and PINs.</string>
    <!-- Title of policy access to watch user login attempts -->
    <string name="policylab_watchLogin">Monitor screen unlock attempts</string>
    <!-- Description of policy access to watch user login attempts -->
    <string name="policydesc_watchLogin" product="tablet">Monitor the number of incorrect passwords
    typed when unlocking the screen, and lock the tablet or erase all the tablet\'s
    data if too many incorrect passwords are typed.</string>
    <!-- Description of policy access to watch user login attempts -->
    <string name="policydesc_watchLogin" product="tv">Monitor the number of incorrect passwords
    typed when unlocking the screen, and lock your Android TV device or erase all your Android TV device\'s
    data if too many incorrect passwords are typed.</string>
    <!-- Description of policy access to watch user login attempts -->
    <string name="policydesc_watchLogin" product="default">Monitor the number of incorrect passwords
    typed. when unlocking the screen, and lock the phone or erase all the phone\'s
    data if too many incorrect passwords are typed.</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tablet">Monitor the number of incorrect passwords
    typed when unlocking the screen, and lock the tablet or erase all this user\'s data
    if too many incorrect passwords are typed.</string>
    <string name="policydesc_watchLogin_secondaryUser" product="tv">Monitor the number of incorrect passwords
    typed when unlocking the screen, and lock your Android TV device or erase all this user\'s data
    if too many incorrect passwords are typed.</string>
    <string name="policydesc_watchLogin_secondaryUser" product="default">Monitor the number of incorrect passwords
    typed when unlocking the screen, and lock the phone or erase all this user\'s data
    if too many incorrect passwords are typed.</string>
    <!-- Title of policy access to reset user's password -->
    <string name="policylab_resetPassword">Change the screen lock</string>
    <!-- Description of policy access to reset user's password -->
    <string name="policydesc_resetPassword">Change the screen lock.</string>
    <!-- Title of policy access to force lock the device -->
    <string name="policylab_forceLock">Lock the screen</string>
    <!-- Description of policy access to limiting the user's password choices -->
    <string name="policydesc_forceLock">Control how and when the screen locks.</string>
    <!-- Title of policy access to wipe primary user's data -->
    <string name="policylab_wipeData">Erase all data</string>
    <!-- Description of policy access to wipe the user's data -->
    <string name="policydesc_wipeData" product="tablet">Erase the tablet\'s data without warning by performing a factory data reset.</string>
    <!-- Description of policy access to wipe the user's data -->
    <string name="policydesc_wipeData" product="tv">Erase your Android TV device\'s data without warning by performing a factory data reset.</string>
    <!-- Description of policy access to wipe the user's data -->
    <string name="policydesc_wipeData" product="default">Erase the phone\'s data without warning by performing a factory data reset.</string>
    <!-- Title of policy access to wipe secondary user's data -->
    <string name="policylab_wipeData_secondaryUser">Erase user data</string>
    <!-- Description of policy access to wipe the user's data -->
    <string name="policydesc_wipeData_secondaryUser" product="tablet">Erase this user\'s data on this tablet without warning.</string>
    <!-- Description of policy access to wipe the user's data -->
    <string name="policydesc_wipeData_secondaryUser" product="tv">Erase this user\'s data on this Android TV device without warning.</string>
    <!-- Description of policy access to wipe the user's data -->
    <string name="policydesc_wipeData_secondaryUser" product="default">Erase this user\'s data on this phone without warning.</string>
    <!-- Title of policy access to set global proxy -->
    <string name="policylab_setGlobalProxy">Set the device global proxy</string>
    <!-- Description of policy access to set global proxy -->
    <string name="policydesc_setGlobalProxy">Set the device global proxy
    to be used while policy is enabled. Only the device owner can set the global proxy.</string>
    <!-- Title of policy access to enforce password expiration [CHAR LIMIT=50]-->
    <string name="policylab_expirePassword">Set screen lock password expiration</string>
    <!-- Description of policy access to enforce password expiration [CHAR LIMIT=110]-->
    <string name="policydesc_expirePassword">Change how frequently the screen lock password, PIN, or pattern must be changed.</string>
    <!-- Title of policy access to require encrypted storage [CHAR LIMIT=30]-->
    <string name="policylab_encryptedStorage">Set storage encryption</string>
    <!-- Description of policy access to require encrypted storage [CHAR LIMIT=110]-->
    <string name="policydesc_encryptedStorage">Require that stored app data be encrypted.</string>
    <!-- Title of policy access to disable all device cameras [CHAR LIMIT=30]-->
    <string name="policylab_disableCamera">Disable cameras</string>
    <!-- Description of policy access to disable all device cameras [CHAR LIMIT=110]-->
    <string name="policydesc_disableCamera">Prevent use of all device cameras.</string>
    <!-- Title of policy access to disable keyguard features [CHAR LIMIT=30]-->
    <string name="policylab_disableKeyguardFeatures">Disable some screen lock features</string>
    <!-- Description of policy access to disable keyguard features. [CHAR LIMIT=110]-->
    <string name="policydesc_disableKeyguardFeatures">Prevent use of some screen lock features.</string>

    <!-- The order of these is important, don't reorder without changing Contacts.java --> <skip />
    <!-- Phone number types from android.provider.Contacts. This could be used when adding a new phone number for a contact, for example. -->
    <string-array name="phoneTypes">
        <item>Home</item>
        <item>Mobile</item>
        <item>Work</item>
        <item>Work Fax</item>
        <item>Home Fax</item>
        <item>Pager</item>
        <item>Other</item>
        <item>Custom</item>
    </string-array>

    <!-- The order of these is important, don't reorder without changing Contacts.java --> <skip />
    <!-- Email address types from android.provider.Contacts. This could be used when adding a new e-mail address for a contact, for example. -->
    <string-array name="emailAddressTypes">
        <item>Home</item>
        <item>Work</item>
        <item>Other</item>
        <item>Custom</item>
    </string-array>

    <!-- The order of these is important, don't reorder without changing Contacts.java --> <skip />
    <!-- Postal address types from android.provider.Contacts. This could be used when adding a new address for a contact, for example. -->
    <string-array name="postalAddressTypes">
        <item>Home</item>
        <item>Work</item>
        <item>Other</item>
        <item>Custom</item>
    </string-array>

    <!-- The order of these is important, don't reorder without changing Contacts.java --> <skip />
    <!-- Instant Messenger ID types from android.provider.Contacts. This could be used when adding a new IM for a contact, for example. -->
    <string-array name="imAddressTypes">
        <item>Home</item>
        <item>Work</item>
        <item>Other</item>
        <item>Custom</item>
    </string-array>

    <!-- The order of these is important, don't reorder without changing Contacts.java --> <skip />
    <!-- Organization types from android.provider.Contacts. This could be used when adding a new organization for a contact, for example. -->
    <string-array name="organizationTypes">
        <item>Work</item>
        <item>Other</item>
        <item>Custom</item>
    </string-array>

    <!-- The order of these is important, don't reorder without changing Contacts.java --> <skip />
    <!-- Instant Message protocols/providers from android.provider.Contacts -->
    <string-array name="imProtocols">
        <item>AIM</item>
        <item>Windows Live</item>
        <item>Yahoo</item>
        <item>Skype</item>
        <item>QQ</item>
        <item>Google Talk</item>
        <item>ICQ</item>
        <item>Jabber</item>
    </string-array>

    <!-- Custom phone number type -->
    <string name="phoneTypeCustom">Custom</string>
    <!-- Home phone number type -->
    <string name="phoneTypeHome">Home</string>
    <!-- Mobile phone number type -->
    <string name="phoneTypeMobile">Mobile</string>
    <!-- Work phone number type -->
    <string name="phoneTypeWork">Work</string>
    <!-- Work fax phone number type -->
    <string name="phoneTypeFaxWork">Work Fax</string>
    <!-- Home fax phone number type -->
    <string name="phoneTypeFaxHome">Home Fax</string>
    <!-- Pager phone number type -->
    <string name="phoneTypePager">Pager</string>
    <!-- Other phone number type -->
    <string name="phoneTypeOther">Other</string>
    <!-- Callback phone number type -->
    <string name="phoneTypeCallback">Callback</string>
    <!-- Car phone number type -->
    <string name="phoneTypeCar">Car</string>
    <!-- Company main phone number type -->
    <string name="phoneTypeCompanyMain">Company Main</string>
    <!-- ISDN phone number type -->
    <string name="phoneTypeIsdn">ISDN</string>
    <!-- Main phone number type -->
    <string name="phoneTypeMain">Main</string>
    <!-- Other fax phone number type -->
    <string name="phoneTypeOtherFax">Other Fax</string>
    <!-- Radio phone number type -->
    <string name="phoneTypeRadio">Radio</string>
    <!-- Telex phone number type -->
    <string name="phoneTypeTelex">Telex</string>
    <!-- TTY TDD phone number type -->
    <string name="phoneTypeTtyTdd">TTY TDD</string>
    <!-- Work mobile phone number type -->
    <string name="phoneTypeWorkMobile">Work Mobile</string>
    <!-- Work pager phone number type -->
    <string name="phoneTypeWorkPager">Work Pager</string>
    <!-- Assistant phone number type -->
    <string name="phoneTypeAssistant">Assistant</string>
    <!-- MMS phone number type -->
    <string name="phoneTypeMms">MMS</string>

    <!-- Label for custom events  [CHAR LIMIT=20] -->
    <string name="eventTypeCustom">Custom</string>
    <!-- Label for a birthday event  [CHAR LIMIT=20] -->
    <string name="eventTypeBirthday">Birthday</string>
    <!-- Label for an anniversary event  [CHAR LIMIT=20] -->
    <string name="eventTypeAnniversary">Anniversary</string>
    <!-- Label for other events  [CHAR LIMIT=20] -->
    <string name="eventTypeOther">Other</string>

    <!-- Custom email type -->
    <string name="emailTypeCustom">Custom</string>
    <!-- Home email type -->
    <string name="emailTypeHome">Home</string>
    <!-- Work email type -->
    <string name="emailTypeWork">Work</string>
    <!-- Other email type -->
    <string name="emailTypeOther">Other</string>
    <!-- Mobile email type -->
    <string name="emailTypeMobile">Mobile</string>

    <!-- Custom postal address type -->
    <string name="postalTypeCustom">Custom</string>
    <!-- Home postal address type -->
    <string name="postalTypeHome">Home</string>
    <!-- Work postal address type -->
    <string name="postalTypeWork">Work</string>
    <!-- Other postal address type -->
    <string name="postalTypeOther">Other</string>

    <!-- Custom IM address type -->
    <string name="imTypeCustom">Custom</string>
    <!-- Home IM address type -->
    <string name="imTypeHome">Home</string>
    <!-- Work IM address type -->
    <string name="imTypeWork">Work</string>
    <!-- Other IM address type -->
    <string name="imTypeOther">Other</string>

    <!-- Custom IM protocol type -->
    <string name="imProtocolCustom">Custom</string>
    <!-- AIM IM protocol type -->
    <string name="imProtocolAim">AIM</string>
    <!-- MSN IM protocol type -->
    <string name="imProtocolMsn">Windows Live</string>
    <!-- Yahoo IM protocol type -->
    <string name="imProtocolYahoo">Yahoo</string>
    <!-- Skype IM protocol type -->
    <string name="imProtocolSkype">Skype</string>
    <!-- QQ IM protocol type -->
    <string name="imProtocolQq">QQ</string>
    <!-- Google Talk IM protocol type -->
    <string name="imProtocolGoogleTalk">Hangouts</string>
    <!-- ICQ IM protocol type -->
    <string name="imProtocolIcq">ICQ</string>
    <!-- Jabber IM protocol type -->
    <string name="imProtocolJabber">Jabber</string>
    <!-- NetMeeting IM protocol type -->
    <string name="imProtocolNetMeeting">NetMeeting</string>

    <!-- Work organization type -->
    <string name="orgTypeWork">Work</string>
    <!-- Other organization type -->
    <string name="orgTypeOther">Other</string>
    <!-- Custom organization type -->
    <string name="orgTypeCustom">Custom</string>

    <!-- Custom relationship custom [CHAR LIMIT=20] -->
    <string name="relationTypeCustom">Custom</string>
    <!-- Assistant relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeAssistant">Assistant</string>
    <!-- Brother relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeBrother">Brother</string>
    <!-- Child relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeChild">Child</string>
    <!-- Domestic Partner relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeDomesticPartner">Domestic Partner</string>
    <!-- Father relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeFather">Father</string>
    <!-- Friend relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeFriend">Friend</string>
    <!-- Manager relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeManager">Manager</string>
    <!-- Mother relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeMother">Mother</string>
    <!-- Parent relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeParent">Parent</string>
    <!-- Partner relationship type [CHAR LIMIT=20] -->
    <string name="relationTypePartner">Partner</string>
    <!-- Referred by relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeReferredBy">Referred by</string>
    <!-- Relative relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeRelative">Relative</string>
    <!-- Sister relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeSister">Sister</string>
    <!-- Spouse relationship type [CHAR LIMIT=20] -->
    <string name="relationTypeSpouse">Spouse</string>

    <!-- Custom SIP address type. Same context as Custom phone type.  -->
    <string name="sipAddressTypeCustom">Custom</string>
    <!-- Home SIP address type. Same context as Home phone type. -->
    <string name="sipAddressTypeHome">Home</string>
    <!-- Work SIP address type. Same context as Work phone type. -->
    <string name="sipAddressTypeWork">Work</string>
    <!-- Other SIP address type. Same context as Other phone type. -->
    <string name="sipAddressTypeOther">Other</string>

    <!-- Error message that is displayed when the user clicks on a quick contacts badge, but
         there is no contacts application installed that can display the quick contact -->
    <string name="quick_contacts_not_available">No application found to view this contact.</string>

    <!-- Instructions telling the user to enter their SIM PIN to unlock the keyguard.
         Displayed in one line in a large font.  -->
    <string name="keyguard_password_enter_pin_code">Type PIN code</string>

    <!-- Instructions telling the user to enter their SIM PUK to unlock the keyguard.
         Displayed in one line in a large font.  -->
    <string name="keyguard_password_enter_puk_code">Type PUK and new PIN code</string>

    <!-- Prompt to enter SIM PUK in Edit Text Box in unlock screen -->
    <string name="keyguard_password_enter_puk_prompt">PUK code</string>
    <!-- Prompt to enter New SIM PIN in Edit Text Box in unlock screen -->
    <string name="keyguard_password_enter_pin_prompt">New PIN code</string>

    <!-- Displayed as hint in passwordEntry EditText on PasswordUnlockScreen [CHAR LIMIT=30]-->
    <string name="keyguard_password_entry_touch_hint"><font size="17">Tap to type password</font></string>

    <!-- Instructions telling the user to enter their text password to unlock the keyguard.
         Displayed in one line in a large font.  -->
    <string name="keyguard_password_enter_password_code">Type password to unlock</string>

    <!-- Instructions telling the user to enter their PIN password to unlock the keyguard.
         Displayed in one line in a large font.  -->
    <string name="keyguard_password_enter_pin_password_code">Type PIN to unlock</string>

    <!-- Instructions telling the user that they entered the wrong pin while trying
         to unlock the keyguard.  Displayed in one line in a large font.  -->
    <string name="keyguard_password_wrong_pin_code">Incorrect PIN code.</string>

    <!-- Instructions telling the user how to unlock the phone. -->
    <string name="keyguard_label_text">To unlock, press Menu then 0.</string>

    <!-- This can be used in any application wanting to disable the text "Emergency number" -->
    <string name="emergency_call_dialog_number_for_display">Emergency number</string>

    <!--
       *** touch based lock / unlock ***
                                          --> <skip />

    <!-- On the keyguard screen, it shows the carrier the phone is connected to.  This is displayed if the phone is not connected to a carrier.-->
    <string name="lockscreen_carrier_default">No service</string>

    <!-- Shown in the lock screen to tell the user that the screen is locked. -->
    <string name="lockscreen_screen_locked">Screen locked.</string>

    <!-- when pattern lock is enabled, tell them about the emergency dial -->
    <string name="lockscreen_instructions_when_pattern_enabled">Press Menu to unlock or place emergency call.</string>

    <!-- On the keyguard screen, when pattern lock is disabled, only tell them to press menu to unlock.  This is shown in small font at the bottom. -->
    <string name="lockscreen_instructions_when_pattern_disabled">Press Menu to unlock.</string>

    <!-- On the unlock pattern screen, shown at the top of the unlock screen to tell the user what to do. Below this text is the place for theu ser to draw the pattern. -->
    <string name="lockscreen_pattern_instructions">Draw pattern to unlock</string>
    <!-- Button at the bottom of the unlock screen to make an emergency call or access other emergency assistance functions. -->
    <string name="lockscreen_emergency_call">Emergency</string>
    <!-- Button at the bottom of the unlock screen that lets the user return to a call -->
    <string name="lockscreen_return_to_call">Return to call</string>
    <!-- Shown to confirm that the user entered their lock pattern correctly. -->
    <string name="lockscreen_pattern_correct">Correct!</string>
    <!-- On the unlock pattern screen, shown when the user enters the wrong lock pattern and must try again. -->
    <string name="lockscreen_pattern_wrong">Try again</string>
    <!-- On the unlock password screen, shown when the user enters the wrong lock password and must try again. -->
    <string name="lockscreen_password_wrong">Try again</string>

    <!-- On the keyguard screen, this string explains that some features or data may not be available until the device is unlocked. [CHAR LIMIT=48] -->
    <string name="lockscreen_storage_locked">Unlock for all features and data</string>

    <!-- Shown when face unlock failed multiple times so we're just using the backup -->
    <string name="faceunlock_multiple_failures">Maximum Face Unlock attempts exceeded</string>

    <!-- Shown in the lock screen when there is no SIM card. -->
    <string name="lockscreen_missing_sim_message_short">No SIM card</string>
    <!-- Shown in the lock screen when there is no SIM card. -->
    <string name="lockscreen_missing_sim_message" product="tablet">No SIM card in tablet.</string>
    <!-- Shown in the lock screen when there is no SIM card. -->
    <string name="lockscreen_missing_sim_message" product="tv">No SIM card in your Android TV device.</string>
    <!-- Shown in the lock screen when there is no SIM card. -->
    <string name="lockscreen_missing_sim_message" product="default">No SIM card in phone.</string>
    <!-- Shown in the lock screen to ask the user to insert a SIM card. -->
    <string name="lockscreen_missing_sim_instructions">Insert a SIM card.</string>
    <!-- Shown in the lock screen to ask the user to insert a SIM card when sim is missing or not readable. -->
    <string name="lockscreen_missing_sim_instructions_long">The SIM card is missing or not readable. Insert a SIM card.</string>
    <!-- Shown in the lock screen when SIM card is permanently disabled. -->
    <string name="lockscreen_permanent_disabled_sim_message_short">Unusable SIM card.</string>
    <!-- Shown in the lock screen to inform the user to SIM card is permanently disabled. -->
    <string name="lockscreen_permanent_disabled_sim_instructions">Your SIM card has been permanently disabled.\n
    Contact your wireless service provider for another SIM card.</string>

    <!-- Shown on transport control of lockscreen. Pressing button goes to previous track. -->
    <string name="lockscreen_transport_prev_description">Previous track</string>
    <!-- Shown on transport control of lockscreen. Pressing button goes to next track. -->
    <string name="lockscreen_transport_next_description">Next track</string>
    <!-- Shown on transport control of lockscreen. Pressing button pauses playback -->
    <string name="lockscreen_transport_pause_description">Pause</string>
    <!-- Shown on transport control of lockscreen. Pressing button pauses playback -->
    <string name="lockscreen_transport_play_description">Play</string>
    <!-- Shown on transport control of lockscreen. Pressing button pauses playback -->
    <string name="lockscreen_transport_stop_description">Stop</string>
    <!-- Shown on transport control screens. Pressing button rewinds playback [CHAR LIMIT=NONE]-->
    <string name="lockscreen_transport_rew_description">Rewind</string>
    <!-- Shown on transport control screens. Pressing button fast forwards playback [CHAR LIMIT=NONE]-->
    <string name="lockscreen_transport_ffw_description">Fast forward</string>

    <!-- Shown in the lock screen when there is emergency calls only mode. -->
    <string name="emergency_calls_only" msgid="2485604591272668370">Emergency calls only</string>

    <!-- When the user inserts a sim card from an unsupported network, it becomes network
         locked -->
    <string name="lockscreen_network_locked_message">Network locked</string>


    <!-- When the user enters a wrong sim pin too many times, it becomes
         PUK locked (Pin Unlock Kode) -->
    <string name="lockscreen_sim_puk_locked_message">SIM card is PUK-locked.</string>
    <!-- Shown in the lock screen when the SIM has become PUK locked and the user must call customer care to unlock it. -->
    <string name="lockscreen_sim_puk_locked_instructions">See the User Guide or contact Customer Care.</string>

    <!-- Shown in the lock screen to tell the user that their SIM is locked and they must unlock it. -->
    <string name="lockscreen_sim_locked_message">SIM card is locked.</string>

    <!-- For the unlock screen, When the user enters a sim unlock code, it takes a little while to check
         whether it is valid, and to unlock the sim if it is valid.  we display a
         progress dialog in the meantime.  this is the emssage. -->
    <string name="lockscreen_sim_unlock_progress_dialog_message">Unlocking SIM card\u2026</string>

    <!-- For the unlock screen, Information message shown in dialog when user has too many failed attempts at
         drawing the unlock pattern -->
    <string name="lockscreen_too_many_failed_attempts_dialog_message">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, Information message shown in dialog when user has too many failed attempts at
         entering the password -->
    <string name="lockscreen_too_many_failed_password_attempts_dialog_message">
        You have incorrectly typed your password <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, Information message shown in dialog when user has too many failed attempts at
         entering the PIN -->
    <string name="lockscreen_too_many_failed_pin_attempts_dialog_message">
        You have incorrectly typed your PIN <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user is almost at the limit
         where they will be locked out and may have to enter an alternate username/password to unlock the phone -->
    <string name="lockscreen_failed_attempts_almost_glogin" product="tablet">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your tablet using your Google signin.\n\n
       Try again in <xliff:g id="number">%3$d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user is almost at the limit
         where they will be locked out and may have to enter an alternate username/password to unlock the phone -->
    <string name="lockscreen_failed_attempts_almost_glogin" product="tv">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your Android TV device using your Google signin.\n\n
       Try again in <xliff:g id="number">%3$d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user is almost at the limit
         where they will be locked out and may have to enter an alternate username/password to unlock the phone -->
    <string name="lockscreen_failed_attempts_almost_glogin" product="default">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your phone using your Google signin.\n\n
       Try again in <xliff:g id="number">%3$d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user is almost at the limit
         where the device will be wiped. -->
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       the tablet will be reset to factory default and all user data will be lost.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user is almost at the limit
         where the device will be wiped. -->
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="tv">
       You have incorrectly attempted to unlock your Android TV device <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       your Android TV device will be reset to factory default and all user data will be lost.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user is almost at the limit
         where the device will be wiped. -->
    <string name="lockscreen_failed_attempts_almost_at_wipe" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       the phone will be reset to factory default and all user data will be lost.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user has exceeded the
        maximum attempts and the device will now be wiped -->
    <string name="lockscreen_failed_attempts_now_wiping" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%d</xliff:g> times.
       The tablet will now be reset to factory default.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user has exceeded the
        maximum attempts and the device will now be wiped -->
    <string name="lockscreen_failed_attempts_now_wiping" product="tv">
       You have incorrectly attempted to unlock your Android TV device <xliff:g id="number">%d</xliff:g> times.
       Your Android TV device will now be reset to factory default.
    </string>

    <!-- For the unlock screen, informational message shown in dialog when user has exceeded the
        maximum attempts and the device will now be wiped -->
    <string name="lockscreen_failed_attempts_now_wiping" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%d</xliff:g> times.
       The phone will now be reset to factory default.
    </string>

    <!-- On the unlock screen, countdown message shown while user is waiting to try again after too many
         failed attempts -->
    <string name="lockscreen_too_many_failed_attempts_countdown">Try again in <xliff:g id="number">%d</xliff:g> seconds.</string>

    <!-- On the unlock screen, message shown on button that appears once it's apparent the user may have forgotten
         their lock gesture -->
    <string name="lockscreen_forgot_pattern_button_text">Forgot pattern?</string>

    <!-- Title of the unlock screen that uses your Google login and password when the user hit
         the 'forgot pattern' button.-->
    <string name="lockscreen_glogin_forgot_pattern">Account unlock</string>
    <!-- Title of the unlock screen that uses your Google login and password when the user attempted
         too many patterns and we are forcing them to use their account instead. -->
    <string name="lockscreen_glogin_too_many_attempts">Too many pattern attempts</string>
    <!-- In the unlock screen, message telling the user that they need to use their Google login and password to unlock the phone -->
    <string name="lockscreen_glogin_instructions">To unlock, sign in with your Google account.</string>
    <!-- Hint caption for the username field when unlocking the phone using login and password -->
    <string name="lockscreen_glogin_username_hint">Username (email)</string>
    <!-- Hint caption for the password field when unlocking the phone using login and password -->
    <string name="lockscreen_glogin_password_hint">Password</string>
    <!-- Button to try to unlock the phone using username and password -->
    <string name="lockscreen_glogin_submit_button">Sign in</string>
    <!-- Displayed to the user when unlocking the phone with a username and password fails. -->
    <string name="lockscreen_glogin_invalid_input">Invalid username or password.</string>
    <!-- Hint displayed on account unlock screen to advise the user on how to recover the account. -->
    <string name="lockscreen_glogin_account_recovery_hint">Forgot your username or password\?\nVisit <b>google.com/accounts/recovery</b>.</string>

    <!-- Displayed in a progress dialog while a username and password are being checked. -->
    <string name="lockscreen_glogin_checking_password">Checking\u2026</string>
    <!-- Displayed on lock screen's left tab - unlock -->
    <string name="lockscreen_unlock_label">Unlock</string>
    <!-- Displayed on lock screen's right tab - turn sound on -->
    <string name="lockscreen_sound_on_label">Sound on</string>
    <!-- Displayed on lock screen's right tab - turn sound off -->
    <string name="lockscreen_sound_off_label">Sound off</string>

    <!-- Accessibility description sent when user starts drawing a lock pattern. [CHAR LIMIT=NONE] -->
    <string name="lockscreen_access_pattern_start">Pattern started</string>
    <!-- Accessibility description sent when the pattern times out and is cleared. [CHAR LIMIT=NONE] -->
    <string name="lockscreen_access_pattern_cleared">Pattern cleared</string>
    <!-- Accessibility description sent when user adds a dot to the pattern. [CHAR LIMIT=NONE]  -->
    <string name="lockscreen_access_pattern_cell_added">Cell added</string>
    <!-- Accessibility description sent when user adds a dot to the pattern. Announces the
    actual cell when headphones are connected [CHAR LIMIT=NONE]  -->
    <string name="lockscreen_access_pattern_cell_added_verbose">
            Cell <xliff:g id="cell_index" example="3">%1$s</xliff:g> added</string>
    <!-- Accessibility description sent when user completes drawing a pattern. [CHAR LIMIT=NONE] -->
    <string name="lockscreen_access_pattern_detected">Pattern completed</string>
    <!-- Accessibility description of the unlock pattern area. [CHAR_LIMIT=none] -->
    <string name="lockscreen_access_pattern_area" msgid="">Pattern area.</string>

    <!-- Accessibility description sent when user changes the current lock screen widget. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_widget_changed">%1$s. Widget %2$d of %3$d.</string>
    <!-- Accessibility description of the add widget button. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_add_widget">Add widget.</string>
    <!-- Accessibility description of the empty sidget slot (place holder for a new widget). [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_widget_empty_slot">Empty</string>
    <!-- Accessibility description of the event of expanding an unlock area. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_unlock_area_expanded">Unlock area expanded.</string>
    <!-- Accessibility description of the event of collapsing an unlock area. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_unlock_area_collapsed">Unlock area collapsed.</string>
    <!-- Accessibility description of a lock screen widget. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_widget"><xliff:g id="widget_index">%1$s</xliff:g> widget.</string>
    <!-- Accessibility description of the lock screen user selector widget. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_user_selector">User selector</string>
    <!-- Accessibility description of the lock screen status widget. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_status">Status</string>
    <!-- Accessibility description of the camera widget. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_camera">Camera</string>
    <!-- Accessibility description of the lock media control widget. [CHAR_LIMIT=none] -->
    <string name="keygaurd_accessibility_media_controls">Media controls</string>
    <!-- Accessibility description of widget reordering start. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_widget_reorder_start">Widget reordering started.</string>
    <!-- Accessibility description of widget reordering end. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_widget_reorder_end">Widget reordering ended.</string>
    <!-- Accessibility description of the a widget deletion event. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_widget_deleted">Widget <xliff:g id="widget_index">%1$s</xliff:g> deleted.</string>
    <!-- Accessibility description of the button to expand the lock area. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_expand_lock_area">Expand unlock area.</string>
    <!-- Accessibility description of the slide unlock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_slide_unlock">Slide unlock.</string>
    <!-- Accessibility description of the pattern unlock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_pattern_unlock">Pattern unlock.</string>
    <!-- Accessibility description of the face unlock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_face_unlock">Face unlock.</string>
    <!-- Accessibility description of the pin lock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_pin_unlock">Pin unlock.</string>
    <!-- Accessibility description of the sim pin lock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_sim_pin_unlock">Sim Pin unlock.</string>
    <!-- Accessibility description of the sim puk lock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_sim_puk_unlock">Sim Puk unlock.</string>
    <!-- Accessibility description of the password lock. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_password_unlock">Password unlock.</string>
    <!-- Accessibility description of the unlock pattern area. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_pattern_area">Pattern area.</string>
    <!-- Accessibility description of the unlock slide area. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_slide_area">Slide area.</string>

    <!-- Password keyboard strings. Used by LockScreen and Settings --><skip />
    <!-- Label for "switch to symbols" key.  Must be short to fit on key! -->
    <string name="password_keyboard_label_symbol_key">\?123</string>
    <!-- Label for "switch to alphabetic" key.  Must be short to fit on key! -->
    <string name="password_keyboard_label_alpha_key">ABC</string>
    <!-- Label for ALT modifier key.  Must be short to fit on key! -->
    <string name="password_keyboard_label_alt_key">ALT</string>

    <!-- Label for granularity to traverse the content on an AccessibilityNodeInfo by character. Only spoken to the user. [CHAR LIMIT=NONE] -->
    <string name="granularity_label_character">character</string>
    <!-- Label for granularity to traverse the content on an AccessibilityNodeInfo by word. Only spoken to the user. [CHAR LIMIT=NONE] -->
    <string name="granularity_label_word">word</string>
    <!-- Label for granularity to traverse the content on an AccessibilityNodeInfo by link. Only spoken to the user. [CHAR LIMIT=NONE] -->
    <string name="granularity_label_link">link</string>
    <!-- Label for granularity to traverse the content on an AccessibilityNodeInfo by line. Only spoken to the user. [CHAR LIMIT=NONE] -->
    <string name="granularity_label_line">line</string>

    <!-- Title of the alert when something went wrong in the factory test. -->
    <string name="factorytest_failed">Factory test failed</string>
    <!-- Error message displayed when a non-system application tries to start a factory test. -->
    <string name="factorytest_not_system">The FACTORY_TEST action
        is only supported for packages installed in /system/app.</string>
    <!-- Error message displayed when the factory test could not be started. -->
    <string name="factorytest_no_action">No package was found that provides the
        FACTORY_TEST action.</string>
    <!-- Button to restart the device after the factory test. -->
    <string name="factorytest_reboot">Reboot</string>

    <!-- Do not translate.  timepicker mode, overridden for watch -->
    <string name="time_picker_mode" translatable="false">"clock"</string>

    <!-- Do not translate.  datepicker mode, overridden for watch -->
    <string name="date_picker_mode" translatable="false">"calendar"</string>

    <!-- Title for a JavaScript dialog. "The page at <url of current page> says:" -->
    <string name="js_dialog_title">The page at \"<xliff:g id="title">%s</xliff:g>\" says:</string>
    <!-- Default title for a javascript dialog -->
    <string name="js_dialog_title_default">JavaScript</string>
    <!-- Title for the unload javascript dialog -->
    <string name="js_dialog_before_unload_title">Confirm Navigation</string>
    <!-- Text for the positive button on the unload javascript dialog -->
    <string name="js_dialog_before_unload_positive_button">Leave this Page</string>
    <!-- Text for the negative button on the unload javascript dialog -->
    <string name="js_dialog_before_unload_negative_button">Stay on this Page</string>
    <!-- Message in a javascript dialog asking if the user wishes to leave the current page -->
    <string name="js_dialog_before_unload"><xliff:g id="message">%s</xliff:g>\n\nAre you sure you want to navigate away from this page?</string>

    <!-- Title of the WebView save password dialog.  If the user enters a password in a form on a website, a dialog will come up asking if they want to save the password. -->
    <string name="save_password_label">Confirm</string>

    <!-- Toast for double-tap -->
    <string name="double_tap_toast">Tip: Double-tap to zoom in and out.</string>

    <!-- Text to show in the auto complete drop down list on a text view when the WebView can auto fill the entire form, and the user has configured an AutoFill profile [CHAR-LIMIT=8] -->
    <string name="autofill_this_form">Autofill</string>
    <!-- Text to show in the auto complete drop down list on a text view when the WebView can auto fill the entire form but the user has not configured an AutoFill profile [CHAR-LIMIT=19] -->
    <string name="setup_autofill">Set up Autofill</string>

    <!-- Title of fullscreen autofill window, including the name of which autofill service it is using [CHAR-LIMIT=NONE] -->
    <string name="autofill_window_title">Autofill with <xliff:g id="serviceName" example="MyPass">%1$s</xliff:g></string>

    <!-- String used to separate FirstName and LastName when writing out a local name
         e.g. John<separator>Smith [CHAR-LIMIT=NONE]-->
    <string name="autofill_address_name_separator">\u0020</string>
    <!-- Format string for displaying a name. $1 is First Name, $2 is autofill_address_name_separator, $3 is Last Name.
         e.g. (John)( )(Smith) -->
    <string name="autofill_address_summary_name_format">$1$2$3</string>

    <!-- String used to separate Name and Address Line 1
         e.g. John Smith<separator>123 Main Street [CHAR-LIMIT=NONE]-->
    <string name="autofill_address_summary_separator">,\u0020</string>
    <!-- Format string for displaying a name and address summary. $1 is the Full Name, $2 is autofill_address_summary_separator, $3 is the Address
         e.g. (John Smith)(, )(123 Main Street) -->
    <string name="autofill_address_summary_format">$1$2$3</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_attention_ignored_re">attention|attn</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_region_ignored_re">province|region|other<!-- es -->|provincia<!-- pt-BR, pt-PT -->|bairro|suburb</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_company_re">company|business|organization|organisation|department<!-- de-DE -->|firma|firmenname<!-- es -->|empresa<!-- fr-FR -->|societe|société<!-- it-IT -->|ragione.?sociale<!-- ja-JP -->|会社<!-- ru -->|название.?компании<!-- zh-CN -->|单位|公司</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_address_line_1_re">address.?line|address1|addr1|street<!-- de-DE -->|strasse|straße|hausnummer|housenumber<!-- en-GB -->|house.?name<!-- es -->|direccion|dirección<!-- fr-FR -->|adresse<!-- it-IT -->|indirizzo<!-- ja-JP -->|住所1<!-- pt-BR, pt-PT -->|morada|endereço<!-- ru -->|Адрес<!-- zh-CN -->|地址</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_address_line_1_label_re">address<!-- fr-FR -->|adresse<!-- it-IT -->|indirizzo<!-- ja-JP -->|住所<!-- zh-CN -->|地址</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_address_line_2_re">address.?line2|address2|addr2|street|suite|unit<!-- de-DE -->|adresszusatz|ergänzende.?angaben<!-- es -->|direccion2|colonia|adicional<!-- fr-FR -->|addresssuppl|complementnom|appartement<!-- it-IT -->|indirizzo2<!-- ja-JP -->|住所2</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_address_line_3_re">address.?line3|address3|addr3|street|line3<!-- es -->|municipio<!-- fr-FR -->|batiment|residence<!-- it-IT -->|indirizzo3</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_country_re">country|location<!-- ja-JP -->|国<!-- zh-CN -->|国家</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_zip_code_re">zip|postal|post code|pcode|^1z$<!-- de-DE -->|postleitzahl<!-- es -->|cp<!-- fr-FR -->|cdp<!-- it-IT -->|cap<!-- ja-JP -->|郵便番号<!-- pt-BR, pt-PT -->|codigo|codpos|cep<!-- ru -->|Почтовый.?Индекс<!--zh-CN -->|邮政编码|邮编<!-- zh-TW -->|郵遞區號</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_zip_4_re">zip|^-$|post2<!-- pt-BR, pt-PT -->|codpos2</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_city_re">city|town<!-- de-DE -->|ort|stadt<!-- en-AU -->|suburb<!-- es -->|ciudad|provincia|localidad|poblacion<!-- fr-FR -->|ville|commune<!-- it-IT -->|localita<!-- ja-JP -->|市区町村<!-- pt-BR, pt-PT -->|cidade<!-- ru -->|Город<!-- zh-CN -->|市<!-- zh-TW -->|分區</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_state_re">state|county|region|province<!-- de-DE -->|land<!-- en-UK -->|county|principality<!-- ja-JP -->|都道府県<!-- pt-BR, pt-PT -->|estado|provincia<!-- ru -->|область<!-- zh-CN -->|省<!-- zh-TW -->|地區</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_address_type_same_as_re">same as</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_address_type_use_my_re">use my</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_billing_designator_re">bill</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_shipping_designator_re">ship</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_email_re">e.?mail<!-- ja-JP -->|メールアドレス<!-- ru -->|Электронной.?Почты<!-- zh-CN -->|邮件|邮箱<!-- zh-TW -->|電郵地址</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_username_re">user.?name|user.?id<!-- de-DE -->|vollständiger.?name<!-- zh-CN -->|用户名</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_name_re">^name|full.?name|your.?name|customer.?name|firstandlastname<!-- es -->|nombre.*y.*apellidos<!-- fr-FR -->|^nom<!-- ja-JP -->|お名前|氏名<!-- pt-BR, pt-PT -->|^nome<!-- zh-CN -->|姓名</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_name_specific_re">^name<!-- fr-FR -->|^nom<!-- pt-BR, pt-PT -->|^nome</string>

    <!-- Do not translate. Regex used by AutoFill. -->

    <string name="autofill_first_name_re">irst.*name|initials|fname|first$<!-- de-DE -->|vorname<!-- es -->|nombre<!-- fr-FR -->|forename|prénom|prenom<!-- ja-JP -->|名<!-- pt-BR, pt-PT -->|nome<!-- ru -->|Имя</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_middle_initial_re">middle.*initial|m\\.i\\.|mi$</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_middle_name_re">middle.*name|mname|middle$<!-- es -->|apellido.?materno|lastlastname</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_last_name_re">last.*name|lname|surname|last$<!-- de-DE -->|nachname<!-- es -->|apellidos<!-- fr-FR -->|famille|^nom<!-- it-IT -->|cognome<!-- ja-JP -->|姓<!-- pt-BR, pt-PT -->|morada|apelidos|surename|sobrenome<!-- ru -->|Фамилия</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_phone_re">phone<!-- de-DE -->|telefonnummer<!-- es -->|telefono|teléfono<!-- fr-FR -->|telfixe<!-- ja-JP -->|電話<!-- pt-BR, pt-PT -->|telefone|telemovel<!-- ru -->|телефон<!-- zh-CN -->|电话</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_area_code_re">area.*code|acode|area</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_phone_prefix_re">prefix<!-- fr-FR -->|preselection<!-- pt-BR, pt-PT -->|ddd</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_phone_suffix_re">suffix</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_phone_extension_re">ext<!-- pt-BR, pt-PT -->|ramal</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_name_on_card_re">card.?holder|name.?on.?card|ccname|owner<!-- de-DE -->|karteninhaber<!-- es -->|nombre.*tarjeta<!-- fr-FR -->|nom.*carte<!-- it-IT -->|nome.*cart<!-- ja-JP -->|名前<!-- ru -->|Имя.*карты<!-- zh-CN -->|信用卡开户名|开户名|持卡人姓名<!-- zh-TW -->|持卡人姓名</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_name_on_card_contextual_re">name</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_card_cvc_re">verification|card identification|cvn|security code|cvv code|cvc</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_card_number_re">number|card.?#|card.?no|ccnum<!-- de-DE -->|nummer<!-- es -->|credito|numero|número<!-- fr-FR -->|numéro<!-- ja-JP -->|カード番号<!-- ru -->|Номер.*карты<!-- zh-CN -->|信用卡号|信用卡号码<!-- zh-TW -->|信用卡卡號</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_expiration_month_re">expir|exp.*month|exp.*date|ccmonth<!-- de-DE -->|gueltig|gültig|monat<!-- es -->|fecha<!-- fr-FR -->|date.*exp<!-- it-IT -->|scadenza<!-- ja-JP -->|有効期限<!-- pt-BR, pt-PT -->|validade<!-- ru -->|Срок действия карты<!-- zh-CN -->|月</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_expiration_date_re">exp|^/|year<!-- de-DE -->|ablaufdatum|gueltig|gültig|yahr<!-- es -->|fecha<!-- it-IT -->|scadenza<!-- ja-JP -->|有効期限<!-- pt-BR, pt-PT -->|validade<!-- ru -->|Срок действия карты<!-- zh-CN -->|年|有效期</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_card_ignored_re">^card</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_fax_re">fax<!-- fr-FR -->|télécopie|telecopie<!-- ja-JP -->|ファックス<!-- ru -->|факс<!-- zh-CN -->|传真<!-- zh-TW -->|傳真</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_country_code_re">country.*code|ccode|_cc</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_area_code_notext_re">^\\($</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_phone_prefix_separator_re">^-$|^\\)$</string>

    <!-- Do not translate. Regex used by AutoFill. -->
    <string name="autofill_phone_suffix_separator_re">^-$</string>

    <!-- Label in a web form for "Province" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_province">Province</string>

    <!-- Label in a web form for "Postal code" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_postal_code">Postal code</string>

    <!-- Label in a web form for "State" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_state">State</string>

    <!-- Label in a web form for "ZIP code" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_zip_code">ZIP code</string>

    <!-- Label in a web form for "County" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_county">County</string>

    <!-- Label in a web form for "Island" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_island">Island</string>

    <!-- Label in a web form for "District" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_district">District</string>

    <!-- Label in a web form for "Department" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_department">Department</string>

    <!-- Label in a web form for "Prefecture" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_prefecture">Prefecture</string>

    <!-- Label in a web form for "Parish" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_parish">Parish</string>

    <!-- Label in a web form for "Area" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_area">Area</string>

    <!-- Label in a web form for "Emirate" [CHAR-LIMIT=NONE]  -->
    <string name="autofill_emirate">Emirate</string>


    <!-- Title of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permlab_readHistoryBookmarks">read your Web bookmarks and history</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permdesc_readHistoryBookmarks">Allows the app to read the
     history of all URLs that the Browser has visited, and all of the Browser\'s
     bookmarks. Note: this permission may not be enforced by third-party
     browsers or other  applications with web browsing capabilities.</string>
    <!-- Title of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->

    <string name="permlab_writeHistoryBookmarks">write web bookmarks and history</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permdesc_writeHistoryBookmarks" product="tablet">Allows the
        app to modify the Browser\'s history or bookmarks stored on your tablet.
        This may allow the app to erase or modify Browser data.  Note: this
        permission may note be enforced by third-party browsers or other
        applications with web browsing capabilities.</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permdesc_writeHistoryBookmarks" product="tv">Allows the
        app to modify the Browser\'s history or bookmarks stored on your Android TV device.
        This may allow the app to erase or modify Browser data.  Note: this
        permission may note be enforced by third-party browsers or other
        applications with web browsing capabilities.</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permdesc_writeHistoryBookmarks" product="default">Allows the
        app to modify the Browser\'s history or bookmarks stored on your phone.
        This may allow the app to erase or modify Browser data.  Note:
        this permission may note be enforced by third-party browsers or other
        applications with web browsing capabilities.</string>

    <!-- Title of an application permission, listed so the user can choose whether
    they want to allow the application to do this. -->
    <string name="permlab_setAlarm">set an alarm</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permdesc_setAlarm">Allows the app to set an alarm in
        an installed alarm clock app. Some alarm clock apps may
        not implement this feature.</string>

    <!-- Title of an application permission, listed so the user can choose whether
        they want to allow the application to do this. [CHAR LIMIT=NONE] -->
    <string name="permlab_addVoicemail">add voicemail</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. [CHAR LIMIT=NONE] -->
    <string name="permdesc_addVoicemail">Allows the app to add messages
      to your voicemail inbox.</string>

    <!-- Title of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permlab_writeGeolocationPermissions">modify Browser geolocation permissions</string>
    <!-- Description of an application permission, listed so the user can choose whether
        they want to allow the application to do this. -->
    <string name="permdesc_writeGeolocationPermissions">Allows the app to modify the
        Browser\'s geolocation permissions. Malicious apps
        may use this to allow sending location information to arbitrary web sites.</string>

    <!-- If the user enters a password in a form on a website, a dialog will come up asking if they want to save the password. Text in the save password dialog, asking if the browser should remember a password. -->
    <string name="save_password_message">Do you want the browser to remember this password?</string>
    <!-- If the user enters a password in a form on a website, a dialog will come up asking if they want to save the password. Button in the save password dialog, saying not to remember this password. -->
    <string name="save_password_notnow">Not now</string>
    <!-- If the user enters a password in a form on a website, a dialog will come up asking if they want to save the password. Button in the save password dialog, saying to remember this password. -->
    <string name="save_password_remember">Remember</string>
    <!-- Button in the save password dialog, saying never to remember this password. This should be short. Should be "Never for this site". But it is too long, use "Never" instead -->
    <string name="save_password_never">Never</string>

    <!-- Displayed to the user when they do not have permission to open a particular web page. -->
    <string name="open_permission_deny">You don\'t have permission to open this page.</string>

    <!-- Displayed to the user to confirm that they have copied text from a web page to the clipboard. -->
    <string name="text_copied">Text copied to clipboard.</string>

    <!-- Displayed to the user to confirm that they have copied text/images to the clipboard [CHAR LIMIT=NONE] -->
    <string name="copied">Copied</string>

    <!-- Menu item displayed at the end of a menu to allow users to see another page worth of menu items. This is shown on any app's menu as long as the app has too many items in the menu.-->
    <string name="more_item_label">More</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the MENU button together with the shortcut to invoke the item. For example, if the shortcut to open a new tab in browser is MENU and B together, then this would be prepended to the letter "B" -->
    <string name="prepend_shortcut_label">Menu+</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the META key together with the shortcut to invoke the item. -->
    <string name="menu_meta_shortcut_label">Meta+</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the CTRL key together with the shortcut to invoke the item. -->
    <string name="menu_ctrl_shortcut_label">Ctrl+</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the ALT key together with the shortcut to invoke the item. -->
    <string name="menu_alt_shortcut_label">Alt+</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the SHIFT key together with the shortcut to invoke the item. -->
    <string name="menu_shift_shortcut_label">Shift+</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the SYM key together with the shortcut to invoke the item. -->
    <string name="menu_sym_shortcut_label">Sym+</string>
    <!-- Prepended to the shortcut for a menu item to indicate that the user should hold the FUNCTION key together with the shortcut to invoke the item. -->
    <string name="menu_function_shortcut_label">Function+</string>
    <!-- Displayed in place of the regular shortcut letter when a menu item has Menu+space for the shortcut. -->
    <string name="menu_space_shortcut_label">space</string>
    <!-- Displayed in place of the regular shortcut letter when a menu item has Menu+enter for the shortcut. -->
    <string name="menu_enter_shortcut_label">enter</string>
    <!-- Displayed in place of the regular shortcut letter when a menu item has Menu+delete for the shortcut. -->
    <string name="menu_delete_shortcut_label">delete</string>

    <!-- Strings used for search bar --><skip />

    <!-- This is the default button label in the system-wide search UI.
         It is also used by the home screen's search "widget". It should be short -->
    <string name="search_go">Search</string>
    <!-- Default hint text for the system-wide search UI's text field. [CHAR LIMIT=30] -->
    <string name="search_hint">Search\u2026</string>
    <!-- SearchView accessibility description for search button [CHAR LIMIT=NONE] -->
    <string name="searchview_description_search">Search</string>
    <!-- SearchView accessibility description for search text field [CHAR LIMIT=NONE] -->
    <string name="searchview_description_query">Search query</string>
    <!-- SearchView accessibility description for clear button [CHAR LIMIT=NONE] -->
    <string name="searchview_description_clear">Clear query</string>
    <!-- SearchView accessibility description for submit button [CHAR LIMIT=NONE] -->
    <string name="searchview_description_submit">Submit query</string>
    <!-- SearchView accessibility description for voice button [CHAR LIMIT=NONE] -->
    <string name="searchview_description_voice">Voice search</string>

    <!-- Title for a warning message about the interaction model changes after allowing an accessibility
         service to put the device into explore by touch mode, displayed as a dialog message when
         the user selects to enables the service. (default). [CHAR LIMIT=45] -->
    <string name="enable_explore_by_touch_warning_title">Enable Explore by Touch?</string>
    <!-- Summary for a warning message about the interaction model changes after allowing an accessibility
         service to put the device into explore by touch mode, displayed as a dialog message when
         the user selects to enables the service. (tablet). [CHAR LIMIT=NONE] -->
    <string name="enable_explore_by_touch_warning_message" product="tablet">
        <xliff:g id="accessibility_service_name">%1$s</xliff:g> wants to enable Explore by Touch.
        When Explore by Touch is turned on, you can hear or see descriptions of what\'s under
        your finger or perform gestures to interact with the tablet.</string>
    <!-- Summary for a warning message about the interaction model changes after allowing an accessibility
         service to put the device into explore by touch mode, displayed as a dialog message when
         the user selects to enables the service. (default). [CHAR LIMIT=NONE] -->
    <string name="enable_explore_by_touch_warning_message" product="default">
        <xliff:g id="accessibility_service_name">%1$s</xliff:g> wants to enable Explore by Touch.
       When Explore by Touch is turned on, you can hear or see descriptions of what\'s under
       your finger or perform gestures to interact with the phone.</string>

    <!-- String used to display the date. This is the string to say something happened 1 month ago. -->
    <string name="oneMonthDurationPast">1 month ago</string>
    <!-- String used to display the date. This is the string to say something happened more than 1 month ago. -->
    <string name="beforeOneMonthDurationPast">Before 1 month ago</string>

    <!-- This is used to express that something occurred within the last X days (e.g., Last 7 days). -->
    <plurals name="last_num_days">
        <item quantity="one">Last <xliff:g id="count">%d</xliff:g> day</item>
        <item quantity="other">Last <xliff:g id="count">%d</xliff:g> days</item>
    </plurals>

    <!-- This is used to express that something has occurred within the last month -->
    <string name="last_month">Last month</string>

    <!-- This is used to express that something happened longer ago than the previous options -->
    <string name="older">Older</string>

    <!-- String used to display the date. Preposition for date display ("on May 29") -->
    <string name="preposition_for_date">on <xliff:g id="date" example="May 29">%s</xliff:g></string>
    <!-- String used to display the date. Preposition for time display ("at 2:33am") -->
    <string name="preposition_for_time">at <xliff:g id="time" example="2:33 am">%s</xliff:g></string>
    <!-- String used to display the date. Preposition for year display ("in 2008") -->
    <string name="preposition_for_year">in <xliff:g id="year" example="2003">%s</xliff:g></string>

    <!-- Appened to express the value is this unit of time: singular day -->
    <string name="day">day</string>
    <!-- Appened to express the value is this unit of time: plural days -->
    <string name="days">days</string>
    <!-- Appened to express the value is this unit of time: singular hour -->
    <string name="hour">hour</string>
    <!-- Appened to express the value is this unit of time: plural hours -->
    <string name="hours">hours</string>
    <!-- Appened to express the value is this unit of time: singular minute -->
    <string name="minute">min</string>
    <!-- Appened to express the value is this unit of time: plural minutes -->
    <string name="minutes">mins</string>
    <!-- Appened to express the value is this unit of time. -->
    <string name="second">sec</string>
    <!-- Appened to express the value is this unit of time. -->
    <string name="seconds">secs</string>
    <!-- Appened to express the value is this unit of time. -->
    <string name="week">week</string>
    <!-- Appened to express the value is this unit of time. -->
    <string name="weeks">weeks</string>
    <!-- Appened to express the value is this unit of time. -->
    <string name="year">year</string>
    <!-- Appened to express the value is this unit of time. -->
    <string name="years">years</string>

    <!-- A string denoting the current point in time that should be as short as possible. Abbreviations are preferred to full strings as this might be shown repetitively. It is used in the header of notifications. [CHAR LIMIT=8]-->
    <string name="now_string_shortest">now</string>

    <!-- Phrase describing a time duration using minutes that is as short as possible, preferrably one character. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=6] -->
    <plurals name="duration_minutes_shortest">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g>m</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g>m</item>
    </plurals>

    <!-- Phrase describing a time duration using hours that is as short as possible, preferrably one character. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=6] -->
    <plurals name="duration_hours_shortest">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g>h</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g>h</item>
    </plurals>

    <!-- Phrase describing a time duration using days that is as short as possible, preferrably one character. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=6] -->
    <plurals name="duration_days_shortest">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g>d</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g>d</item>
    </plurals>

    <!-- Phrase describing a time duration using years that is as short as possible, preferrably one character. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=6] -->
    <plurals name="duration_years_shortest">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g>y</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g>y</item>
    </plurals>

    <!-- Phrase describing a time duration using minutes that is as short as possible, preferrably one character. This version should be a future point in time. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=14] -->
    <plurals name="duration_minutes_shortest_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g>m</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g>m</item>
    </plurals>

    <!-- Phrase describing a time duration using hours that is as short as possible, preferrably one character. This version should be a future point in time. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=14] -->
    <plurals name="duration_hours_shortest_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g>h</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g>h</item>
    </plurals>

    <!-- Phrase describing a time duration using days that is as short as possible, preferrably one character. This version should be a future point in time. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=14] -->
    <plurals name="duration_days_shortest_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g>d</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g>d</item>
    </plurals>

    <!-- Phrase describing a time duration using years that is as short as possible, preferrably one character. This version should be a future point in time. If the language needs a space in between the integer and the unit, please also integrate it in the string, but preferably it should not have a space in between.[CHAR LIMIT=14] -->
    <plurals name="duration_years_shortest_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g>y</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g>y</item>
    </plurals>

    <!-- Phrase describing a relative time using minutes in the past that is not shown on the screen but used for accessibility. [CHAR LIMIT=NONE] -->
    <plurals name="duration_minutes_relative">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g> minute ago</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g> minutes ago</item>
    </plurals>

    <!-- Phrase describing a relative time using hours in the past that is not shown on the screen but used for accessibility. [CHAR LIMIT=NONE] -->
    <plurals name="duration_hours_relative">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g> hour ago</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g> hours ago</item>
    </plurals>

    <!-- Phrase describing a relative time using days in the past that is not shown on the screen but used for accessibility. [CHAR LIMIT=NONE] -->
    <plurals name="duration_days_relative">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g> day ago</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g> days ago</item>
    </plurals>

    <!-- Phrase describing a relative time using years in the past that is not shown on the screen but used for accessibility. [CHAR LIMIT=NONE] -->
    <plurals name="duration_years_relative">
        <item quantity="one"><xliff:g example="1" id="count">%d</xliff:g> year ago</item>
        <item quantity="other"><xliff:g example="2" id="count">%d</xliff:g> years ago</item>
    </plurals>

    <!-- Phrase describing a relative time using minutes that is not shown on the screen but used for accessibility. This version should be a future point in time. [CHAR LIMIT=NONE] -->
    <plurals name="duration_minutes_relative_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g> minute</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g> minutes</item>
    </plurals>

    <!-- Phrase describing a relative time using hours that is not shown on the screen but used for accessibility. This version should be a future point in time. [CHAR LIMIT=NONE] -->
    <plurals name="duration_hours_relative_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g> hour</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g> hours</item>
    </plurals>

    <!-- Phrase describing a relative time using days that is not shown on the screen but used for accessibility. This version should be a future point in time. [CHAR LIMIT=NONE] -->
    <plurals name="duration_days_relative_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g> day</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g> days</item>
    </plurals>

    <!-- Phrase describing a relative time using years that is not shown on the screen but used for accessibility. This version should be a future point in time. [CHAR LIMIT=NONE] -->
    <plurals name="duration_years_relative_future">
        <item quantity="one">in <xliff:g example="1" id="count">%d</xliff:g> year</item>
        <item quantity="other">in <xliff:g example="2" id="count">%d</xliff:g> years</item>
    </plurals>

    <!-- Title for error alert when a video cannot be played.  it can be used by any app. -->
    <string name="VideoView_error_title">Video problem</string>
    <!-- Text for error alert when a video container is not valid for progressive download/playback. -->
    <string name="VideoView_error_text_invalid_progressive_playback">This video isn\'t valid for streaming to this device.</string>
    <!-- Text for error alert when a video cannot be played. it can be used by any app. -->
    <string name="VideoView_error_text_unknown">Can\'t play this video.</string>
    <!-- Button to close error alert when a video cannot be played -->
    <string name="VideoView_error_button">OK</string>




    <!-- Format indicating a relative expression and time.
         Example: "4 hours ago, 11:00 am" -->
    <string name="relative_time">"<xliff:g id="date" example="4 hours ago">%1$s</xliff:g>, <xliff:g id="time" example="11:00 am">%2$s</xliff:g>"</string>


    <!-- Quoted name for 12pm, lowercase -->
    <string name="noon">"noon"</string>
    <!-- Quoted name for 12pm, uppercase first letter -->
    <string name="Noon">"Noon"</string>
    <!-- Quoted name for 12am, lowercase -->
    <string name="midnight">"midnight"</string>
    <!-- Quoted name for 12am, uppercase first letter -->
    <string name="Midnight">"Midnight"</string>











    <!-- Format string for durations like "01:23" (1 minute, 23 seconds) -->
    <string name="elapsed_time_short_format_mm_ss"><xliff:g id="minutes" example="1">%1$02d</xliff:g>:<xliff:g id="seconds" example="23">%2$02d</xliff:g></string>

    <!-- Format string for times like "1:43:33" (1 hour, 43 minutes, 33 seconds) -->
    <string name="elapsed_time_short_format_h_mm_ss"><xliff:g id="hours" example="1">%1$d</xliff:g>:<xliff:g id="minutes" example="43">%2$02d</xliff:g>:<xliff:g id="seconds" example="33">%3$02d</xliff:g></string>

    <!-- Item on EditText context menu. This action is used to select all text in the edit field. -->
    <string name="selectAll">Select all</string>

    <!-- Item on EditText context menu.  This action is used to cut selected the text into the clipboard.  -->
    <string name="cut">Cut</string>

    <!-- Item on EditText context menu. This action is used to cut selected the text into the clipboard. -->
    <string name="copy">Copy</string>

    <!-- Error shown by TextView/EditText when cut/copy operation fails because text is too long to copy into the clipboard. -->
    <string name="failed_to_copy_to_clipboard">Failed to copy to clipboard</string>

    <!-- Item on EditText context menu. This action is used to paste from the clipboard into the eidt field -->
    <string name="paste">Paste</string>

    <!-- Item on EditText context menu. This action is used to paste from the clipboard into the eidt field without formatting -->
    <string name="paste_as_plain_text">Paste as plain text</string>

    <!-- Item on EditText context menu. This action is used to replace the current word by other suggested words, suggested by the IME or the spell checker -->
    <string name="replace">Replace\u2026</string>

    <!-- Item on EditText pop-up window. This action is used to delete the text that the user recently added. [CHAR LIMIT=15] -->
    <string name="delete">Delete</string>

    <!-- Item on EditText context menu. This action is used to copy a URL from the edit field into the clipboard. -->
    <string name="copyUrl">Copy URL</string>

    <!-- Item on EditText context menu. Added only when the context menu is not empty, it enable selection context mode. [CHAR LIMIT=20] -->
    <string name="selectTextMode">Select text</string>

    <!-- Item on EditText context menu. This action is used to undo a text edit operation. -->
    <string name="undo">Undo</string>

    <!-- Item on EditText context menu. This action is used to redo a text edit operation. -->
    <string name="redo">Redo</string>

    <!-- Item on EditText context menu. This action is used to request autofill. -->
    <string name="autofill">Autofill</string>

    <!-- Text selection contextual mode title, displayed in the CAB. [CHAR LIMIT=20] -->
    <string name="textSelectionCABTitle">Text selection</string>

    <!-- Option to add the current misspelled word to the user dictionary. [CHAR LIMIT=25] -->
    <string name="addToDictionary">Add to dictionary</string>

    <!-- Option to delete the highlighted part of the text from the suggestion popup. [CHAR LIMIT=25] -->
    <string name="deleteText">Delete</string>

    <!-- EditText context menu -->
    <string name="inputMethod">Input method</string>

    <!-- Title for EditText context menu [CHAR LIMIT=20] -->
    <string name="editTextMenuTitle">Text actions</string>

    <!-- Label for item in the text selection menu to trigger an Email app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="email">Email</string>

    <!-- Accessibility description for an item in the text selection menu to trigger an Email app [CHAR LIMIT=NONE] -->
    <string name="email_desc">Email selected address</string>

    <!-- Label for item in the text selection menu to trigger a Dialer app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="dial">Call</string>

    <!-- Accessibility description for an item in the text selection menu to call a phone number [CHAR LIMIT=NONE] -->
    <string name="dial_desc">Call selected phone number</string>

    <!-- Label for item in the text selection menu to trigger a Map app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="map">Map</string>

    <!-- Accessibility description for an item in the text selection menu to open maps for an address [CHAR LIMIT=NONE] -->
    <string name="map_desc">Locate selected address</string>

    <!-- Label for item in the text selection menu to trigger a Browser app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="browse">Open</string>

    <!-- Accessibility description for an item in the text selection menu to open a URL in a browser [CHAR LIMIT=NONE] -->
    <string name="browse_desc">Open selected URL</string>

    <!-- Label for item in the text selection menu to trigger an SMS app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="sms">Message</string>

    <!-- Accessibility description for an item in the text selection menu to send an SMS to a phone number [CHAR LIMIT=NONE] -->
    <string name="sms_desc">Message selected phone number</string>

    <!-- Label for item in the text selection menu to trigger adding a contact. Should be a verb. [CHAR LIMIT=30] -->
    <string name="add_contact">Add</string>

    <!-- Accessibility description for an item in the text selection menu to add the selected detail to contacts [CHAR LIMIT=NONE] -->
    <string name="add_contact_desc">Add to contacts</string>

    <!-- Label for item in the text selection menu to view the calendar for the selected time/date. Should be a verb. [CHAR LIMIT=30] -->
    <string name="view_calendar">View</string>

    <!-- Accessibility description for an item in the text selection menu to view the calendar for a date [CHAR LIMIT=NONE]-->
    <string name="view_calendar_desc">View selected time in calendar</string>

    <!-- Label for item in the text selection menu to create a calendar event at the selected time/date. Should be a verb. [CHAR LIMIT=30] -->
    <string name="add_calendar_event">Schedule</string>

    <!-- Accessibility description for an item in the text selection menu to schedule an event for a date [CHAR LIMIT=NONE] -->
    <string name="add_calendar_event_desc">Schedule event for selected time</string>

    <!-- Label for item in the text selection menu to track a selected flight number. Should be a verb. [CHAR LIMIT=30] -->
    <string name="view_flight">Track</string>

    <!-- Accessibility description for an item in the text selection menu to track a flight [CHAR LIMIT=NONE] -->
    <string name="view_flight_desc">Track selected flight</string>

    <!-- Label for item in the text selection menu to translate selected text with a translation app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="translate">Translate</string>

    <!-- Accessibility description for an item in the text selection menu to translate selected text with a translation app. [CHAR LIMIT=NONE] -->
    <string name="translate_desc">Translate selected text</string>

    <!-- Label for item in the text selection menu to define selected text with a dictionary app. Should be a verb. [CHAR LIMIT=30] -->
    <string name="define">Define</string>

    <!-- Accessibility description for an item in the text selection menu to define selected text with a dictionary app. Should be a verb. [CHAR LIMIT=NONE] -->
    <string name="define_desc">Define selected text</string>

    <!-- If the device is getting low on internal storage, a notification is shown to the user.  This is the title of that notification. -->
    <string name="low_internal_storage_view_title">Storage space running out</string>
    <!-- If the device is getting low on internal storage, a notification is shown to the user.  This is the message of that notification. -->
    <string name="low_internal_storage_view_text">Some system functions may not work</string>
    <!-- If the device does not have storage for the main system classes, a notification is shown to the user.  This is the message of that notification. -->
    <string name="low_internal_storage_view_text_no_boot">Not enough storage for the system. Make sure you have 250MB of free space and restart.</string>

    <!-- [CHAR LIMIT=NONE] Stub notification title for an app running a service that has provided
         a bad bad notification for itself. -->
    <string name="app_running_notification_title"><xliff:g id="app_name">%1$s</xliff:g>
        is running</string>
    <!-- [CHAR LIMIT=NONE] Stub notification text for an app running a service that has provided
         a bad bad notification for itself. -->
    <string name="app_running_notification_text">Tap for more information
        or to stop the app.</string>

    <!-- Preference framework strings. -->
    <string name="ok">OK</string>
    <!-- Preference framework strings. -->
    <string name="cancel">Cancel</string>
    <!-- Preference framework strings. {@deprecated Do not use. Incorrectly matches android.R.string.ok rather than "yes".} -->
    <string name="yes">OK</string>
    <!-- Preference framework strings. {@deprecated Do not use. Incorrectly matches android.R.string.cancel rather than "no".} -->
    <string name="no">Cancel</string>
    <!-- This is the generic "attention" string to be used in attention dialogs.  Typically
         combined with setIconAttribute(android.R.attr.alertDialogIcon)
         (or setIcon(android.R.drawable.ic_dialog_alert) on legacy versions of the platform) -->
    <string name="dialog_alert_title">Attention</string>

    <!-- Text shown by list fragment when waiting for data to display. -->
    <string name="loading">Loading\u2026</string>

    <!-- Default text for a button that can be toggled on and off. -->
    <string name="capital_on">ON</string>
    <!-- Default text for a button that can be toggled on and off. -->
    <string name="capital_off">OFF</string>

    <!-- Default state for CompoundButton for on and off. [CHAR LIMIT=32] -->
    <string name="checked">checked</string>
    <!-- Default text for a button that can be toggled on and off. [CHAR LIMIT=32] -->
    <string name="not_checked">not checked</string>

    <!-- Title of intent resolver dialog when selecting an application to run. -->
    <string name="whichApplication">Complete action using</string>
    <!-- Title of intent resolver dialog when selecting an application to run
         and a previously used application is known. -->
    <string name="whichApplicationNamed">Complete action using %1$s</string>
    <!-- Generic label for a link to a intent resolver. -->
    <string name="whichApplicationLabel">Complete action</string>
    <!-- Title of intent resolver dialog when selecting a viewer application to run. -->
    <string name="whichViewApplication">Open with</string>
    <!-- Title of intent resolver dialog when selecting a viewer application to run
         and a previously used application is known. -->
    <string name="whichViewApplicationNamed">Open with %1$s</string>
    <!-- Label for a link to a intent resolver dialog to view something -->
    <string name="whichViewApplicationLabel">Open</string>
    <!-- Title of intent resolver dialog when selecting a browser/application that opens specific URIs
         [CHAR LIMIT=128]. -->
    <string name="whichOpenHostLinksWith">Open <xliff:g id="host" example="mail.google.com">%1$s</xliff:g> links with</string>
    <!-- Title of intent resolver dialog when selecting a browser that opens URI
         [CHAR LIMIT=128]. -->
    <string name="whichOpenLinksWith">Open links with</string>
    <!-- Title of intent resolver dialog when defaulting to a specific browser that opens URI
         [CHAR LIMIT=128]. -->
    <string name="whichOpenLinksWithApp">Open links with <xliff:g id="application" example="Chrome">%1$s</xliff:g></string>
    <!-- Title of intent resolver dialog when defaulting to a specific browser that opens URI
         [CHAR LIMIT=128]. -->
    <string name="whichOpenHostLinksWithApp">Open <xliff:g id="host" example="mail.google.com">%1$s</xliff:g> links with <xliff:g id="application" example="Chrome">%2$s</xliff:g></string>
    <!-- Title of intent resolver dialog when selecting a viewer application that opens URI
         and a previously used application is known [CHAR LIMIT=128]. -->
    <!-- Label for a link to an intent resolver dialog to open URI [CHAR LIMIT=18] -->
    <string name="whichGiveAccessToApplicationLabel">Give access</string>
    <!-- Title of intent resolver dialog when selecting an editor application to run. -->
    <string name="whichEditApplication">Edit with</string>
    <!-- Title of intent resolver dialog when selecting an editor application to run
         and a previously used application is known. -->
    <string name="whichEditApplicationNamed">Edit with %1$s</string>
    <!-- Label for a link to a intent resolver dialog when selecting an editor application -->
    <string name="whichEditApplicationLabel">Edit</string>
    <!-- Title of intent resolver dialog when selecting a sharing application to run. -->
    <string name="whichSendApplication">Share</string>
    <!-- Title of intent resolver dialog when selecting a sharing application to run
         and a previously used application is known. -->
    <string name="whichSendApplicationNamed">Share with %1$s</string>
    <!-- Label for a link to a intent resolver dialog to sharing something -->
    <string name="whichSendApplicationLabel">Share</string>
    <!-- Title of intent resolver dialog when selecting an application to run to
         send content to a specific recipient. Often used for email. -->
    <string name="whichSendToApplication">Send using</string>
    <!-- Title of intent resolver dialog when selecting an application to run to
         send content to a specific recipient and a previously used application is known.
         Often used for email. -->
    <string name="whichSendToApplicationNamed">Send using %1$s</string>
    <!-- Label for a link to a intent resolver dialog to send content to a specific recipient. -->
    <string name="whichSendToApplicationLabel">Send</string>
    <!-- Title of intent resolver dialog when selecting a HOME application to run. -->
    <string name="whichHomeApplication">Select a Home app</string>
    <!-- Title of intent resolver dialog when selecting a HOME application to run
         and a previously used application is known. -->
    <string name="whichHomeApplicationNamed">Use %1$s as Home</string>
    <!-- Label for a link to a intent resolver dialog when selecting a HOME -->
    <string name="whichHomeApplicationLabel">Capture image</string>
    <!-- Option to always use the selected application resolution in the future. See the "Complete action using" dialog title-->
    <!-- Title of intent resolver dialog when capturing an image. -->
    <string name="whichImageCaptureApplication">Capture image with</string>
    <!-- Title of intent resolver dialog when capturing an image
         and a previously used application is known. -->
    <string name="whichImageCaptureApplicationNamed">Capture image with %1$s</string>
    <!-- Label for a link to a intent resolver dialog when capturing an image -->
    <string name="whichImageCaptureApplicationLabel">Capture image</string>
    <!-- Option to always use the selected application resolution in the future. See the "Complete action using" dialog title-->
    <string name="alwaysUse">Use by default for this action.</string>
    <!-- Title of the list of alternate options to complete an action shown when the
         last used option is being displayed separately. -->
    <string name="use_a_different_app">Use a different app</string>
    <!-- Text displayed when the user selects the check box for setting default application.  See the "Use by default for this action" check box. -->
    <string name="clearDefaultHintMsg">Clear default in System settings &gt; Apps &gt; Downloaded.</string>
    <!-- Default title for the activity chooser, when one is not given. Android allows multiple activities to perform an action.  for example, there may be many ringtone pickers installed.  A dialog is shown to the user allowing him to pick which activity should be used.  This is the title. -->
    <string name="chooseActivity">Choose an action</string>
    <!-- title for the USB activity chooser. -->
    <string name="chooseUsbActivity">Choose an app for the USB device</string>
    <!-- Text to display when there are no activities found to display in the
         activity chooser. See the "Select an action" title. -->
    <string name="noApplications">No apps can perform this action.</string>
    <!-- Text of the alert that is displayed when an application has crashed. -->
    <string name="aerr_application"><xliff:g id="application">%1$s</xliff:g> has stopped</string>
    <!-- Text of the alert that is displayed when a process has crashed. -->
    <string name="aerr_process"><xliff:g id="process">%1$s</xliff:g> has
        stopped</string>
    <!-- Text of the alert that is displayed when an application has crashed repeatedly. -->
    <string name="aerr_application_repeated"><xliff:g id="application">%1$s</xliff:g> keeps stopping</string>
    <!-- Text of the alert that is displayed when a process has crashed repeatedly. -->
    <string name="aerr_process_repeated"><xliff:g id="process">%1$s</xliff:g> keeps stopping</string>
    <!-- Button that restarts a crashed application -->
    <string name="aerr_restart">Open app again</string>
    <!-- Button that sends feedback about a crashed application -->
    <string name="aerr_report">Send feedback</string>
    <!-- Button that closes a crashed application -->
    <string name="aerr_close">Close</string>
    <!-- Button that mutes further crashes of the crashed application. Note that this only appears on engineering builds. -->
    <string name="aerr_mute">Mute until device restarts</string>
    <!-- Button that waits a bit more for an unresponsive app -->
    <string name="aerr_wait">Wait</string>
    <!-- Button that closes an unresponsive application -->
    <string name="aerr_close_app">Close app</string>

    <!-- Title of the alert when an application is not responding. -->
    <string name="anr_title"></string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_activity_application"><xliff:g id="application">%2$s</xliff:g> isn\'t responding</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_activity_process"><xliff:g id="activity">%1$s</xliff:g> isn\'t responding</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_application_process"><xliff:g id="application">%1$s</xliff:g> isn\'t responding</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_process">Process <xliff:g id="process">%1$s</xliff:g> isn\'t responding</string>
    <!-- Button allowing the user to close an application that is not responding. This will kill the application. -->
    <string name="force_close">OK</string>
    <!-- Button allowing the user to send a bug report for application which has encountered an error. -->
    <string name="report">Report</string>
    <!-- Button allowing the user to choose to wait for an application that is not responding to become responsive again. -->
    <string name="wait">Wait</string>
    <!-- Text of the alert that is displayed when a web page is not responding. [CHAR-LIMIT=NONE] -->
    <string name="webpage_unresponsive">The page has become unresponsive.\n\nDo you want to close it?</string>
    <!-- [CHAR LIMIT=25] Title of the alert when application launches on top of another. -->
    <string name="launch_warning_title">App redirected</string>
    <!-- [CHAR LIMIT=50] Title of the alert when application launches on top of another. -->
    <string name="launch_warning_replace"><xliff:g id="app_name">%1$s</xliff:g> is now running.</string>
    <!-- [CHAR LIMIT=50] Title of the alert when application launches on top of another. -->
    <string name="launch_warning_original"><xliff:g id="app_name">%1$s</xliff:g> was originally launched.</string>
    <!-- [CHAR LIMIT=50] Compat mode dialog: compat mode switch label. -->
    <string name="screen_compat_mode_scale">Scale</string>
    <!-- [CHAR LIMIT=50] Compat mode dialog: compat mode switch label. -->
    <string name="screen_compat_mode_show">Always show</string>
    <!-- [CHAR LIMIT=200] Compat mode dialog: hint to re-enable compat mode dialog. -->
    <string name="screen_compat_mode_hint">Re-enable this in System settings &gt; Apps &gt; Downloaded.</string>

    <!-- [CHAR LIMIT=200] Unsupported display size dialog: message. Refers to "Display size" setting. -->
    <string name="unsupported_display_size_message"><xliff:g id="app_name">%1$s</xliff:g> does not support the current Display size setting and may behave unexpectedly.</string>
    <!-- [CHAR LIMIT=50] Unsupported display size dialog: check box label. -->
    <string name="unsupported_display_size_show">Always show</string>

    <!-- [CHAR LIMIT=200] Unsupported compile SDK dialog: message. Shown when an app may not be compatible with the device's current version of Android. -->
    <string name="unsupported_compile_sdk_message"><xliff:g id="app_name">%1$s</xliff:g> was built for an incompatible version of the Android OS and may behave unexpectedly. An updated version of the app may be available.</string>
    <!-- [CHAR LIMIT=50] Unsupported compile SDK dialog: check box label. -->
    <string name="unsupported_compile_sdk_show">Always show</string>
    <!-- [CHAR LIMIT=50] Unsupported compile SDK dialog: label for button to check for an app update. -->
    <string name="unsupported_compile_sdk_check_update">Check for update</string>

    <!-- Text of the alert that is displayed when an application has violated StrictMode. -->
    <string name="smv_application">The app <xliff:g id="application">%1$s</xliff:g>
        (process <xliff:g id="process">%2$s</xliff:g>) has violated its self-enforced StrictMode policy.</string>
    <!-- Text of the alert that is displayed when an application has violated StrictMode. -->
    <string name="smv_process">The process <xliff:g id="process">%1$s</xliff:g> has
      has violated its self-enforced StrictMode policy.</string>

    <!-- [CHAR LIMIT=40] Title of dialog that is shown when performing a system update. -->
    <string name="android_upgrading_title" product="default">Phone is updating\u2026</string>
    <!-- [CHAR LIMIT=40] Title of dialog that is shown when performing a system update. -->
    <string name="android_upgrading_title" product="tablet">Tablet is updating\u2026</string>
    <!-- [CHAR LIMIT=40] Title of dialog that is shown when performing a system update. -->
    <string name="android_upgrading_title" product="device">Device is updating\u2026</string>

    <!-- [CHAR LIMIT=40] Title of dialog that is shown when system is starting. -->
    <string name="android_start_title" product="default">Phone is starting\u2026</string>
    <!-- [CHAR LIMIT=40] Title of dialog that is shown when system is starting. -->
    <string name="android_start_title" product="automotive">Android is starting\u2026</string>
    <!-- [CHAR LIMIT=40] Title of dialog that is shown when system is starting. -->
    <string name="android_start_title" product="tablet">Tablet is starting\u2026</string>
    <!-- [CHAR LIMIT=40] Title of dialog that is shown when system is starting. -->
    <string name="android_start_title" product="device">Device is starting\u2026</string>

    <!-- [CHAR LIMIT=NONE] Message shown in upgrading dialog when doing an fstrim. -->
    <string name="android_upgrading_fstrim">Optimizing storage.</string>

    <!-- [CHAR LIMIT=40] Title of notification that is shown when finishing a system update. -->
    <string name="android_upgrading_notification_title" product="default">Finishing system update\u2026</string>

    <!-- [CHAR LIMIT=40] Toast that is shown when an app is still upgrading. -->
    <string name="app_upgrading_toast"><xliff:g id="application">%1$s</xliff:g> is upgrading\u2026</string>

    <!-- [CHAR LIMIT=NONE] Message shown in upgrading dialog for each .apk that is optimized. -->
    <string name="android_upgrading_apk">Optimizing app
        <xliff:g id="number" example="123">%1$d</xliff:g> of
        <xliff:g id="number" example="123">%2$d</xliff:g>.</string>

    <!-- [CHAR LIMIT=NONE] Message shown in upgrading dialog for each .apk pre boot broadcast -->
    <string name="android_preparing_apk">Preparing <xliff:g id="appname">%1$s</xliff:g>.</string>

    <!-- [CHAR LIMIT=NONE] Message to show in upgrading dialog when reached the point of starting apps. -->
    <string name="android_upgrading_starting_apps">Starting apps.</string>

    <!-- [CHAR LIMIT=NONE] Message to show in upgrading dialog when the bulk of the upgrade work is done. -->
    <string name="android_upgrading_complete">Finishing boot.</string>

    <!-- Notification text to tell the user that a heavy-weight application is running. -->
    <string name="heavy_weight_notification"><xliff:g id="app">%1$s</xliff:g> running</string>

    <!-- Notification details to tell the user that a heavy-weight application is running. -->
    <string name="heavy_weight_notification_detail">Tap to return to game</string>

    <!-- Title of dialog prompting whether user wants to switch between heavy-weight apps. -->
    <string name="heavy_weight_switcher_title">Choose game</string>

    <!-- Descriptive text for switching to a new heavy-weight application. -->
    <string name="heavy_weight_switcher_text">For better performance, only one of these
        games can be open at a time.</string>

    <string name="old_app_action">Go back to <xliff:g id="old_app">%1$s</xliff:g></string>

    <string name="new_app_action">Open <xliff:g id="new_app">%1$s</xliff:g></string>
    <string name="new_app_description"><xliff:g id="old_app">%1$s</xliff:g> will close
        without saving</string>

    <!-- Notification text to tell the user that a process has exceeded its memory limit. -->
    <string name="dump_heap_notification"><xliff:g id="proc">%1$s</xliff:g> exceeded memory
        limit</string>

    <!-- Notification text to tell the user that a heap dump that they initiated for a process is ready [CHAR LIMIT=NONE] -->
    <string name="dump_heap_ready_notification">
        <xliff:g id="proc" example="com.android.example">%1$s</xliff:g> heap dump ready</string>

    <!-- Notification details to tell the user that a process has exceeded its memory limit. -->
    <string name="dump_heap_notification_detail">Heap dump collected. Tap to share.</string>

    <!-- Title of dialog prompting the user to share a heap dump. -->
    <string name="dump_heap_title">Share heap dump?</string>

    <!-- Text of dialog prompting the user to share a heap dump for an application [CHAR LIMIT=NONE] -->
    <string name="dump_heap_text">The
        <xliff:g id="proc" example="com.android.example">%1$s</xliff:g> process has exceeded
        its memory limit of <xliff:g id="size" example="350MB">%2$s</xliff:g>. A heap dump is available
        for you to share with its developer.  Be careful: this heap dump can contain any
        of your personal information that the application has access to.</string>

    <!-- Text of dialog prompting the user to share a heap dump for a system process [CHAR LIMIT=NONE] -->
    <string name="dump_heap_system_text">The
        <xliff:g id="proc" example="Android System">%1$s</xliff:g> process has exceeded
        its memory limit of <xliff:g id="size" example="350MB">%2$s</xliff:g>. A heap dump is available
        for you to share. Be careful: this heap dump can contain any sensitive personal information
        that the process has access to, which may include things you\u2019ve typed.</string>

    <!-- Text of dialog prompting the user to share a heap dump that they initiated [CHAR LIMIT=NONE] -->
    <string name="dump_heap_ready_text">A heap dump of
        <xliff:g id="proc" example="com.android.example">%1$s</xliff:g>\u2019s process is available
        for you to share. Be careful: this heap dump may contain any sensitive personal information
        that the process has access to, which may include things you\u2019ve typed.</string>

    <!-- Displayed in the title of the chooser for things to do with text that
         is to be sent to another application. For example, I can send
         text through SMS or IM.  A dialog with those choices would be shown,
         and this would be the title. -->
    <string name="sendText">Choose an action for text</string>

    <!-- Title of the dialog where the user is adjusting the phone ringer volume -->
    <string name="volume_ringtone">Ringer volume</string>
    <!-- Title of the dialog where the user is adjusting the music volume -->
    <string name="volume_music">Media volume</string>
    <!-- Hint shown in the volume toast to inform the user that the media audio is playing through Bluetooth. -->
    <string name="volume_music_hint_playing_through_bluetooth">Playing through Bluetooth</string>
    <!-- Hint shown in the volume toast to inform the user that the current ringtone is the silent ringtone. -->
    <string name="volume_music_hint_silent_ringtone_selected">Silent ringtone set</string>
    <!-- Title of the dialog where the user is adjusting the phone call volume -->
    <string name="volume_call">In-call volume</string>
    <!-- Title of the dialog where the user is adjusting the phone call volume when connected on bluetooth-->
    <string name="volume_bluetooth_call">Bluetooth in-call volume</string>
    <!-- Title of the dialog where the user is adjusting the audio volume for alarms -->
    <string name="volume_alarm">Alarm volume</string>
    <!-- Title of the dialog where the user is adjusting the audio volume for notifications -->
    <string name="volume_notification">Notification volume</string>
    <!-- Title of the dialog where the user is adjusting the general audio volume -->
    <string name="volume_unknown">Volume</string>

    <!-- Content description for bluetooth volume icon [CHAR LIMIT=100] -->
    <string name="volume_icon_description_bluetooth">Bluetooth volume</string>
    <!-- Content description for ringer volume icon [CHAR LIMIT=100] -->
    <string name="volume_icon_description_ringer">Ringtone volume</string>
    <!-- Content description for in-call volume icon [CHAR LIMIT=100] -->
    <string name="volume_icon_description_incall">Call volume</string>
    <!-- Content description for media volume icon [CHAR LIMIT=100] -->
    <string name="volume_icon_description_media">Media volume</string>
    <!-- Content description for notification volume icon [CHAR LIMIT=100] -->
    <string name="volume_icon_description_notification">Notification volume</string>

    <!-- Ringtone picker strings --> <skip />
    <!-- Choice in the ringtone picker.  If chosen, the default ringtone will be used. -->
    <string name="ringtone_default">Default ringtone</string>
    <!-- Choice in the ringtone picker.  If chosen, the default ringtone will be used. This fills in the actual ringtone's title into the message. -->
    <string name="ringtone_default_with_actual">Default (<xliff:g id="actual_ringtone">%1$s</xliff:g>)</string>
    <!-- Choice in the ringtone picker.  If chosen, there will be silence instead of a ringtone played. -->
    <string name="ringtone_silent">None</string>
    <!-- The title of the ringtone picker dialog. -->
    <string name="ringtone_picker_title">Ringtones</string>
    <!-- The title of the alarm sound picker dialog [CHAR LIMIT=100] -->
    <string name="ringtone_picker_title_alarm">Alarm sounds</string>
    <!-- The title of the notification sound picker dialog [CHAR LIMIT=100] -->
    <string name="ringtone_picker_title_notification">Notification sounds</string>
    <!-- If there is ever a ringtone set for some setting, but that ringtone can no longer be resolved, t his is shown instead.  For example, if the ringtone was on a SD card and it had been removed, this woudl be shown for ringtones on that SD card. -->
    <string name="ringtone_unknown">Unknown</string>

    <!-- A notification is shown when a wifi captive portal network is detected.  This is the notification's title. -->
    <string name="wifi_available_sign_in">Sign in to Wi-Fi network</string>

    <!-- A notification is shown when a captive portal network is detected.  This is the notification's title. -->
    <string name="network_available_sign_in">Sign in to network</string>

    <!-- A notification is shown when a captive portal network is detected.  This is the notification's message. -->
    <string name="network_available_sign_in_detailed"><xliff:g id="network_ssid">%1$s</xliff:g></string>

    <!-- A notification is shown when the user connects to a Wi-Fi network and the system detects that that network has no Internet access. This is the notification's title. -->
    <string name="wifi_no_internet"><xliff:g id="network_ssid" example="GoogleGuest">%1$s</xliff:g> has no internet access</string>

    <!-- A notification is shown when the user connects to a Wi-Fi network and the system detects that that network has no Internet access. This is the notification's message. -->
    <string name="wifi_no_internet_detailed">Tap for options</string>

    <!-- A notification is shown when the user connects to a mobile network without internet access. This is the notification's title. -->
    <string name="mobile_no_internet">Mobile network has no internet access</string>

    <!-- A notification is shown when the user connects to a non-mobile and non-wifi network without internet access. This is the notification's title. -->
    <string name="other_networks_no_internet">Network has no internet access</string>

    <!-- A notification is shown when connected network without internet due to private dns validation failed. This is the notification's message. [CHAR LIMIT=NONE] -->
    <string name="private_dns_broken_detailed">Private DNS server cannot be accessed</string>

    <!-- A notification is shown after the user logs in to a captive portal network, to indicate that the network should now have internet connectivity. This is the message of notification. [CHAR LIMIT=50] -->
    <string name="captive_portal_logged_in_detailed">Connected</string>
    <!-- A notification is shown when the user connects to a network that doesn't have access to some services (e.g. Push notifications may not work). This is the notification's title. [CHAR LIMIT=50] -->
    <string name="network_partial_connectivity"><xliff:g id="network_ssid" example="GoogleGuest">%1$s</xliff:g> has limited connectivity</string>

    <!-- A notification is shown when the user connects to a network that doesn't have access to some services (e.g. Push notifications may not work). This is the notification's message. [CHAR LIMIT=50] -->
    <string name="network_partial_connectivity_detailed">Tap to connect anyway</string>

    <!-- A notification might be shown if the device switches to another network type (e.g., mobile data) because it detects that the network it was using (e.g., Wi-Fi) has lost Internet connectivity. This is the notification's title. %1$s is the network type that the device switched to, e.g., cellular data. It is one of the strings in the network_switch_type_name array. -->
    <string name="network_switch_metered">Switched to <xliff:g id="network_type">%1$s</xliff:g></string>

    <!-- A notification might be shown if the device switches to another network type (e.g., mobile data) because it detects that the network it was using (e.g., Wi-Fi) has lost Internet connectivity. This is the notification's message. %1$s is the network that the device switched to, e.g., cellular data. %2$s is the network type the device switched from, e.g., Wi-Fi. Both are strings in the network_switch_type_name array. -->
    <string name="network_switch_metered_detail">Device uses <xliff:g id="new_network">%1$s</xliff:g> when <xliff:g id="previous_network">%2$s</xliff:g> has no internet access. Charges may apply.</string>

    <!-- A toast might be shown if the device switches to another network type (e.g., mobile data) because it detects that the network it was using (e.g., Wi-Fi) has lost Internet connectivity. This is the text of the toast. %1$s is the network that the device switched from, e.g., Wi-Fi. %2$s is the network type the device switched from, e.g., cellular data. Both are strings in the network_switch_type_name array. -->
    <string name="network_switch_metered_toast">Switched from <xliff:g id="previous_network">%1$s</xliff:g> to <xliff:g id="new_network">%2$s</xliff:g></string>

    <!-- Network type names used in the network_switch_metered and network_switch_metered_detail strings. These must be kept in the sync with the values NetworkCapabilities.TRANSPORT_xxx values, and in the same order. -->
    <string-array name="network_switch_type_name">
        <item>mobile data</item>
        <item>Wi-Fi</item>
        <item>Bluetooth</item>
        <item>Ethernet</item>
        <item>VPN</item>
    </string-array>

    <!-- Network type name displayed if one of the types is not found in network_switch_type_name. -->
    <string name="network_switch_type_name_unknown">an unknown network type</string>

    <string name="accept">Accept</string>
    <string name="decline">Decline</string>

    <!-- Name of the dialog that lets the user choose an accented character to insert -->
    <string name="select_character">Insert character</string>

    <!-- SMS per-application rate control Dialog --> <skip />
    <!-- SMS_DIALOG: An SMS dialog is shown if an application tries to send too many SMSes.  This is the title of that dialog. -->
    <string name="sms_control_title">Sending SMS messages</string>
    <!-- See SMS_DIALOG.  This is the message shown in that dialog. [CHAR LIMIT=NONE] -->
    <string name="sms_control_message">&lt;b><xliff:g id="app_name">%1$s</xliff:g>&lt;/b> is sending a large number of SMS messages. Do you want to allow this app to continue sending messages?</string>
    <!-- See SMS_DIALOG.  This is a button choice to allow sending the SMSes. [CHAR LIMIT=30] -->
    <string name="sms_control_yes">Allow</string>
    <!-- See SMS_DIALOG.  This is a button choice to disallow sending the SMSes. [CHAR LIMIT=30] -->
    <string name="sms_control_no">Deny</string>

    <!-- SMS short code verification dialog. --> <skip />
    <!-- The message text for the SMS short code confirmation dialog. [CHAR LIMIT=NONE] -->
    <string name="sms_short_code_confirm_message">&lt;b><xliff:g id="app_name">%1$s</xliff:g>&lt;/b> would like to send a message to &lt;b><xliff:g id="dest_address">%2$s</xliff:g>&lt;/b>.</string>
    <!-- Message details for the SMS short code confirmation dialog (possible premium short code). [CHAR LIMIT=NONE] -->
    <string name="sms_short_code_details">This <b>may cause charges</b> on your mobile account.</string>
    <!-- Message details for the SMS short code confirmation dialog (premium short code). [CHAR LIMIT=NONE] -->
    <string name="sms_premium_short_code_details"><b>This will cause charges on your mobile account.</b></string>
    <!-- Text of the approval button for the SMS short code confirmation dialog. [CHAR LIMIT=30] -->
    <string name="sms_short_code_confirm_allow">Send</string>
    <!-- Text of the cancel button for the SMS short code confirmation dialog. [CHAR LIMIT=30] -->
    <string name="sms_short_code_confirm_deny">Cancel</string>
    <!-- Text of the checkbox for the SMS short code confirmation dialog to remember the user's choice. [CHAR LIMIT=40] -->
    <string name="sms_short_code_remember_choice">Remember my choice</string>
    <!-- Text shown when remember checkbox is checked to inform the user how they may undo the setting. [CHAR LIMIT=40] -->
    <string name="sms_short_code_remember_undo_instruction">You can change this later in Settings\u00A0>\u00A0Apps"</string>

    <!-- Text of the approval button for the SMS short code confirmation dialog when checkbox is checked. [CHAR LIMIT=30] -->
    <string name="sms_short_code_confirm_always_allow">Always Allow</string>
    <!-- Text of the cancel button for the SMS short code confirmation dialog when checkbox is checked. [CHAR LIMIT=30] -->
    <string name="sms_short_code_confirm_never_allow">Never Allow</string>

    <!-- SIM swap and device reboot Dialog --> <skip />
    <!-- See SIM_REMOVED_DIALOG.  This is the title of that dialog. -->
    <string name="sim_removed_title">SIM card removed</string>
    <!-- See SIM_REMOVED_DIALOG.  This is the message of that dialog. -->
    <string name="sim_removed_message">The mobile network will be unavailable until you restart with a valid SIM card inserted.</string>
    <!-- See SIM_REMOVED_DIALOG.  This is the button of that dialog. -->
    <string name="sim_done_button">Done</string>
    <!-- See SIM_ADDED_DIALOG.  This is the title of that dialog. -->
    <string name="sim_added_title">SIM card added</string>
    <!-- See SIM_ADDED_DIALOG.  This is the message of that dialog. -->
    <string name="sim_added_message">Restart your device to access the mobile network.</string>
    <!-- See SIM_ADDED_DIALOG.  This is the button of that dialog. -->
    <string name="sim_restart_button">Restart</string>
    <!-- See Carrier_App_Dialog. This is the message of that dialog. -->
    <string name="install_carrier_app_notification_title">Activate mobile service</string>
    <!-- Notification message that shows when the user inserts a SIM card that requires a carrier app download, but the app name is unknown -->
    <string name="install_carrier_app_notification_text">Download the carrier app to activate your new SIM</string>
    <!-- Notification message that shows when the user inserts a SIM card that requires a carrier app download.  App name is known -->
    <string name="install_carrier_app_notification_text_app_name">Download the <xliff:g id="app_name">%1$s</xliff:g> app to activate your new SIM</string>
    <!-- See Carrier_App_Notification. This is the button of that dialog. -->
    <string name="install_carrier_app_notification_button">Download app</string>
    <!-- See carrier_app_notification. This is the headline. -->
    <string name="carrier_app_notification_title">New SIM inserted</string>
    <string name="carrier_app_notification_text">Tap to set it up</string>

    <!-- Date/Time picker dialogs strings -->

    <!-- The title of the time picker dialog. [CHAR LIMIT=NONE] -->
    <string name="time_picker_dialog_title">Set time</string>
    <!-- The title of the date picker dialog. [CHAR LIMIT=NONE] -->
    <string name="date_picker_dialog_title">Set date</string>
    <!-- Name of the button in the date/time picker to accept the date/time change -->
    <string name="date_time_set">Set</string>
    <!-- Name of the button in the date/time picker to accept the date/time change -->
    <string name="date_time_done">Done</string>

    <!-- Security Permissions strings-->
    <!-- Text that is placed at the front of a permission name that is being added to an app [CHAR LIMIT=NONE] -->
    <string name="perms_new_perm_prefix"><font size="12" fgcolor="#ff33b5e5">NEW: </font></string>
    <!-- Text that is placed at the front of a permission name that is being added to an app [CHAR LIMIT=NONE] -->
    <string name="perms_description_app">Provided by <xliff:g id="app_name">%1$s</xliff:g>.</string>
    <!-- Shown for an application when it doesn't require any permission grants. -->
    <string name="no_permissions">No permissions required</string>
    <!-- [CHAR LIMIT=NONE] Additional text in permission description for perms that can cost money. -->
    <string name="perm_costs_money">this may cost you money</string>
    <!-- Dialog ok button-->
    <string name="dlg_ok">OK</string>

    <!-- USB_PREFERENCES: Notification for when the user connected to the charger only.  This is the title -->
    <string name="usb_charging_notification_title">Charging this device via USB</string>
    <!-- USB_PREFERENCES: Notification for when the user connects the phone to supply power to attached device.  This is the title -->
    <string name="usb_supplying_notification_title">Charging connected device via USB</string>
    <!-- USB_PREFERENCES: Notification for when the user connects the phone to a computer via USB in MTP mode.  This is the title -->
    <string name="usb_mtp_notification_title">USB file transfer turned on</string>
    <!-- USB_PREFERENCES: Notification for when the user connects the phone to a computer via USB in PTP mode.  This is the title -->
    <string name="usb_ptp_notification_title">PTP via USB turned on</string>
    <!-- USB_PREFERENCES: Notification for when the user connects the phone to a computer via USB in Tethering mode.  This is the title -->
    <string name="usb_tether_notification_title">USB tethering turned on</string>
    <!-- USB_PREFERENCES: Notification for when the user connects the phone to a computer via USB in MIDI mode.  This is the title -->
    <string name="usb_midi_notification_title">MIDI via USB turned on</string>
    <!-- USB_PREFERENCES: Notification for when a USB accessory is attached.  This is the title -->
    <string name="usb_accessory_notification_title">USB accessory connected</string>
    <!-- See USB_PREFERENCES. This is the message. -->
    <string name="usb_notification_message">Tap for more options.</string>
    <!-- See USB_PREFERENCES. This is the message when a data mode is turned on (mtp, ptp, midi) and the device is supplying power.. -->
    <string name="usb_power_notification_message">Charging connected device. Tap for more options.</string>
    <!-- USB_PREFERENCES: Notification for when a type-c USB audio accessory is attached but not supported.  This is the title -->
    <string name="usb_unsupported_audio_accessory_title">Analog audio accessory detected</string>
    <!-- Message of notification shown when a type-c USB audio accessory is attached but not supported. -->
    <string name="usb_unsupported_audio_accessory_message">The attached device is not compatible with this phone. Tap to learn more.</string>


    <!-- Title of notification shown when ADB is actively connected to the phone. -->
    <string name="adb_active_notification_title">USB debugging connected</string>
    <!-- Message of notification shown when ADB is actively connected to the phone. -->
    <string name="adb_active_notification_message">Tap to turn off USB debugging</string>
    <string name="adb_active_notification_message" product="tv">Select to disable USB debugging.</string>

    <!-- Title of notification shown when Test Harness Mode is enabled. [CHAR LIMIT=NONE] -->
    <string name="test_harness_mode_notification_title">Test Harness Mode enabled</string>
    <!-- Message of notification shown when Test Harness Mode is enabled. [CHAR LIMIT=NONE] -->
    <string name="test_harness_mode_notification_message">Perform a factory reset to disable Test Harness Mode.</string>

    <!-- Title of notification shown when serial console is enabled. [CHAR LIMIT=NONE] -->
    <string name="console_running_notification_title">Serial console enabled</string>
    <!-- Message of notification shown when serial console is enabled. [CHAR LIMIT=NONE] -->
    <string name="console_running_notification_message">Performance is impacted. To disable, check bootloader.</string>

    <!-- Title of notification shown when contaminant is detected on the USB port. [CHAR LIMIT=NONE] -->
    <string name="usb_contaminant_detected_title">Liquid or debris in USB port</string>
    <!-- Message of notification shown when contaminant is detected on the USB port. [CHAR LIMIT=NONE] -->
    <string name="usb_contaminant_detected_message">USB port is automatically disabled. Tap to learn more.</string>
    <!-- Title of notification shown when contaminant is no longer detected on the USB port. [CHAR LIMIT=NONE] -->
    <string name="usb_contaminant_not_detected_title">OK to use USB port</string>
    <!-- Message of notification shown when contaminant is no longer detected on the USB port. [CHAR LIMIT=NONE] -->
    <string name="usb_contaminant_not_detected_message">Phone no longer detects liquid or debris.</string>

    <!-- Title of notification shown to indicate that bug report is being collected. -->
    <string name="taking_remote_bugreport_notification_title">Taking bug report\u2026</string>
    <!-- Title of notification shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator. -->
    <string name="share_remote_bugreport_notification_title">Share bug report?</string>
    <!-- Title of notification shown to indicate that bug report is still being collected after sharing was accepted. -->
    <string name="sharing_remote_bugreport_notification_title">Sharing bug report\u2026</string>
    <!-- Message of a notification shown to ask for user consent for sharing a bugreport that was requested remotely by the IT administrator. -->
    <string name="share_remote_bugreport_notification_message_finished">Your admin requested a bug
        report to help troubleshoot this device. Apps and data may be shared.</string>
    <!-- Acceptance label of notification shown to ask for user consent for sharing the remote bugreport. -->
    <string name="share_remote_bugreport_action">SHARE</string>
    <!-- Decline label of notification shown to ask for user consent for sharing the remote bugreport. -->
    <string name="decline_remote_bugreport_action">DECLINE</string>

    <!-- Used to replace %s in urls retreived from the signin server with locales.  For Some        -->
    <!-- devices we don't support all the locales we ship to and need to replace the '%s' with a    -->
    <!-- locale string based on mcc values.  By default (0-length string) we don't replace the %s   -->
    <!-- at all and later replace it with a locale string based on the users chosen locale          -->
    <!-- DO NOT TRANSLATE -->
    <string name="locale_replacement">""</string>

    <!-- Title of the pop-up dialog in which the user switches keyboard, also known as input method. -->
    <string name="select_input_method">Choose input method</string>
    <!-- Summary text of a toggle switch to enable/disable use of the IME while a physical
         keyboard is connected -->
    <string name="show_ime">Keep it on screen while physical keyboard is active</string>
    <!-- Title of the physical keyboard category in the input method selector [CHAR LIMIT=30] -->
    <string name="hardware">Show virtual keyboard</string>

    <!-- Title of the notification to prompt the user to configure physical keyboard settings. -->
    <string name="select_keyboard_layout_notification_title">Configure physical keyboard</string>
    <!-- Message of the notification to prompt the user to configure physical keyboard settings
         where the user can associate language with physical keyboard layout. -->
    <string name="select_keyboard_layout_notification_message">Tap to select language and layout</string>

    <string name="fast_scroll_alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
    <string name="fast_scroll_numeric_alphabet">\u00200123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>

    <!-- Alert windows notification strings -->
    <skip />
    <!-- Name of notification channel group the system post notification to inform the use about apps
         that are drawing ui on-top of other apps (alert-windows) [CHAR LIMIT=NONE] -->
    <string name="alert_windows_notification_channel_group_name">Display over other apps</string>
    <!-- Name of notification channel the system post notification to inform the use about apps
         that are drawing ui on-top of other apps (alert-windows) [CHAR LIMIT=NONE] -->
    <string name="alert_windows_notification_channel_name"><xliff:g id="name" example="Google Maps">%s</xliff:g> displaying over other apps</string>
    <!-- Notification title when an application is displaying ui on-top of other apps
         [CHAR LIMIT=30] -->
    <string name="alert_windows_notification_title"><xliff:g id="name" example="Google Maps">%s</xliff:g> is displaying over other apps</string>
    <!-- Notification body when an application is displaying ui on-top of other apps
         [CHAR LIMIT=NONE] -->
    <string name="alert_windows_notification_message">If you don’t want <xliff:g id="name" example="Google Maps">%s</xliff:g> to use this feature, tap to open settings and turn it off.</string>
    <!-- Notification action to turn-off app displaying on-top of other apps. [CHAR LIMIT=20] -->
    <string name="alert_windows_notification_turn_off_action">Turn off</string>

    <!-- External media notification strings -->
    <skip />

    <!-- Notification title when external media is being checked [CHAR LIMIT=30] -->
    <string name="ext_media_checking_notification_title">Checking <xliff:g id="name" example="SD card">%s</xliff:g>\u2026</string>
    <!-- Notification body when external media is being checked [CHAR LIMIT=NONE] -->
    <string name="ext_media_checking_notification_message">Reviewing current content</string>

    <!-- Notification body when new external media is detected [CHAR LIMIT=30] -->
    <string name="ext_media_new_notification_title">New <xliff:g id="name" example="SD card">%s</xliff:g></string>
    <!-- Notification body when new external media is detected [CHAR LIMIT=NONE] -->
    <string name="ext_media_new_notification_message">Tap to set up</string>

    <!-- Notification body when external media is ready for use [CHAR LIMIT=NONE] -->
    <string name="ext_media_ready_notification_message">For transferring photos and media</string>

    <!-- Notification title when external media is unmountable (corrupt) [CHAR LIMIT=30] -->
    <string name="ext_media_unmountable_notification_title">Issue with <xliff:g id="name" example="SD card">%s</xliff:g></string>
    <!-- Notification body when external media is unmountable (corrupt) [CHAR LIMIT=NONE] -->
    <string name="ext_media_unmountable_notification_message">Tap to fix</string>
    <!-- TV-specifiv notification body when external media is unmountable (corrupt) [CHAR LIMIT=NONE] -->
    <string name="ext_media_unmountable_notification_message" product="tv"><xliff:g id="name" example="SD card">%s</xliff:g> is corrupt. Select to fix.</string>

    <!-- Notification title when external media is unsupported [CHAR LIMIT=30] -->
    <string name="ext_media_unsupported_notification_title">Unsupported <xliff:g id="name" example="SD card">%s</xliff:g></string>
    <!-- Notification body when external media is unsupported [CHAR LIMIT=NONE] -->
    <string name="ext_media_unsupported_notification_message">This device doesn\u2019t support this <xliff:g id="name" example="SD card">%s</xliff:g>. Tap to set up in a supported format.</string>
    <!-- TV-specific notification body when external media is unsupported [CHAR LIMIT=NONE] -->
    <string name="ext_media_unsupported_notification_message" product="tv">This device doesn\u2019t support this <xliff:g id="name" example="SD card">%s</xliff:g>. Select to set up in a supported format.</string>

    <!-- Notification title when external media is unsafely removed [CHAR LIMIT=30] -->
    <string name="ext_media_badremoval_notification_title"><xliff:g id="name" example="SD card">%s</xliff:g> unexpectedly removed</string>
    <!-- Notification body when external media is unsafely removed [CHAR LIMIT=NONE] -->
    <string name="ext_media_badremoval_notification_message">Eject media before removing to avoid losing content</string>

    <!-- Notification title when external media is missing [CHAR LIMIT=30] -->
    <string name="ext_media_nomedia_notification_title"><xliff:g id="name" example="SD card">%s</xliff:g> removed</string>
    <!-- Notification body when external media is missing [CHAR LIMIT=NONE] -->
    <string name="ext_media_nomedia_notification_message">Some functionality may not work properly. Insert new storage.</string>

    <!-- Notification title when external media is unmounting [CHAR LIMIT=30] -->
    <string name="ext_media_unmounting_notification_title">Ejecting <xliff:g id="name" example="SD card">%s</xliff:g></string>
    <!-- Notification body when external media is unmounting [CHAR LIMIT=NONE] -->
    <string name="ext_media_unmounting_notification_message">Don\u2019t remove</string>

    <!-- Notification action to setup external media [CHAR LIMIT=20] -->
    <string name="ext_media_init_action">Set up</string>
    <!-- Notification action to unmount external media [CHAR LIMIT=20] -->
    <string name="ext_media_unmount_action">Eject</string>
    <!-- Notification action to browse external media [CHAR LIMIT=20] -->
    <string name="ext_media_browse_action">Explore</string>

    <!-- Notification action to transfer media [CHAR LIMIT=40] -->
    <string name="ext_media_seamless_action">Switch output</string>

    <!-- Notification title when external media is missing [CHAR LIMIT=30] -->
    <string name="ext_media_missing_title"><xliff:g id="name" example="SD card">%s</xliff:g> missing</string>
    <!-- Notification body when external media is missing [CHAR LIMIT=30] -->
    <string name="ext_media_missing_message">Insert device again</string>

    <!-- Notification title when moving an application to external storage [CHAR LIMIT=30] -->
    <string name="ext_media_move_specific_title">Moving <xliff:g id="name" example="Calculator">%s</xliff:g></string>
    <!-- Notification title when moving data to external storage [CHAR LIMIT=32] -->
    <string name="ext_media_move_title">Moving data</string>

    <!-- Notification title when moving data to external storage [CHAR LIMIT=32] -->
    <string name="ext_media_move_success_title">Content transfer is done</string>
    <!-- Notification title when moving data to external storage [CHAR LIMIT=64] -->
    <string name="ext_media_move_success_message">Content moved to <xliff:g id="name" example="SD card">%s</xliff:g></string>

    <!-- Notification title when moving data to external storage failed [CHAR LIMIT=32] -->
    <string name="ext_media_move_failure_title">Couldn\u2019t move content</string>
    <!-- Notification title when moving data to external storage failed [CHAR LIMIT=64] -->
    <string name="ext_media_move_failure_message">Try moving content again</string>

    <!-- Short summary of storage media status when removed [CHAR LIMIT=32] -->
    <string name="ext_media_status_removed">Removed</string>
    <!-- Short summary of storage media status when unmounted [CHAR LIMIT=32] -->
    <string name="ext_media_status_unmounted">Ejected</string>
    <!-- Short summary of storage media status when checking [CHAR LIMIT=32] -->
    <string name="ext_media_status_checking">Checking\u2026</string>
    <!-- Short summary of storage media status when mounted [CHAR LIMIT=32] -->
    <string name="ext_media_status_mounted">Ready</string>
    <!-- Short summary of storage media status when mounted read-only [CHAR LIMIT=32] -->
    <string name="ext_media_status_mounted_ro">Read-only</string>
    <!-- Short summary of storage media status when removed unsafely [CHAR LIMIT=32] -->
    <string name="ext_media_status_bad_removal">Removed unsafely</string>
    <!-- Short summary of storage media status when unmountable [CHAR LIMIT=32] -->
    <string name="ext_media_status_unmountable">Corrupted</string>
    <!-- Short summary of storage media status when unsupported [CHAR LIMIT=32] -->
    <string name="ext_media_status_unsupported">Unsupported</string>
    <!-- Short summary of storage media status when ejecting [CHAR LIMIT=32] -->
    <string name="ext_media_status_ejecting">Ejecting\u2026</string>
    <!-- Short summary of storage media status when formatting [CHAR LIMIT=32] -->
    <string name="ext_media_status_formatting">Formatting\u2026</string>
    <!-- Short summary of storage media status when missing [CHAR LIMIT=32] -->
    <string name="ext_media_status_missing">Not inserted</string>

    <!-- Shown in LauncherActivity when the requested target Intent didn't return any matching Activities, leaving the list empty. -->
    <string name="activity_list_empty">No matching activities found.</string>

    <!-- Title of an application permission that lets an application route media output. -->
    <string name="permlab_route_media_output">route media output</string>
    <!-- Description of an application permission that lets an application route media output. -->
    <string name="permdesc_route_media_output">Allows an application to route media output to other external devices.</string>

    <!-- Title of an application permission that lets it read install sessions. -->
    <string name="permlab_readInstallSessions">read install sessions</string>
    <!-- Description of an application permission that lets it read install sessions. -->
    <string name="permdesc_readInstallSessions">Allows an application to read install sessions. This allows it to see details about active package installations.</string>

    <!-- Title of an application permission that lets it read install sessions. -->
    <string name="permlab_requestInstallPackages">request install packages</string>
    <!-- Description of an application permission that lets it read install sessions. -->
    <string name="permdesc_requestInstallPackages">Allows an application to request installation of packages.</string>

    <!-- Title of an application permission that lets it read install sessions. -->
    <string name="permlab_requestDeletePackages">request delete packages</string>
    <!-- Description of an application permission that lets it read install sessions. -->
    <string name="permdesc_requestDeletePackages">Allows an application to request deletion of packages.</string>

    <!-- Title of an application permission that lets it ask user to ignore battery optimizations for that app. -->
    <string name="permlab_requestIgnoreBatteryOptimizations">ask to ignore battery optimizations</string>
    <!-- Description of an application permission that lets it ask user to ignore battery optimizations for that app-->
    <string name="permdesc_requestIgnoreBatteryOptimizations">Allows an app to ask for permission to ignore battery optimizations for that app.</string>

    <!-- Shown in the tutorial for tap twice for zoom control. -->
    <string name="tutorial_double_tap_to_zoom_message_short">Tap twice for zoom control</string>


    <!-- Shown in gadget hosts (e.g. the home screen) when there was an error inflating
    the gadget. -->
    <string name="gadget_host_error_inflating">Couldn\'t add widget.</string>

    <!-- Long label for a button on a full-screen input method for the "Go" action. -->
    <string name="ime_action_go">Go</string>

    <!-- Long label for a button on a full-screen input method for the "Search" action. -->
    <string name="ime_action_search">Search</string>

    <!-- Long label for a button on a full-screen input method for the "Send" action. -->
    <string name="ime_action_send">Send</string>

    <!-- Long label for a button on a full-screen input method for the "Next" action. -->
    <string name="ime_action_next">Next</string>

    <!-- Long label for a button on a full-screen input method for the "Done" action. -->
    <string name="ime_action_done">Done</string>

    <!-- [CHAR LIMIT=6] Long label for a button on a full-screen input method for the "Previous" action. -->
    <string name="ime_action_previous">Prev</string>

    <!-- Long label for a button on a full-screen input method for an unknown action. -->
    <string name="ime_action_default">Execute</string>

    <!-- Strings for search suggestions. These are going here because they are referenced by both
         ContactsProvider and GoogleContactsProvider -->
    <skip />


    <!-- This string appears (on two lines) when you type a number into contacts search, to let you dial the phone number you typed.  The first line will be in bigger type than the second. -->
    <string name="dial_number_using">Dial number\nusing <xliff:g id="number" example="555">%s</xliff:g></string>

    <!-- This string appears (on two lines) when you type a number into contacts search, to let you create a contact whose phone number is the number you typed.  The first line will be in bigger type than the second. -->
    <string name="create_contact_using">Create contact\nusing <xliff:g id="number" example="555">%s</xliff:g></string>

    <!-- This string array should be overridden by the manufacture to present a list of carrier-id,locale. The wifi regulatory domain is extracted from the locale information. This is used at startup to set system defaults by checking the system property ro.carrier for the carrier-id and searching through this array -->
    <!-- An Array of [[Carrier-ID]                     -->
    <!--              [default-locale]]                -->
    <string-array translatable="false" name="carrier_properties">
    </string-array>

    <string name="grant_credentials_permission_message_header">The following one or more apps request permission to access your account, now and in the future.</string>
    <string name="grant_credentials_permission_message_footer">Do you want to allow this request?</string>
    <string name="grant_permissions_header_text">Access request</string>
    <string name="allow">Allow</string>
    <string name="deny">Deny</string>
    <string name="permission_request_notification_title">Permission requested</string>
    <string name="permission_request_notification_with_subtitle">Permission requested\nfor account <xliff:g id="account" example="foo@gmail.com">%s</xliff:g>.</string>

    <!-- Message to show when an intent automatically switches users into the personal profile. -->
    <string name="forward_intent_to_owner">You\'re using this app outside of your work profile</string>
    <!-- Message to show when an intent automatically switches users into a work profile. -->
    <string name="forward_intent_to_work">You\'re using this app in your work profile</string>

    <!-- Label to show for a service that is running because it is an input method. -->
    <string name="input_method_binding_label">Input method</string>
    <!-- Label to show for a service that is running because it is a sync adapter. -->
    <string name="sync_binding_label">Sync</string>
    <!-- Label to show for a service that is running because it is an accessibility module. -->
    <string name="accessibility_binding_label">Accessibility</string>
    <!-- Label to show for a service that is running because it is a wallpaper. -->
    <string name="wallpaper_binding_label">Wallpaper</string>
    <!-- Dialog title for user to select a different wallpaper from service list -->
    <string name="chooser_wallpaper">Change wallpaper</string>
    <!-- Label to show for a service that is running because it is observing
         the user's notifications. -->
    <string name="notification_listener_binding_label">Notification listener</string>
    <!-- Label to show for a service that is running because the system is in VR mode. -->
    <string name="vr_listener_binding_label">VR listener</string>
    <!-- Label to show for a service that is running because it is providing conditions. -->
    <string name="condition_provider_service_binding_label">Condition provider</string>
    <!-- Label to show for a service that is running because it is observing and modifying the
         importance of the user's notifications. -->
    <string name="notification_ranker_binding_label">Notification ranker service</string>

    <!-- Do Not Translate: Alternate eri.xml -->
    <string name="alternate_eri_file">/data/eri.xml</string>

    <!-- The title of the notification when VPN is active. -->
    <string name="vpn_title">VPN activated</string>
    <!-- The title of the notification when VPN is active with an application name. -->
    <string name="vpn_title_long">VPN is activated by <xliff:g id="app" example="FooVPN client">%s</xliff:g></string>
    <!-- The text of the notification when VPN is active. -->
    <string name="vpn_text">Tap to manage the network.</string>
    <!-- The text of the notification when VPN is active with a session name. -->
    <string name="vpn_text_long">Connected to <xliff:g id="session" example="office">%s</xliff:g>. Tap to manage the network.</string>

    <!-- Notification title when connecting to always-on VPN, a VPN that's set to always stay
         connected. -->
    <string name="vpn_lockdown_connecting">Always-on VPN connecting\u2026</string>
    <!-- Notification title when connected to always-on VPN, a VPN that's set to always stay
         connected. -->
    <string name="vpn_lockdown_connected">Always-on VPN connected</string>
    <!-- Notification title when not connected to always-on VPN, a VPN that's set to always stay
         connected. -->
    <string name="vpn_lockdown_disconnected">Disconnected from always-on VPN</string>
    <!-- Notification title when error connecting to always-on VPN, a VPN that's set to always stay
         connected. -->
    <string name="vpn_lockdown_error">Couldn\'t connect to always-on VPN</string>
    <!-- Notification body that indicates user can touch to configure always-on VPN, a VPN that's
         set to always stay connected. -->
    <string name="vpn_lockdown_config">Change network or VPN settings</string>

    <!-- Localized strings for WebView -->
    <!-- Label for button in a WebView that will open a chooser to choose a file to upload -->
    <string name="upload_file">Choose file</string>
    <!-- Label for the file upload control when no file has been chosen yet -->
    <string name="no_file_chosen">No file chosen</string>
    <!-- Label for <input type="reset"> button in html -->
    <string name="reset">Reset</string>
    <!-- Label for <input type="submit"> button in html -->
    <string name="submit">Submit</string>

    <!-- Strings for car mode notification -->
    <!-- Shown when car mode is enabled -->
    <string name="car_mode_disable_notification_title">Driving app is running</string>
    <string name="car_mode_disable_notification_message">Tap to exit driving app.</string>

    <!--  Strings for possible PreferenceActivity Back/Next buttons -->
    <string name="back_button_label">Back</string>
    <string name="next_button_label">Next</string>

    <!-- Optional button to Skip a PreferenceActivity [CHAR LIMIT=20] -->
    <string name="skip_button_label">Skip</string>

    <!-- Displayed on the Find dialog when there are no matches [CHAR LIMIT=NONE]-->
    <string name="no_matches">No matches</string>

    <!-- Find dialog hint text.  Also used in the menu item to open find on page [CHAR LIMIT=NONE] -->
    <string name="find_on_page">Find on page</string>

    <!-- Displayed on the Find dialog to display the index of the highlighted
         match and total number of matches found in the current page. [CHAR LIMIT=NONE] -->
    <plurals name="matches_found">
        <!-- Case of one match -->
        <item quantity="one">1 match</item>
        <!-- Case of multiple total matches -->
        <item quantity="other"><xliff:g id="index" example="2">%d</xliff:g> of <xliff:g id="total" example="137">%d</xliff:g></item>
    </plurals>

    <!-- Label for the "Done" button on the far left of action mode toolbars. -->
    <string name="action_mode_done">Done</string>

    <!-- Strings for MasterClearReceiver. -->
    <!-- Text for progress dialog while erasing the shared storage volume [CHAR LIMIT=NONE] -->
    <string name="progress_erasing">Erasing shared storage\u2026</string>

    <!-- Text for WebView's text selection Action Mode -->
    <!-- ActionBar action to share the current selection [CHAR LIMIT=10] -->
    <string name="share">Share</string>
    <!-- ActionBar action to use the current selection to open the Find on page functionality [CHAR LIMIT=10]-->
    <string name="find">Find</string>
    <!-- ActionBar action to use the current selection to perform a web search [CHAR-LIMIT=16] -->
    <string name="websearch">Web Search</string>
    <!-- ActionBar action to find the next match in the page [CHAR LIMIT=24] -->
    <string name="find_next">Find next</string>
    <!-- ActionBar action to find the previous match in the page [CHAR LIMIT=24] -->
    <string name="find_previous">Find previous</string>

    <!-- Network positioning notification ticker. The name of the user (e.g. John Doe) who sent
         the request is shown as a dynamic string. -->
    <string name="gpsNotifTicker">Location request from <xliff:g id="name">%s</xliff:g></string>
    <!-- Network positioning notification and verification title to inform the user about
         an incoming location request. -->
    <string name="gpsNotifTitle">Location request</string>
    <!-- Network positioning notification message. The name of the user (e.g. John Doe) and
         service (SUPL-service) who sent the request is shown as dynamic strings.
         Translation should not be longer than master text. -->
    <string name="gpsNotifMessage">Requested by <xliff:g id="name">%1$s</xliff:g> (<xliff:g id="service" example="SUPL-service">%2$s</xliff:g>)</string>
    <!-- Network positioning verification Yes. Button to push to share location information. -->
    <string name="gpsVerifYes">Yes</string>
    <!-- Network positioning verification No. Button to push to deny sharing of location
         information. -->
    <string name="gpsVerifNo">No</string>

    <!-- Error message when the sync tried to delete too many things -->
    <string name="sync_too_many_deletes">Delete limit exceeded</string>
    <!-- Dialog message for when there are too many deletes that would take place and we want user confirmation -->
    <string name="sync_too_many_deletes_desc">There are <xliff:g id="number_of_deleted_items">%1$d</xliff:g> deleted items for <xliff:g id="type_of_sync">%2$s</xliff:g>, account <xliff:g id="account_name">%3$s</xliff:g>. What do you want to do?</string>
    <!-- Dialog action for when there are too many deletes that would take place and we want user confirmation, and the user wants to delete the items -->
    <string name="sync_really_delete">Delete the items</string>
    <!-- Dialog action for when there are too many deletes that would take place and we want user confirmation, and the user wants to undo the deletions -->
    <string name="sync_undo_deletes">Undo the deletes</string>
    <!-- Dialog action for when there are too many deletes that would take place and we want user confirmation, and the user wants to do nothing for now -->
    <string name="sync_do_nothing">Do nothing for now</string>

    <!-- Choose Account Activity label -->
    <string name="choose_account_label">Choose an account</string>

    <string name="add_account_label">"Add an account"</string>

    <!-- List item to add an account [CHAR LIMIT=20] -->
    <string name="add_account_button_label">Add account</string>

    <!-- NumberPicker - accessibility support -->
    <!-- Description of the button to increase the NumberPicker value. [CHAR LIMIT=NONE] -->
    <string name="number_picker_increment_button">Increase</string>
    <!-- Description of the button to decrease the NumberPicker value. [CHAR LIMIT=NONE] -->
    <string name="number_picker_decrement_button">Decrease</string>
    <!-- Description of the tap and hold action to get into scroll mode in NumberPicker. [CHAR LIMIT=NONE] -->
    <string name="number_picker_increment_scroll_mode"><xliff:g id="value" example="3">%s</xliff:g> touch &amp; hold.</string>
    <!-- Description of the scrolling action in NumberPicker. [CHAR LIMIT=NONE] -->
    <string name="number_picker_increment_scroll_action">Slide up to increase and down to decrease.</string>

    <!-- TimePicker - accessibility support -->
    <!-- Description of the button to increase the TimePicker's minute value. [CHAR LIMIT=NONE] -->
    <string name="time_picker_increment_minute_button">Increase minute</string>
    <!-- Description of the button to decrease the TimePicker's minute value. [CHAR LIMIT=NONE] -->
    <string name="time_picker_decrement_minute_button">Decrease minute</string>
    <!-- Description of the button to increase the TimePicker's hour value. [CHAR LIMIT=NONE] -->
    <string name="time_picker_increment_hour_button">Increase hour</string>
    <!-- Description of the button to decrease the TimePicker's hour value. [CHAR LIMIT=NONE] -->
    <string name="time_picker_decrement_hour_button">Decrease hour</string>
    <!-- Description of the button to increase the TimePicker's set PM value. [CHAR LIMIT=NONE] -->
    <string name="time_picker_increment_set_pm_button">Set PM</string>
    <!-- Description of the button to decrease the TimePicker's set AM value. [CHAR LIMIT=NONE] -->
    <string name="time_picker_decrement_set_am_button">Set AM</string>

    <!-- DatePicker - accessibility support -->
    <!-- Description of the button to increase the DatePicker's month value. [CHAR LIMIT=NONE] -->
    <string name="date_picker_increment_month_button">Increase month</string>
    <!-- Description of the button to decrease the DatePicker's month value. [CHAR LIMIT=NONE] -->
    <string name="date_picker_decrement_month_button">Decrease month</string>
    <!-- Description of the button to increase the DatePicker's day value. [CHAR LIMIT=NONE] -->
    <string name="date_picker_increment_day_button">Increase day</string>
    <!-- Description of the button to decrease the DatePicker's day value. [CHAR LIMIT=NONE] -->
    <string name="date_picker_decrement_day_button">Decrease day</string>
    <!-- Description of the button to increase the DatePicker's year value. [CHAR LIMIT=NONE] -->
    <string name="date_picker_increment_year_button">Increase year</string>
    <!-- Description of the button to decrease the DatePicker's year value. [CHAR LIMIT=NONE] -->
    <string name="date_picker_decrement_year_button">Decrease year</string>
    <!-- Description of the button to move to the previous month. [CHAR LIMIT=NONE] -->
    <string name="date_picker_prev_month_button">Previous month</string>
    <!-- Description of the button to move to the next month. [CHAR LIMIT=NONE] -->
    <string name="date_picker_next_month_button">Next month</string>

    <!-- KeyboardView - accessibility support -->
    <!-- Description of the Alt button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_alt">Alt</string>
    <!-- Description of the Cancel button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_cancel">Cancel</string>
    <!-- Description of the Delete button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_delete">Delete</string>
    <!-- Description of the Done button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_done">Done</string>
    <!-- Description of the Mode change button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_mode_change">Mode change</string>
    <!-- Description of the Shift button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_shift">Shift</string>
    <!-- Description of the Enter button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_enter">Enter</string>

    <!-- ActivityChooserView - accessibility support -->
    <!-- Description of the shwoing of a popup window with activities to choose from. [CHAR LIMIT=NONE] -->
    <string name="activitychooserview_choose_application">Choose an app</string>

    <!-- Error message if the share target app cannto be launched. [CHAR LIMIT=NONE] -->
    <string name="activitychooserview_choose_application_error">Couldn\'t launch <xliff:g id="application_name" example="Acme">%s</xliff:g></string>

    <!-- ShareActionProvider - accessibility support -->
    <!-- Description of the choose target button in a ShareActionProvider (share UI). [CHAR LIMIT=NONE] -->
    <string name="shareactionprovider_share_with">Share with</string>
    <!-- Description of a share target (both in the list of such or the default share button) in a ShareActionProvider (share UI). [CHAR LIMIT=NONE] -->
    <string name="shareactionprovider_share_with_application">Share with <xliff:g id="application_name" example="Bluetooth">%s</xliff:g></string>

    <!-- Slide lock screen -->

    <!-- Description of the sliding handle in the Slide unlock screen. [CHAR LIMIT=NONE] -->
    <string name="content_description_sliding_handle">"Sliding handle. Touch &amp; hold."</string>

    <!-- Description of the unlock handle in the Slide unlock screen for tablets. [CHAR LIMIT=NONE] -->
    <string name="description_target_unlock_tablet">Swipe to unlock.</string>

    <!-- Content description for the action bar "home" affordance. [CHAR LIMIT=NONE] -->
    <string name="action_bar_home_description">Navigate home</string>
    <!-- Content description for the action bar "up" affordance. [CHAR LIMIT=NONE] -->
    <string name="action_bar_up_description">Navigate up</string>
    <!-- Content description for the action menu overflow button. [CHAR LIMIT=NONE] -->
    <string name="action_menu_overflow_description">More options</string>
    <!-- Formatting string for describing the action bar's title/home/up affordance.
         This is a single tappable "button" that includes the app icon, the Up indicator
         (usually a "<" chevron) and the window title text.
         %1$s is the title. %2$s is the description of what tapping/clicking the whole
         thing is going to do. -->
    <string name="action_bar_home_description_format">%1$s, %2$s</string>
    <!-- Just like action_bar_home_description_format, but this one will be used
         if the window is also providing subtitle text.
         %1$s is the title. %2$s is the subtitle. %3$s is the description of what
         tapping/clicking the whole thing is going to do. -->
    <string name="action_bar_home_subtitle_description_format">%1$s, %2$s, %3$s</string>

    <!-- Storage description for internal shared storage. [CHAR LIMIT=NONE] -->
    <string name="storage_internal">Internal shared storage</string>

    <!-- Storage description for a generic SD card. [CHAR LIMIT=NONE] -->
    <string name="storage_sd_card">SD card</string>
    <!-- Storage description for a SD card from a specific manufacturer. [CHAR LIMIT=NONE] -->
    <string name="storage_sd_card_label"><xliff:g id="manufacturer" example="SanDisk">%s</xliff:g> SD card</string>

    <!-- Storage description for a generic USB drive. [CHAR LIMIT=NONE] -->
    <string name="storage_usb_drive">USB drive</string>
    <!-- Storage description for a USB drive from a specific manufacturer. [CHAR LIMIT=NONE] -->
    <string name="storage_usb_drive_label"><xliff:g id="manufacturer" example="Seagate">%s</xliff:g> USB drive</string>

    <!-- Storage description for USB storage. [CHAR LIMIT=NONE] -->
    <string name="storage_usb">USB storage</string>

    <!-- Button text for the edit menu in input method extract mode. [CHAR LIMIT=16] -->
    <string name="extract_edit_menu_button">Edit</string>

    <!-- Notification title when data usage has exceeded warning threshold. [CHAR LIMIT=50] -->
    <string name="data_usage_warning_title">Data warning</string>
    <!-- Notification body when data usage has exceeded warning threshold. [CHAR LIMIT=32] -->
    <string name="data_usage_warning_body">You\'ve used <xliff:g id="app" example="3.8GB">%s</xliff:g> of data</string>

    <!-- Notification title when mobile data usage has exceeded limit threshold, and has been disabled. [CHAR LIMIT=50] -->
    <string name="data_usage_mobile_limit_title">Mobile data limit reached</string>
    <!-- Notification title when Wi-Fi data usage has exceeded limit threshold, and has been disabled. [CHAR LIMIT=32] -->
    <string name="data_usage_wifi_limit_title">Wi-Fi data limit reached</string>
    <!-- Notification body when data usage has exceeded limit threshold, and has been disabled. -->
    <string name="data_usage_limit_body">Data paused for the rest of your cycle</string>

    <!-- Notification title when mobile data usage has exceeded limit threshold. [CHAR LIMIT=32] -->
    <string name="data_usage_mobile_limit_snoozed_title">Over your mobile data limit</string>
    <!-- Notification title when Wi-Fi data usage has exceeded limit threshold. [CHAR LIMIT=32] -->
    <string name="data_usage_wifi_limit_snoozed_title">Over your Wi-Fi data limit</string>
    <!-- Notification body when data usage has exceeded limit threshold. -->
    <string name="data_usage_limit_snoozed_body">You\'ve gone <xliff:g id="size" example="3.8GB">%s</xliff:g> over your set limit</string>

    <!-- Notification title when background data usage is limited. [CHAR LIMIT=32] -->
    <string name="data_usage_restricted_title">Background data restricted</string>
    <!-- Notification body when background data usage is limited. -->
    <string name="data_usage_restricted_body">Tap to remove restriction.</string>

    <!-- Notification title when there has been recent excessive data usage. [CHAR LIMIT=32] -->
    <string name="data_usage_rapid_title">High mobile data usage</string>
    <!-- Notification body when there has been recent excessive data usage. [CHAR LIMIT=128] -->
    <string name="data_usage_rapid_body">Your apps have used more data than usual</string>
    <!-- Notification body when there has been recent excessive data usage by a specific app. [CHAR LIMIT=128] -->
    <string name="data_usage_rapid_app_body"><xliff:g id="app" example="Calculator">%s</xliff:g> has used more data than usual</string>

    <!-- SSL Certificate dialogs -->
    <!-- Title for an SSL Certificate dialog -->
    <string name="ssl_certificate">Security certificate</string>
    <!-- Message on an SSL Certificate dialog -->
    <string name="ssl_certificate_is_valid">This certificate is valid.</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="issued_to">Issued to:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="common_name">Common name:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="org_name">Organization:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="org_unit">Organizational unit:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="issued_by">Issued by:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="validity_period">Validity:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="issued_on">Issued on:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="expires_on">Expires on:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="serial_number">Serial number:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="fingerprints">Fingerprints:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="sha256_fingerprint">SHA-256 fingerprint:</string>
    <!-- Label for an information field on an SSL Certificate Dialog -->
    <string name="sha1_fingerprint">SHA-1 fingerprint:</string>

    <!-- Title for a button to expand the list of activities in ActivityChooserView [CHAR LIMIT=25] -->
    <string name="activity_chooser_view_see_all">See all</string>
    <!-- Title default for a dialog showing possible activities in ActivityChooserView [CHAR LIMIT=25] -->
    <string name="activity_chooser_view_dialog_title_default">Choose activity</string>

    <!-- Title for a dialog showing possible activities for sharing in ShareActionProvider [CHAR LIMIT=25] -->
    <string name="share_action_provider_share_with">Share with</string>

    <!-- STK sending DTMF, SMS, USSD, SS -->
    <string name="sending">Sending\u2026</string>

    <!-- STK launch Browser -->
    <string name="launchBrowserDefault">Launch Browser?</string>

    <!-- STK setup Call -->
    <string name="SetupCallDefault">Accept call?</string>

    <!-- Title for a button to choose the currently selected activity
         as the default in the activity resolver. [CHAR LIMIT=25] -->
    <string name="activity_resolver_use_always">Always</string>

    <!-- Title for a button to choose the currently selected activity
         as the default in the activity resolver. [CHAR LIMIT=50] -->
    <string name="activity_resolver_set_always">Set to always open</string>

    <!-- Title for a button to choose the currently selected activity
         from the activity resolver to use just this once. [CHAR LIMIT=25] -->
    <string name="activity_resolver_use_once">Just once</string>

    <!-- Title for a button to choose to go to
          'Open by Default' app settings. [CHAR LIMIT=25] -->
    <string name="activity_resolver_app_settings">Settings</string>

    <!-- Text for the toast that is shown when the user clicks on a launcher that
         doesn't support the work profile. [CHAR LIMIT=100] -->
    <string name="activity_resolver_work_profiles_support">%1$s doesn\'t support work profile</string>

    <!-- Name of the default audio route for tablets when nothing
         is connected to a headphone or other wired audio output jack. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name" product="tablet">Tablet</string>

    <!-- Name of the default audio route for tablets when nothing
         is connected to a headphone or other wired audio output jack. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name" product="tv">TV</string>

    <!-- Name of the default audio route when nothing is connected to
         a headphone or other wired audio output jack. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name" product="default">Phone</string>

    <!-- Name of the default audio route when an audio dock is connected. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name_dock_speakers">Dock speakers</string>

    <!-- Name of the default audio route when HDMI is connected. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name_hdmi">HDMI</string>

    <!-- Name of the default audio route when wired headphones are
         connected. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name_headphones">Headphones</string>

    <!-- Name of the default audio route when USB is connected. [CHAR LIMIT=50] -->
    <string name="default_audio_route_name_usb">USB</string>

    <!-- Name of the default audio route category. [CHAR LIMIT=50] -->
    <string name="default_audio_route_category_name">System</string>

    <!-- Description of the bluetooth a2dp audio route. [CHAR LIMIT=50] -->
    <string name="bluetooth_a2dp_audio_route_name">Bluetooth audio</string>

    <!-- Description of a wireless display route. [CHAR LIMIT=50] -->
    <string name="wireless_display_route_description">Wireless display</string>

    <!-- Content description of a MediaRouteButton for accessibility support.
        Cast is the standard android verb for sending content to a remote device. [CHAR LIMIT=50] -->
    <string name="media_route_button_content_description">Cast</string>

    <!-- Title of the media route chooser dialog. [CHAR LIMIT=40] -->
    <string name="media_route_chooser_title">Connect to device</string>

    <!-- Title of the media route chooser dialog for selecting remote display routes. [CHAR LIMIT=40] -->
    <string name="media_route_chooser_title_for_remote_display">Cast screen to device</string>

    <!-- Placeholder text to show when no devices have been found. [CHAR LIMIT=50] -->
    <string name="media_route_chooser_searching">Searching for devices\u2026</string>

    <!-- Button to access extended settings.  [CHAR LIMIT=30] -->
    <string name="media_route_chooser_extended_settings">Settings</string>

    <!-- Button to disconnect from a media route.  [CHAR LIMIT=30] -->
    <string name="media_route_controller_disconnect">Disconnect</string>

    <!-- Status message for remote routes attempting to scan/determine availability -->
    <string name="media_route_status_scanning">Scanning...</string>

    <!-- Status message for a remote route attempting to connect -->
    <string name="media_route_status_connecting">Connecting...</string>

    <!-- Status message for a remote route that is confirmed to be available for connection -->
    <string name="media_route_status_available">Available</string>

    <!-- Status message for remote routes that are not available for connection right now -->
    <string name="media_route_status_not_available">Not available</string>

    <!-- Status message for a remote route that is in use (and thus unavailabe) right now -->
    <string name="media_route_status_in_use">In use</string>

    <!-- Display manager service -->

    <!-- Name of the built-in display.  [CHAR LIMIT=50] -->
    <string name="display_manager_built_in_display_name">Built-in Screen</string>

    <!-- Name of the HDMI display.  [CHAR LIMIT=50] -->
    <string name="display_manager_hdmi_display_name">HDMI Screen</string>

    <!-- Name of the N'th overlay display for testing.  [CHAR LIMIT=50] -->
    <string name="display_manager_overlay_display_name">Overlay #<xliff:g id="id">%1$d</xliff:g></string>

    <!-- Title text to show within the overlay.  [CHAR LIMIT=50] -->
    <string name="display_manager_overlay_display_title"><xliff:g id="name">%1$s</xliff:g>: <xliff:g id="width">%2$d</xliff:g>x<xliff:g id="height">%3$d</xliff:g>, <xliff:g id="dpi">%4$d</xliff:g> dpi</string>

    <!-- Title text to append when the display is secure.  [CHAR LIMIT=30] -->
    <string name="display_manager_overlay_display_secure_suffix">, secure</string>

    <!-- Keyguard strings -->
    <!-- Message shown in pattern unlock after some number of unsuccessful attempts -->
    <string name="kg_forgot_pattern_button_text">Forgot Pattern</string>
    <!-- Message shown when user enters wrong pattern -->
    <string name="kg_wrong_pattern">Wrong Pattern</string>
    <!-- Message shown when user enters wrong password -->
    <string name="kg_wrong_password">Wrong Password</string>
    <!-- Message shown when user enters wrong PIN -->
    <string name="kg_wrong_pin">Wrong PIN</string>
    <!-- Countdown message shown after too many failed unlock attempts -->
    <plurals name="kg_too_many_failed_attempts_countdown">
        <item quantity="one">Try again in 1 second.</item>
        <item quantity="other">Try again in <xliff:g id="number">%d</xliff:g> seconds.</item>
    </plurals>
    <!-- Instructions for using the pattern unlock screen -->
    <string name="kg_pattern_instructions">Draw your pattern</string>
    <!-- Instructions for using the SIM PIN unlock screen -->
    <string name="kg_sim_pin_instructions">Enter SIM PIN</string>
    <!-- Instructions for using the PIN unlock screen -->
    <string name="kg_pin_instructions">Enter PIN</string>
    <!-- Instructions for using the password unlock screen -->
    <string name="kg_password_instructions">Enter Password</string>
    <!-- Hint shown in the PUK screen that asks the user to enter the PUK code given to them by their provider -->
    <string name="kg_puk_enter_puk_hint">SIM is now disabled. Enter PUK code to continue. Contact carrier for details.</string>
    <!-- Hint shown in the PUK unlock screen PIN TextView -->
    <string name="kg_puk_enter_pin_hint">Enter desired PIN code</string>
    <!-- Message shown when the user needs to confirm the PIN they just entered in the PUK screen -->
    <string name="kg_enter_confirm_pin_hint">Confirm desired PIN code</string>
    <!-- Message shown in dialog while the device is unlocking the SIM card -->
    <string name="kg_sim_unlock_progress_dialog_message">Unlocking SIM card\u2026</string>
    <!-- Message shown when the user enters the wrong PIN code -->
    <string name="kg_password_wrong_pin_code">Incorrect PIN code.</string>
    <!-- Message shown when the user enters an invalid SIM pin password in PUK screen -->
    <string name="kg_invalid_sim_pin_hint">Type a PIN that is 4 to 8 numbers.</string>
    <!-- Message shown when the user enters an invalid PUK code in the PUK screen -->
    <string name="kg_invalid_sim_puk_hint">PUK code should be 8 numbers.</string>
    <!-- Message shown when the user enters an invalid PUK code -->
    <string name="kg_invalid_puk">Re-enter the correct PUK code. Repeated attempts will permanently disable the SIM.</string>
      <!-- String shown in PUK screen when PIN codes don't match -->
    <string name="kg_invalid_confirm_pin_hint" product="default">PIN codes does not match</string>
    <!-- Message shown when the user exceeds the maximum number of pattern attempts -->
    <string name="kg_login_too_many_attempts">Too many pattern attempts</string>
    <!-- Instructions show in account unlock screen allowing user to enter their email password -->
    <string name="kg_login_instructions">To unlock, sign in with your Google account.</string>
    <!-- Hint shown in TextView in account unlock screen of keyguard -->
    <string name="kg_login_username_hint">Username (email)</string>
    <!-- Hint shown in TextView in account unlock screen of keyguard -->
    <string name="kg_login_password_hint">Password</string>
    <!-- Label shown on sign in button on account unlock screen of keyguard -->
    <string name="kg_login_submit_button">Sign in</string>
    <!-- Message shown when the user enters an invalid username/password combination in account unlock screen of keyguard -->
    <string name="kg_login_invalid_input">Invalid username or password.</string>
    <!-- Hint text shown when user has too many failed password attempts in account unlock screen of keyguard -->
    <string name="kg_login_account_recovery_hint">Forgot your username or password\?\nVisit <b>google.com/accounts/recovery</b>.</string>
    <!-- Message shown while device checks username/password in account unlock screen of keyguard -->
    <string name="kg_login_checking_password">Checking account\u2026</string>
    <!-- Message shown in dialog when max number of attempts are reached for PIN screen of keyguard -->
    <string name="kg_too_many_failed_pin_attempts_dialog_message">
        You have incorrectly typed your PIN <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>
    <!-- Message shown in dialog when max number of attempts are reached for password screen of keyguard -->
    <string name="kg_too_many_failed_password_attempts_dialog_message">
        You have incorrectly typed your password <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>
    <!-- Message shown when user is almost at the limit of password attempts where the device will be wiped. -->
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       the tablet will be reset to factory default and all user data will be lost.
    </string>
    <!-- Message shown when user is almost at the limit of password attempts where the device will be wiped. -->
    <string name="kg_failed_attempts_almost_at_wipe" product="tv">
       You have incorrectly attempted to unlock your Android TV device <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       your Android TV device will be reset to factory default and all user data will be lost.
    </string>
    <!-- Message shown when user is almost at the limit of password attempts where the device will be wiped. -->
    <string name="kg_failed_attempts_almost_at_wipe" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       the phone will be reset to factory default and all user data will be lost.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the device will now be wiped -->
    <string name="kg_failed_attempts_now_wiping" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%d</xliff:g> times.
       The tablet will now be reset to factory default.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the device will now be wiped -->
    <string name="kg_failed_attempts_now_wiping" product="tv">
       You have incorrectly attempted to unlock your Android TV device <xliff:g id="number">%d</xliff:g> times.
       Your Android TV device will now be reset to factory default.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the device will now be wiped -->
    <string name="kg_failed_attempts_now_wiping" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%d</xliff:g> times.
       The phone will now be reset to factory default.
    </string>
    <!-- Message shown in dialog when user is almost at the limit where they will be
    locked out and may have to enter an alternate username/password to unlock the phone -->
    <string name="kg_failed_attempts_almost_at_login" product="tablet">
       You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your tablet using an email account.\n\n
       Try again in <xliff:g id="number">%3$d</xliff:g> seconds.
    </string>
    <!-- Message shown in dialog when user is almost at the limit where they will be
    locked out and may have to enter an alternate username/password to unlock the phone -->
    <string name="kg_failed_attempts_almost_at_login" product="tv">
       You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your Android TV device using an email account.\n\n
       Try again in <xliff:g id="number">%3$d</xliff:g> seconds.
    </string>
    <!-- Message shown in dialog when user is almost at the limit where they will be
    locked out and may have to enter an alternate username/password to unlock the phone -->
    <string name="kg_failed_attempts_almost_at_login" product="default">
       You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your phone using an email account.\n\n
       Try again in <xliff:g id="number">%3$d</xliff:g> seconds.
    </string>
    <!-- Sequence of characters used to separate message strings in keyguard. Typically just em-dash
         with spaces on either side. [CHAR LIMIT=3] -->
    <string name="kg_text_message_separator" product="default">" \u2014 "</string>
    <!-- The delete-widget drop target button text -->
    <string name="kg_reordering_delete_drop_target_text">Remove</string>

    <!-- Toast message for background started foreground service while-in-use permission restriction feature -->
    <string name="allow_while_in_use_permission_in_fgs">The background started foreground service from <xliff:g id="packageName" example="com.example">%1$s</xliff:g> will not have while-in-use permission in future R builds. Please see go/r-bg-fgs-restriction and file a bugreport.</string>

    <!-- Message shown in dialog when user is attempting to set the music volume above the
    recommended maximum level for headphones -->
    <string name="safe_media_volume_warning" product="default">
       "Raise volume above recommended level?\n\nListening at high volume for long periods may damage your hearing."
    </string>

    <!-- Dialog title for dialog shown when the accessibility shortcut is activated, and we want
     to confirm that the user understands what's going to happen-->
    <string name="accessibility_shortcut_warning_dialog_title">Use Accessibility Shortcut?</string>

    <!-- Message shown in dialog when user is in the process of enabling the accessibility
    service via the volume buttons shortcut for the first time. [CHAR LIMIT=none] -->
    <string name="accessibility_shortcut_toogle_warning">
        When the shortcut is on, pressing both volume buttons for 3 seconds will start an
        accessibility feature.
    </string>

    <!-- Text in button that edit the accessibility shortcut menu, user can delete
    any service item in the menu list. [CHAR LIMIT=100] -->
    <string name="edit_accessibility_shortcut_menu_button">Edit shortcuts</string>

    <!-- Text in button that cancel the accessibility shortcut menu changed status. [CHAR LIMIT=100] -->
    <string name="cancel_accessibility_shortcut_menu_button">Cancel</string>

    <!-- Text in button that turns off the accessibility shortcut -->
    <string name="disable_accessibility_shortcut">Turn off Shortcut</string>

    <!-- Text in button that closes the warning dialog about the accessibility shortcut, leaving the
    shortcut enabled.-->
    <string name="leave_accessibility_shortcut_on">Use Shortcut</string>

    <!-- Title of Color Inversion feature shown in the warning dialog about the accessibility
    shortcut. -->
    <string name="color_inversion_feature_name">Color Inversion</string>

    <!-- Title of Color Correction feature, which is mostly used to help users who are colorblind,
     shown in the warning dialog about the accessibility shortcut. -->
    <string name="color_correction_feature_name">Color Correction</string>

    <!-- Text in toast to alert the user that the accessibility shortcut turned on an accessibility
    service.-->
    <string name="accessibility_shortcut_enabling_service">Accessibility Shortcut turned
        <xliff:g id="service_name" example="TalkBack">%1$s</xliff:g> on</string>

    <!-- Text in toast to alert the user that the accessibility shortcut turned off an accessibility
    service.-->
    <string name="accessibility_shortcut_disabling_service">Accessibility Shortcut turned
        <xliff:g id="service_name" example="TalkBack">%1$s</xliff:g> off</string>

    <!-- Text spoken when accessibility shortcut warning dialog is shown. [CHAR LIMIT=none] -->
    <string name="accessibility_shortcut_spoken_feedback">Press and hold both volume keys for three seconds to use
        <xliff:g id="service_name" example="TalkBack">%1$s</xliff:g></string>

    <!-- Text used to describe system navigation features, shown within a UI allowing a user to assign system magnification features to the Accessibility button in the navigation bar. -->
    <string name="accessibility_magnification_chooser_text">Magnification</string>

    <!-- Text spoken when the current user is switched if accessibility is enabled. [CHAR LIMIT=none] -->
    <string name="user_switched">Current user <xliff:g id="name" example="Bob">%1$s</xliff:g>.</string>
    <!-- Message shown when switching to a user [CHAR LIMIT=none] -->
    <string name="user_switching_message">Switching to <xliff:g id="name" example="Bob">%1$s</xliff:g>\u2026</string>
    <!-- Message when logging out a user on a split user system -->
    <string name="user_logging_out_message">Logging out <xliff:g id="name" example="Bob">%1$s</xliff:g>\u2026</string>
    <!-- Default name of the owner user [CHAR LIMIT=20] -->
    <string name="owner_name" msgid="3879126011135546571">Owner</string>
    <!-- Error message title [CHAR LIMIT=35] -->
    <string name="error_message_title">Error</string>
    <!-- Message informing user that the change was disallowed by an administrator. [CHAR LIMIT=none] -->
    <string name="error_message_change_not_allowed">This change isn\'t allowed by your admin</string>
    <!-- Message informing user that the requested activity could not be found [CHAR LIMIT=none] -->
    <string name="app_not_found">No application found to handle this action</string>
    <string name="revoke">Revoke</string>

    <!-- Printing -->

    <!-- ISO (European standard) A0 media (paper) size: 33.11" × 46.81" -->
    <string name="mediasize_iso_a0">ISO A0</string>
    <!-- ISO (European standard) A1 media (paper) size: 23.39" × 33.11" -->
    <string name="mediasize_iso_a1">ISO A1</string>
    <!-- ISO (European standard) A2 media (paper) size: 16.54" x 23.39" -->
    <string name="mediasize_iso_a2">ISO A2</string>
    <!-- ISO (European standard) A3 media (paper) size: 11.69" x 16.54" -->
    <string name="mediasize_iso_a3">ISO A3</string>
    <!-- ISO (European standard) A4 media (paper) size: 8.27" x 11.69" -->
    <string name="mediasize_iso_a4">ISO A4</string>
    <!-- ISO (European standard) A5 media (paper) size: 5.83" x 8.27" -->
    <string name="mediasize_iso_a5">ISO A5</string>
    <!-- ISO (European standard) A6 media (paper) size: 4.13" x 5.83" -->
    <string name="mediasize_iso_a6">ISO A6</string>
    <!-- ISO (European standard) A7 media (paper) size: 2.91" x 4.13" -->
    <string name="mediasize_iso_a7">ISO A7</string>
    <!-- ISO (European standard) A8 media (paper) size: 2.05" x 2.91" -->
    <string name="mediasize_iso_a8">ISO A8</string>
    <!-- ISO (European standard) A9 media (paper) size: 1.46" x 2.05" -->
    <string name="mediasize_iso_a9">ISO A9</string>
    <!-- ISO (European standard) A10 media (paper) size: 1.02" x 1.46" -->
    <string name="mediasize_iso_a10">ISO A10</string>

    <!-- ISO (European standard) B0 media (paper) size: 39.37" x 55.67" -->
    <string name="mediasize_iso_b0">ISO B0</string>
    <!-- ISO (European standard) B1 media (paper) size: 27.83" x 39.37" -->
    <string name="mediasize_iso_b1">ISO B1</string>
    <!-- ISO (European standard) B2 media (paper) size - 19.69" x 27.83" -->
    <string name="mediasize_iso_b2">ISO B2</string>
    <!-- ISO (European standard) B3 media (paper) size: 13.90" x 19.69" -->
    <string name="mediasize_iso_b3">ISO B3</string>
    <!-- ISO (European standard) B4 media (paper) size: 9.84" x 13.90" -->
    <string name="mediasize_iso_b4">ISO B4</string>
    <!-- ISO (European standard) B5 media (paper) size: 6.93" x 9.84" -->
    <string name="mediasize_iso_b5">ISO B5</string>
    <!-- ISO (European standard) B6 media (paper) size: 4.92" x 6.93" -->
    <string name="mediasize_iso_b6">ISO B6</string>
    <!-- ISO (European standard) B7 media (paper) size: 3.46" x 4.92" -->
    <string name="mediasize_iso_b7">ISO B7</string>
    <!-- ISO (European standard) B8 media (paper) size: 2.44" x 3.46" -->
    <string name="mediasize_iso_b8">ISO B8</string>
    <!-- ISO (European standard) B9 media (paper) size: 1.73" x 2.44" -->
    <string name="mediasize_iso_b9">ISO B9</string>
    <!-- ISO (European standard) B10 media (paper) size: 1.22" x 1.73" -->
    <string name="mediasize_iso_b10">ISO B10</string>

    <!-- ISO (European standard) C0 media (paper) size: 36.10" x 51.06" -->
    <string name="mediasize_iso_c0">ISO C0</string>
    <!-- ISO (European standard) C1 media (paper) size: 25.51" x 36.10" -->
    <string name="mediasize_iso_c1">ISO C1</string>
    <!-- ISO (European standard) C2 media (paper) size: 18.03" x 25.51" -->
    <string name="mediasize_iso_c2">ISO C2</string>
    <!-- ISO (European standard) C3 media (paper) size: 12.76" x 18.03" -->
    <string name="mediasize_iso_c3">ISO C3</string>
    <!-- ISO (European standard) C4 media (paper) size: 9.02" x 12.76" -->
    <string name="mediasize_iso_c4">ISO C4</string>
    <!-- ISO (European standard) C5 media (paper) size: 6.38" x 9.02" -->
    <string name="mediasize_iso_c5">ISO C5</string>
    <!-- ISO (European standard) C6 media (paper) size: 4.49" x 6.38" -->
    <string name="mediasize_iso_c6">ISO C6</string>
    <!-- ISO (European standard) C7 media (paper) size: 3.19" x 4.49" -->
    <string name="mediasize_iso_c7">ISO C7</string>
    <!-- ISO ISO C8 media (paper) size: 2.24" x 3.19" -->
    <string name="mediasize_iso_c8">ISO C8</string>
    <!-- ISO ISO C9 media (paper) size: 1.57" x 2.24" -->
    <string name="mediasize_iso_c9">ISO C9</string>
    <!-- ISO (European standard) C10 media (paper) size: 1.10" x 1.57" -->
    <string name="mediasize_iso_c10">ISO C10</string>

    <!-- North America Letter media (paper) size: 8.5" × 11" (279mm x 216mm) -->
    <string name="mediasize_na_letter">Letter</string>
    <!-- North America Government Letter media (paper) size: 8.0" × 10.5" (203mm x 267mm) -->
    <string name="mediasize_na_gvrnmt_letter">Government Letter</string>
    <!-- North America Legal media (paper) size: 8.5" × 14" (216mm x 356mm) -->
    <string name="mediasize_na_legal">Legal</string>
    <!-- North America Junior Legal media (paper) size: 8.0" × 5.0" (203mm × 127mm) -->
    <string name="mediasize_na_junior_legal">Junior Legal</string>
    <!-- North America Ledger media (paper) size: 17" × 11" (432mm × 279mm) -->
    <string name="mediasize_na_ledger">Ledger</string>
    <!-- North America Tabloid media (paper) size: 11" × 17" (279mm × 432mm) -->
    <string name="mediasize_na_tabloid">Tabloid</string>

    <!-- North America Index Card 3x5 media (paper) size: 3" x 5" (76mm x 127mm) -->
    <string name="mediasize_na_index_3x5">Index Card 3x5</string>
    <!-- North America Index Card 4x6 media (paper) size: 4" x 6" (102mm x 152mm) -->
    <string name="mediasize_na_index_4x6">Index Card 4x6</string>
    <!-- North America Index Card 5x8 media (paper) size: 5" x 8" (127mm x 203mm) -->
    <string name="mediasize_na_index_5x8">Index Card 5x8</string>
    <!-- North America Monarch media (paper) size: 7.25" x 10.5" (184mm x 267mm) -->
    <string name="mediasize_na_monarch">Monarch</string>
    <!-- North America Quarto media (paper) size: 8" x 10" (203mm x 254mm) -->
    <string name="mediasize_na_quarto">Quarto</string>
    <!-- North America Foolscap media (paper) size: 8" x 13" (203mm x 330mm) -->
    <string name="mediasize_na_foolscap">Foolscap</string>

    <!-- Chinese Roc 8k media (paper) size: 270mm x 390mm (10.629" x 15.3543") -->
    <string name="mediasize_chinese_roc_8k">ROC 8K</string>
    <!-- Chinese Roc 16k media (paper) size: 195mm x 270mm (7.677" x 10.629") -->
    <string name="mediasize_chinese_roc_16k">ROC 16K</string>

    <!-- Chinese PRC 1 media (paper) size: 102mm x 165mm (4.015" x 6.496") -->
    <string name="mediasize_chinese_prc_1">PRC 1</string>
    <!-- Chinese PRC 2 media (paper) size: 102mm x 176mm (4.015" x 6.929") -->
    <string name="mediasize_chinese_prc_2">PRC 2</string>
    <!-- Chinese PRC 3 media (paper) size: 125mm x 176mm (4.921" x 6.929") -->
    <string name="mediasize_chinese_prc_3">PRC 3</string>
    <!-- Chinese PRC 4 media (paper) size: 110mm x 208mm (4.330" x 8.189") -->
    <string name="mediasize_chinese_prc_4">PRC 4</string>
    <!-- Chinese PRC 5 media (paper) size: 110mm x 220mm (4.330" x 8.661") -->
    <string name="mediasize_chinese_prc_5">PRC 5</string>
    <!-- Chinese PRC 6 media (paper) size: 120mm x 320mm (4.724" x 12.599") -->
    <string name="mediasize_chinese_prc_6">PRC 6</string>
    <!-- Chinese PRC 7 media (paper) size: 160mm x 230mm (6.299" x 9.055") -->
    <string name="mediasize_chinese_prc_7">PRC 7</string>
    <!-- Chinese PRC 8 media (paper) size: 120mm x 309mm (4.724" x 12.165") -->
    <string name="mediasize_chinese_prc_8">PRC 8</string>
    <!-- Chinese PRC 9 media (paper) size: 229mm x 324mm (9.016" x 12.756") -->
    <string name="mediasize_chinese_prc_9">PRC 9</string>
    <!-- Chinese PRC 10 media (paper) size: 324mm x 458mm (12.756" x 18.032") -->
    <string name="mediasize_chinese_prc_10">PRC 10</string>

    <!-- Chinese RPC 16K media (paper) size: 146mm x 215mm (5.749" x 8.465") -->
    <string name="mediasize_chinese_prc_16k">PRC 16K</string>
    <!-- Chinese Pa Kai media (paper) size: 146mm x 215mm (5.749" x 8.465") -->
    <string name="mediasize_chinese_om_pa_kai">Pa Kai</string>
    <!-- Chinese Dai Pa Kai media (paper) size: 275mm x 395mm (10.827" x 15.551") -->
    <string name="mediasize_chinese_om_dai_pa_kai">Dai Pa Kai</string>
    <!-- Chinese Jurro Ku Kai media (paper) size: 275mm x 395mm (10.827" x 15.551") -->
    <string name="mediasize_chinese_om_jurro_ku_kai">Jurro Ku Kai</string>

    <!-- Japanese JIS B10 media (paper) size: 32mm x 45mm (1.259" x 1.772") -->
    <string name="mediasize_japanese_jis_b10">JIS B10</string>
    <!-- Japanese JIS B9 media (paper) size: 45mm x 64mm (1.772" x 2.52") -->
    <string name="mediasize_japanese_jis_b9">JIS B9</string>
    <!-- Japanese JIS B8 media (paper) size: 64mm x 91mm (2.52" x 3.583") -->
    <string name="mediasize_japanese_jis_b8">JIS B8</string>
    <!-- Japanese JIS B7 media (paper) size: 91mm x 128mm (3.583" x 5.049") -->
    <string name="mediasize_japanese_jis_b7">JIS B7</string>
    <!-- Japanese JIS B6 media (paper) size: 128mm x 182mm (5.049" x 7.165") -->
    <string name="mediasize_japanese_jis_b6">JIS B6</string>
    <!-- Japanese JIS B5 media (paper) size: 182mm x 257mm (7.165" x 10.118") -->
    <string name="mediasize_japanese_jis_b5">JIS B5</string>
    <!-- Japanese JIS B4 media (paper) size: 257mm x 364mm (10.118" x 14.331") -->
    <string name="mediasize_japanese_jis_b4">JIS B4</string>
    <!-- Japanese JIS B3 media (paper) size: 364mm x 515mm (14.331" x 20.276") -->
    <string name="mediasize_japanese_jis_b3">JIS B3</string>
    <!-- Japanese JIS B2 media (paper) size: 515mm x 728mm (20.276" x 28.661") -->
    <string name="mediasize_japanese_jis_b2">JIS B2</string>
    <!-- Japanese JIS B1 media (paper) size: 728mm x 1030mm (28.661" x 40.551") -->
    <string name="mediasize_japanese_jis_b1">JIS B1</string>
    <!-- Japanese JIS B0 media (paper) size: 1030mm x 1456mm (40.551" x 57.323") -->
    <string name="mediasize_japanese_jis_b0">JIS B0</string>

    <!-- Japanese JIS Exec media (paper) size: 216mm x 330mm (8.504" x 12.992") -->
    <string name="mediasize_japanese_jis_exec">JIS Exec</string>

    <!-- Japanese Chou4 media (paper) size: 90mm x 205mm (3.543" x 8.071") -->
    <string name="mediasize_japanese_chou4">Chou4</string>
    <!-- Japanese Chou3 media (paper) size: 120mm x 235mm (4.724" x 9.252") -->
    <string name="mediasize_japanese_chou3">Chou3</string>
    <!-- Japanese Chou2 media (paper) size: 111.1mm x 146mm (4.374" x 5.748") -->
    <string name="mediasize_japanese_chou2">Chou2</string>

    <!-- Japanese Hagaki media (paper) size: 100mm x 148mm (3.937" x 5.827") -->
    <string name="mediasize_japanese_hagaki">Hagaki </string>
    <!-- Japanese Oufuku media (paper) size: 148mm x 200mm (5.827" x 7.874") -->
    <string name="mediasize_japanese_oufuku">Oufuku </string>
    <!-- Japanese Kahu media (paper) size: 240mm x 322.1mm (9.449" x 12.681") -->
    <string name="mediasize_japanese_kahu">Kahu</string>
    <!-- Japanese Kaku2 media (paper) size: 240mm x 332mm (9.449" x 13.071") -->
    <string name="mediasize_japanese_kaku2">Kaku2</string>
    <!-- Japanese You4 media (paper) size: 105mm x 235mm (4.134" x 9.252") -->
    <string name="mediasize_japanese_you4">You4</string>

    <!-- Media (paper) size for specifying any paper size in portrait.-->
    <string name="mediasize_unknown_portrait">Unknown portrait</string>
    <!-- Media (paper) size for specifying any paper size in landscape.-->
    <string name="mediasize_unknown_landscape">Unknown landscape</string>

    <!-- Write fail reason: printing was cancelled.[CHAR LIMIT=none] -->
    <string name="write_fail_reason_cancelled">Cancelled</string>
    <!-- Write fail reason: couldn't write the printed content. [CHAR LIMIT=none] -->
    <string name="write_fail_reason_cannot_write">Error writing content</string>

    <!-- Print fail reason: unknown. [CHAR LIMIT=25] -->
    <string name="reason_unknown">unknown</string>

    <!-- Print fail reason: the print service that has to process the print job is not available. [CHAR LIMIT=none] -->
    <string name="reason_service_unavailable">Print service not enabled</string>

    <!-- Title for the notification that a print service was installed. [CHAR LIMIT=50] -->
    <string name="print_service_installed_title"><xliff:g id="name" example="Cloud Print">%s</xliff:g> service installed</string>
    <!-- Message for the notification that a print service was installed. [CHAR LIMIT=50] -->
    <string name="print_service_installed_message">Tap to enable</string>

    <!-- PIN entry dialog title for entering the administrator PIN [CHAR LIMIT=none] -->
    <string name="restr_pin_enter_admin_pin">Enter admin PIN</string>
    <!-- PIN entry dialog label/hint for PIN [CHAR LIMIT=none] -->
    <string name="restr_pin_enter_pin">Enter PIN</string>
    <!-- PIN entry dialog label/hint for incorrect PIN entry [CHAR LIMIT=none] -->
    <string name="restr_pin_incorrect">Incorrect</string>
    <!-- PIN entry dialog label/hint for old PIN [CHAR LIMIT=none] -->
    <string name="restr_pin_enter_old_pin">Current PIN</string>
    <!-- PIN entry dialog label for new PIN [CHAR LIMIT=none] -->
    <string name="restr_pin_enter_new_pin">New PIN</string>
    <!-- PIN entry dialog label for new PIN confirmation [CHAR LIMIT=none] -->
    <string name="restr_pin_confirm_pin">Confirm new PIN</string>
    <!-- PIN creation dialog message [CHAR LIMIT=none] -->
    <string name="restr_pin_create_pin">Create a PIN for modifying restrictions</string>
    <!-- PIN entry dialog error when PINs are not the same [CHAR LIMIT=none] -->
    <string name="restr_pin_error_doesnt_match">PINs don\'t match. Try again.</string>
    <!-- PIN entry dialog error when PIN is too short [CHAR LIMIT=none] -->
    <string name="restr_pin_error_too_short">PIN is too short. Must be at least 4 digits.</string>
    <!-- PIN entry dialog countdown message for next chance to enter the PIN [CHAR LIMIT=none] -->
    <!-- Phrase describing a time duration using seconds [CHAR LIMIT=none] -->
    <plurals name="restr_pin_countdown">
        <item quantity="one">Try again in 1 second</item>
        <item quantity="other">Try again in <xliff:g id="count">%d</xliff:g> seconds</item>
    </plurals>
    <!-- PIN entry dialog tells the user to not enter a PIN for a while. [CHAR LIMIT=none] -->
    <string name="restr_pin_try_later">Try again later</string>

    <!-- Cling help message title when hiding the navigation bar entering immersive mode [CHAR LIMIT=none] -->
    <string name="immersive_cling_title">Viewing full screen</string>

    <!-- Cling help message description when hiding the navigation bar entering immersive mode [CHAR LIMIT=none] -->
    <string name="immersive_cling_description">To exit, swipe down from the top.</string>

    <!-- Cling help message confirmation button when hiding the navigation bar entering immersive mode [CHAR LIMIT=30] -->
    <string name="immersive_cling_positive">Got it</string>

    <!-- Label for button to confirm chosen date or time [CHAR LIMIT=30] -->
    <string name="done_label">Done</string>
    <!--
         Content description for the hour selector in the time picker, which displays
         selectable hours of the day along the inside edge of a circle, as in an analog clock.
         [CHAR LIMIT=50]
    -->
    <string name="hour_picker_description">Hours circular slider</string>
    <!--
         Content description for the minute selector in the time picker, which displays
         selectable five-minute intervals along the inside edge of a circle, as in an analog clock.
         [CHAR LIMIT=50]
    -->
    <string name="minute_picker_description">Minutes circular slider</string>
    <!-- Accessibility announcement for hour circular picker [CHAR LIMIT=NONE] -->
    <string name="select_hours">Select hours</string>
    <!-- Accessibility announcement for minute circular picker [CHAR LIMIT=NONE] -->
    <string name="select_minutes">Select minutes</string>

    <!-- Accessibility announcement for the day picker [CHAR LIMIT=NONE] -->
    <string name="select_day">Select month and day</string>
    <!-- Accessibility announcement for the year picker [CHAR LIMIT=NONE] -->
    <string name="select_year">Select year</string>
    <!-- Accessibility announcement when a number that had been typed in is deleted [CHAR_LIMIT=NONE] -->
    <string name="deleted_key"><xliff:g id="key" example="4">%1$s</xliff:g> deleted</string>

    <!--
        Used to wrap a label for content description for a work profile, e.g. "Work Email" instead
        of email when there are two email apps.
        [CHAR LIMIT=20]
     -->
    <string name="managed_profile_label_badge">Work <xliff:g id="label" example="Email">%1$s</xliff:g></string>
    <string name="managed_profile_label_badge_2">2nd Work <xliff:g id="label" example="Email">%1$s</xliff:g></string>
    <string name="managed_profile_label_badge_3">3rd Work <xliff:g id="label" example="Email">%1$s</xliff:g></string>

    <!-- DO NOT TRANSLATE -->
    <string name="time_placeholder">--</string>

    <!-- DO NOT TRANSLATE -->
    <string name="radial_numbers_typeface">sans-serif</string>
    <!-- DO NOT TRANSLATE -->
    <string name="sans_serif">sans-serif</string>

    <!-- DO NOT TRANSLATE -->
    <string name="date_picker_month_typeface">sans-serif-medium</string>
    <!-- DO NOT TRANSLATE -->
    <string name="date_picker_day_of_week_typeface">sans-serif-medium</string>
    <!-- DO NOT TRANSLATE -->
    <string name="date_picker_day_typeface">sans-serif-medium</string>

    <!-- Lock-to-app unlock pin string -->
    <string name="lock_to_app_unlock_pin">Ask for PIN before unpinning</string>
    <!-- Lock-to-app unlock pattern string -->
    <string name="lock_to_app_unlock_pattern">Ask for unlock pattern before unpinning</string>
    <!-- Lock-to-app unlock password string -->
    <string name="lock_to_app_unlock_password">Ask for password before unpinning</string>

    <!-- Notification shown when device owner silently installs a package [CHAR LIMIT=NONE] -->
    <string name="package_installed_device_owner">Installed by your admin</string>
    <!-- Notification shown when device owner silently updates a package [CHAR LIMIT=NONE] -->
    <string name="package_updated_device_owner">Updated by your admin</string>
    <!-- Notification shown when device owner silently deletes a package [CHAR LIMIT=NONE] -->
    <string name="package_deleted_device_owner">Deleted by your admin</string>

    <!-- [CHAR LIMIT=25] String for confirmation button to enable a feature gated by the battery saver warning-->
    <string name="confirm_battery_saver">OK</string>

    <!-- [CHAR_LIMIT=NONE] Battery saver: Feature description, with a "learn more" link. -->
    <string name="battery_saver_description_with_learn_more">To extend battery life, Battery Saver:\n&#183;Turns on Dark theme\n&#183;Turns off or restricts background activity, some visual effects, and other features like \u201cHey Google\u201d\n\n<annotation id="url">Learn more</annotation></string>

    <!-- [CHAR_LIMIT=NONE] Battery saver: Feature description, without a "learn more" link. -->
    <string name="battery_saver_description">To extend battery life, Battery Saver:\n&#183;Turns on Dark theme\n&#183;Turns off or restricts background activity, some visual effects, and other features like \u201cHey Google\u201d</string>

    <!-- [CHAR_LIMIT=NONE] Data saver: Feature description -->
    <string name="data_saver_description">To help reduce data usage, Data Saver prevents some apps from sending or receiving data in the background. An app you’re currently using can access data, but may do so less frequently. This may mean, for example, that images don’t display until you tap them.</string>
    <!-- [CHAR_LIMIT=35] Data saver: Title on first-time dialog -->
    <string name="data_saver_enable_title">Turn on Data Saver?</string>
    <!-- [CHAR_LIMIT=16] Data saver: Button to turn it on on first-time dialog -->
    <string name="data_saver_enable_button">Turn on</string>

    <!-- Zen mode condition - summary: time duration in minutes. [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_minutes_summary">
        <item quantity="one">For one minute (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
        <item quantity="other">For %1$d minutes (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
    </plurals>

    <!-- Zen mode condition - summary: time duration in minutes (short version). [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_minutes_summary_short">
        <item quantity="one">For 1 min (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
        <item quantity="other">For %1$d min (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
    </plurals>

    <!-- Zen mode condition - summary: time duration in hours. [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_hours_summary">
        <item quantity="one">For 1 hour (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
        <item quantity="other">For %1$d hours (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
    </plurals>

    <!-- Zen mode condition - summary: time duration in hours (short version). [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_hours_summary_short">
        <item quantity="one">For 1 hr (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
        <item quantity="other">For %1$d hr (until <xliff:g id="formattedTime" example="10:00 PM">%2$s</xliff:g>)</item>
    </plurals>

    <!-- Zen mode condition - line one: time duration in minutes. [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_minutes">
        <item quantity="one">For one minute</item>
        <item quantity="other">For %d minutes</item>
    </plurals>

    <!-- Zen mode condition - line one: time duration in minutes (short version). [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_minutes_short">
        <item quantity="one">For 1 min</item>
        <item quantity="other">For %d min</item>
    </plurals>

    <!-- Zen mode condition - line one: time duration in hours. [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_hours">
        <item quantity="one">For 1 hour</item>
        <item quantity="other">For %d hours</item>
    </plurals>

    <!-- Zen mode condition - line one: time duration in hours (short version). [CHAR LIMIT=NONE] -->
    <plurals name="zen_mode_duration_hours_short">
        <item quantity="one">For 1 hr</item>
        <item quantity="other">For %d hr</item>
    </plurals>

    <!-- Zen mode condition - line two: ending time. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_until">Until <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g></string>

    <!-- Zen mode condition - line one: Until next alarm. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_alarm">Until <xliff:g id="formattedTime" example="10:00 PM">%1$s</xliff:g> (next alarm)</string>

    <!-- Zen mode condition: no exit criteria. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_forever">Until you turn off</string>

    <!-- Zen mode condition: no exit criteria, includes the name of the feature for emphasis. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_forever_dnd">Until you turn off Do Not Disturb</string>

    <!-- Zen mode active automatic rule name separator. [CHAR LIMIT=NONE] -->
    <string name="zen_mode_rule_name_combination"><xliff:g id="first" example="Weeknights">%1$s</xliff:g> / <xliff:g id="rest" example="Meetings">%2$s</xliff:g></string>

    <!-- Content description for the Toolbar icon used to collapse an expanded action mode. [CHAR LIMIT=NONE] -->
    <string name="toolbar_collapse_description">Collapse</string>

    <!-- Zen mode - feature name. [CHAR LIMIT=40] -->
    <string name="zen_mode_feature_name">Do not disturb</string>

    <!-- Zen mode - downtime legacy feature name. [CHAR LIMIT=40] -->
    <string name="zen_mode_downtime_feature_name">Downtime</string>

    <!-- Zen mode - name of default automatic schedule for weeknights. [CHAR LIMIT=40] -->
    <string name="zen_mode_default_weeknights_name">Weeknight</string>

    <!-- Zen mode - name of default automatic schedule for weekends. [CHAR LIMIT=40] -->
    <string name="zen_mode_default_weekends_name">Weekend</string>

    <!-- Zen mode - name of default automatic calendar event-based rule. [CHAR LIMIT=40] -->
    <string name="zen_mode_default_events_name">Event</string>

    <!-- Zen mode - name of default automatic calendar time-based rule that is triggered every night (when sleeping). [CHAR LIMIT=40] -->
    <string name="zen_mode_default_every_night_name">Sleeping</string>

    <!-- Indication that the current volume and other effects (vibration) are being suppressed by a third party, such as a notification listener. [CHAR LIMIT=30] -->
    <string name="muted_by"><xliff:g id="third_party">%1$s</xliff:g> is muting some sounds</string>

    <!-- Error message shown when there is a system error which can be solved by user performing factory reset. [CHAR LIMIT=NONE] -->
    <string name="system_error_wipe_data">There\'s an internal problem with your device, and it may be unstable until you factory data reset.</string>
    <!-- Error message shown when there is a system error which can be solved by the manufacturer. [CHAR LIMIT=NONE] -->
    <string name="system_error_manufacturer">There\'s an internal problem with your device. Contact your manufacturer for details.</string>

    <!-- Displayed when the USSD/SS request is modified by STK CC to a
    different request. This will be displayed in a toast. -->
    <string name="stk_cc_ussd_to_dial">USSD request changed to regular call</string>
    <string name="stk_cc_ussd_to_ss">USSD request changed to SS request</string>
    <string name="stk_cc_ussd_to_ussd">Changed to new USSD request</string>
    <string name="stk_cc_ussd_to_dial_video">USSD request changed to video call</string>
    <string name="stk_cc_ss_to_dial">SS request changed to regular call</string>
    <string name="stk_cc_ss_to_dial_video">SS request changed to video call</string>
    <string name="stk_cc_ss_to_ussd">SS request changed to USSD request</string>
    <string name="stk_cc_ss_to_ss">Changed to new SS request</string>

    <!-- Content description of the work profile icon in the notification. -->
    <string name="notification_work_profile_content_description">Work profile</string>

    <!-- Content description of the alerting icon in the notification. [CHAR_LIMIT=NONE] -->
    <string name="notification_alerted_content_description">Alerted</string>

    <!-- Content description of the expand button icon in the notification when collaped.-->
    <string name="expand_button_content_description_collapsed">Expand</string>

    <!-- Content description of the expand button icon in the notification when expanded.-->
    <string name="expand_button_content_description_expanded">Collapse</string>

    <!-- Accessibility action description on the expand button. -->
    <string name="expand_action_accessibility">toggle expansion</string>

    <!-- User visible name for USB MIDI Peripheral port -->
    <string name="usb_midi_peripheral_name">Android USB Peripheral Port</string>
    <!-- Manufacturer name for USB MIDI Peripheral port -->
    <string name="usb_midi_peripheral_manufacturer_name">Android</string>
    <!-- Product name for USB MIDI Peripheral port -->
    <string name="usb_midi_peripheral_product_name">USB Peripheral Port</string>

    <!-- Floating toolbar strings -->
    <!-- Content description for the button that opens the floating toolbar overflow. [CHAR LIMIT=NONE] -->
    <string name="floating_toolbar_open_overflow_description">More options</string>
    <!-- Content description for the button that closes the floating toolbar overflow. [CHAR LIMIT=NONE] -->
    <string name="floating_toolbar_close_overflow_description">Close overflow</string>

    <!-- Free style window strings -->
    <!-- Accessibility text for the maximize window button -->
    <string name="maximize_button_text">Maximize</string>
    <!-- Accessibility text for the close window button -->
    <string name="close_button_text">Close</string>

    <!-- Ellipsis character to appear in notification templates, e.g.
         notification_template_material_inbox.xml.
         DO NOT TRANSLATE -->
    <string name="notification_inbox_ellipsis">\u2026</string>

    <!-- Tempalate for Notification.MessagingStyle to join a conversation name with the name of the sender of a message, to make a notification title [CHAR LIMIT=NONE] -->
    <string name="notification_messaging_title_template"><xliff:g id="conversation_title" example="Tasty Treat Team">%1$s</xliff:g>: <xliff:g id="sender_name" example="Adrian Baker">%2$s</xliff:g></string>


    <!-- Label describing the number of selected items [CHAR LIMIT=48] -->
    <plurals name="selected_count">
        <item quantity="one"><xliff:g id="count" example="1">%1$d</xliff:g> selected</item>
        <item quantity="other"><xliff:g id="count" example="3">%1$d</xliff:g> selected</item>
    </plurals>

    <string name="default_notification_channel_label">Uncategorized</string>

    <string name="importance_from_user">You set the importance of these notifications.</string>
    <string name="importance_from_person">This is important because of the people involved.</string>

    <!-- Message to user that app trying to create user for an account that already exists. [CHAR LIMIT=none] -->
    <string name="user_creation_account_exists">Allow <xliff:g id="app" example="Gmail">%1$s</xliff:g> to create a new User with <xliff:g id="account" example="foobar@gmail.com">%2$s</xliff:g> (a User with this account already exists) ?</string>
    <!-- Message to user that app is trying to create user for a specified account. [CHAR LIMIT=none] -->
    <string name="user_creation_adding">Allow <xliff:g id="app" example="Gmail">%1$s</xliff:g> to create a new User with <xliff:g id="account" example="foobar@gmail.com">%2$s</xliff:g> ?</string>

    <!-- Locale picker strings -->

    <!-- Title for the language selection screen [CHAR LIMIT=25] -->
    <string name="language_selection_title">Add a language</string>
    <!-- Title for the region selection screen [CHAR LIMIT=25] -->
    <string name="country_selection_title">Region preference</string>
    <!-- Hint text in a search edit box (used to filter long language / country lists) [CHAR LIMIT=25] -->
    <string name="search_language_hint">Type language name</string>

    <!-- List section subheader for the language picker, containing a list of suggested languages determined by the default region [CHAR LIMIT=30] -->
    <string name="language_picker_section_suggested">Suggested</string>
    <!-- List section subheader for the language picker, containing a list of all languages available [CHAR LIMIT=30] -->
    <string name="language_picker_section_all">All languages</string>
    <!-- List section subheader for the region picker, containing a list of all regions supported for the selected language.
    Warning: this is a more 'neutral' term for 'country', not for the sub-divisions of a country. [CHAR LIMIT=30] -->
    <string name="region_picker_section_all">All regions</string>

    <!-- Menu item in the locale menu  [CHAR LIMIT=30] -->
    <string name="locale_search_menu">Search</string>

    <!-- Title of the dialog that is shown when the user tries to launch a suspended application [CHAR LIMIT=50] -->
    <string name="app_suspended_title">App isn\u2019t available</string>
    <!-- Default message shown in the dialog that is shown when the user tries to launch a suspended application [CHAR LIMIT=NONE] -->
    <string name="app_suspended_default_message">
        <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> isn\u2019t available right now. This is managed by <xliff:g id="app_name" example="Settings">%2$s</xliff:g>.
    </string>
    <!-- Title of the button to show users more details about why the app has been suspended [CHAR LIMIT=50]-->
    <string name="app_suspended_more_details">Learn more</string>
    <!-- Title of the button to unsuspend a suspended app immediately [CHAR LIMIT=50]-->
    <string name="app_suspended_unsuspend_message">Unpause app</string>

    <!-- Title of a dialog. The string is asking if the user wants to turn on their work profile, which contains work apps that are managed by their employer. "Work" is an adjective. [CHAR LIMIT=30] -->
    <string name="work_mode_off_title">Turn on work profile?</string>
    <!-- Text in a dialog. This string describes what will happen if a user decides to turn on their work profile. "Work profile" is used as an adjective. [CHAR LIMIT=NONE] -->
    <string name="work_mode_off_message">Your work apps, notifications, data, and other work profile features will be turned on</string>
    <!-- Title for button to turn on work profile. [CHAR LIMIT=NONE] -->
    <string name="work_mode_turn_on">Turn on</string>

    <!-- Title of the dialog that is shown when the user tries to launch a blocked application [CHAR LIMIT=50] -->
    <string name="app_blocked_title">App is not available</string>
    <!-- Default message shown in the dialog that is shown when the user tries to launch a blocked application [CHAR LIMIT=NONE] -->
    <string name="app_blocked_message">
        <xliff:g id="app_name" example="Gmail">%1$s</xliff:g> is not available right now.
    </string>

    <!-- Message displayed in dialog when app is too old to run on this verison of android. [CHAR LIMIT=NONE] -->
    <string name="deprecated_target_sdk_message">This app was built for an older version of Android and may not work properly. Try checking for updates, or contact the developer.</string>
    <!-- Title for button to see application detail in app store which it came from - it may allow user to update to newer version. [CHAR LIMIT=50] -->
    <string name="deprecated_target_sdk_app_store">Check for update</string>

    <!-- Notification title shown when new SMS/MMS is received while the device is locked [CHAR LIMIT=NONE] -->
    <string name="new_sms_notification_title">You have new messages</string>
    <!-- Notification content shown when new SMS/MMS is received while the device is locked [CHAR LIMIT=NONE] -->
    <string name="new_sms_notification_content">Open SMS app to view</string>

    <!-- Notification title shown when user profile is credential encrypted and requires the user to unlock before some features are usable [CHAR LIMIT=36] -->
    <string name="profile_encrypted_title">Some functionality may be limited</string>
    <!-- Notification detail shown when work profile is credential encrypted and requires the user to unlock before some features are usable [CHAR LIMIT=30] -->
    <string name="profile_encrypted_detail">Work profile locked</string>
    <!-- Notification message shown when work profile is credential encrypted and requires the user to unlock before some features are usable [CHAR LIMIT=30] -->
    <string name="profile_encrypted_message">Tap to unlock work profile</string>

    <!-- Title of notification shown after a MTP device is connected to Android. -->
    <string name="usb_mtp_launch_notification_title">Connected to <xliff:g id="product_name">%1$s</xliff:g></string>
    <!-- Description of notification shown after a MTP device is connected to Android. -->
    <string name="usb_mtp_launch_notification_description">Tap to view files</string>

    <!-- Resolver target actions strings -->
    <!-- Pin this app to the top of the Sharesheet app list. [CHAR LIMIT=60]-->
    <string name="pin_target">Pin</string>
    <!-- Pin this app to the top of the Sharesheet app list. [CHAR LIMIT=60]-->
    <string name="pin_specific_target">Pin <xliff:g id="label" example="Tweet">%1$s</xliff:g></string>
    <!-- Un-pin this app in the Sharesheet, so that it is sorted normally. [CHAR LIMIT=60]-->
    <string name="unpin_target">Unpin </string>
    <!-- Un-pin this app in the Sharesheet, so that it is sorted normally. [CHAR LIMIT=60]-->
    <string name="unpin_specific_target">Unpin <xliff:g id="label" example="Tweet">%1$s</xliff:g></string>
    <!-- View application info for a target. -->
    <string name="app_info">App info</string>

    <!-- The representation of a time duration when negative. An example is -1:14. This can be used with a countdown timer for example.-->
    <string name="negative_duration">\u2212<xliff:g id="time" example="1:14">%1$s</xliff:g></string>

    <!-- Text of dialog shown when starting a demo user for the first time [CHAR LIMIT=40] -->
    <string name="demo_starting_message">Starting demo\u2026</string>
    <!-- Text of dialog shown when starting a new demo user in retail demo mode [CHAR LIMIT=40] -->
    <string name="demo_restarting_message">Resetting device\u2026</string>

    <!-- Accessibilty string added to a widget that has been suspended [CHAR LIMIT=20] -->
    <string name="suspended_widget_accessibility">Disabled <xliff:g id="label" example="Calendar">%1$s</xliff:g></string>

    <!-- Label used by Telephony code, assigned as the display name for conference calls [CHAR LIMIT=60] -->
    <string name="conference_call">Conference Call</string>

    <!-- Window title for a tooltip [CHAR LIMIT=NONE] -->
    <string name="tooltip_popup_title">Tooltip</string>

    <!-- Category title for apps which are primarily games. [CHAR LIMIT=32] -->
    <string name="app_category_game">Games</string>
    <!-- Category title for apps which primarily work with audio or music, such as music players. [CHAR LIMIT=32] -->
    <string name="app_category_audio">Music &amp; Audio</string>
    <!-- Category title for apps which primarily work with video or movies, such as streaming video apps. [CHAR LIMIT=32] -->
    <string name="app_category_video">Movies &amp; Video</string>
    <!-- Category title for apps which primarily work with images or photos, such as camera or gallery apps. [CHAR LIMIT=32] -->
    <string name="app_category_image">Photos &amp; Images</string>
    <!-- Category title for apps which are primarily social apps, such as messaging, communication, email, or social network apps. [CHAR LIMIT=32] -->
    <string name="app_category_social">Social &amp; Communication</string>
    <!-- Category title for apps which are primarily news apps, such as newspapers, magazines, or sports apps. [CHAR LIMIT=32] -->
    <string name="app_category_news">News &amp; Magazines</string>
    <!-- Category title for apps which are primarily maps apps, such as navigation apps. [CHAR LIMIT=32] -->
    <string name="app_category_maps">Maps &amp; Navigation</string>
    <!-- Category title for apps which are primarily productivity apps, such as cloud storage or workplace apps. [CHAR LIMIT=32] -->
    <string name="app_category_productivity">Productivity</string>

    <!-- Channel name for DeviceStorageMonitor notifications -->
    <string name="device_storage_monitor_notification_channel">Device storage</string>
    <!-- Channel name for UsbDeviceManager adb debugging notifications -->
    <string name="adb_debugging_notification_channel_tv">USB debugging</string>

    <!-- Label for the time picker hour input field. [CHAR LIMIT=20] -->
    <string name="time_picker_hour_label">hour</string>
    <!-- Label for the time picker minute input field. [CHAR LIMIT=20] -->
    <string name="time_picker_minute_label">minute</string>
    <!-- The title for the time picker dialog. [CHAR LIMIT=NONE] -->
    <string name="time_picker_header_text">Set time</string>
    <!-- Error shown to the user if they type in invalid hour or minute in the time picker. [CHAR LIMIT=NONE] -->
    <string name="time_picker_input_error">Enter a valid time</string>
    <!-- Label shown to the user in time picker to let them know that should type in time. [CHAR LIMIT=NONE] -->
    <string name="time_picker_prompt_label">Type in time</string>
    <!-- Accessibility string used for describing the button in time picker that changes the dialog to text input mode. [CHAR LIMIT=NONE] -->
    <string name="time_picker_text_input_mode_description">Switch to text input mode for the time input.</string>
    <!-- Accessibility string used for describing the button in time picker that changes the dialog to circular clock mode. [CHAR LIMIT=NONE] -->
    <string name="time_picker_radial_mode_description">Switch to clock mode for the time input.</string>

    <!-- Accessibility title for the autofill dialog used to select a list of options to autofill an activity. [CHAR LIMIT=NONE] -->
    <string name="autofill_picker_accessibility_title">Autofill options</string>

    <!-- Accessibility title for the autofill dialog used to ask user to save the information on the screen by sending it to an Autofill Service. [CHAR LIMIT=NONE] -->
    <string name="autofill_save_accessibility_title">Save for Autofill</string>

    <!-- Toast message shown when user manually request autofill but service could not figure out the data that would autofill the screen contents. [CHAR LIMIT=NONE] -->
    <string name="autofill_error_cannot_autofill">Contents can\u2019t be autofilled</string>

    <!-- Accessibility string to announce there are no autofill suggestions in the autofill picker. [CHAR LIMIT=NONE] -->
    <string name="autofill_picker_no_suggestions">No autofill suggestions</string>

    <!-- Accessibility string to announce there are some autofill suggestions in the autofill picker. [CHAR LIMIT=NONE] -->
    <plurals name="autofill_picker_some_suggestions">
        <item quantity="one">One autofill suggestion</item>
        <item quantity="other"><xliff:g id="count" example="Two">%1$s</xliff:g> autofill suggestions</item>
    </plurals>

    <!-- Title for the autofill save dialog shown when the the contents of the activity can be saved
         by an autofill service, but the service does not know what the activity represents [CHAR LIMIT=NONE] -->
    <string name="autofill_save_title">Save to <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
    <!-- Title for the autofill save dialog shown when the the contents of the activity can be saved
         by an autofill service, and the service knows what the activity represents (for example, credit card info) [CHAR LIMIT=NONE] -->
    <string name="autofill_save_title_with_type">Save <xliff:g id="type" example="Credit Card">%1$s</xliff:g> to <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
    <!-- Title for the autofill save dialog shown when the the contents of the activity can be saved
         by an autofill service, and the service knows what the activity represents, and it represents 2 types of
         data (for example, password and credit card info) [CHAR LIMIT=NONE] -->
    <string name="autofill_save_title_with_2types">Save <xliff:g id="type" example="Password">%1$s</xliff:g> and <xliff:g id="type" example="Credit Card">%2$s</xliff:g> to <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
    <!-- Title for the autofill save dialog shown when the the contents of the activity can be saved
         by an autofill service, and the service knows what the activity represents, and it represents 3 types of
         data (for example, username, password and credit card info) [CHAR LIMIT=NONE] -->
    <string name="autofill_save_title_with_3types">Save <xliff:g id="type" example="Username">%1$s</xliff:g>, <xliff:g id="type" example="Password">%2$s</xliff:g>, and <xliff:g id="type" example="Credit Card">%3$s</xliff:g> to <b><xliff:g id="label" example="MyPass">%4$s</xliff:g></b>?</string>

    <!-- Title for the autofill update dialog shown when the the contents of the activity can be updated
         in an autofill service, but the service does not know what the activity represents [CHAR LIMIT=NONE] -->
    <string name="autofill_update_title">Update in <b><xliff:g id="label" example="MyPass">%1$s</xliff:g></b>?</string>
    <!-- Title for the autofill update dialog shown when the the contents of the activity can be updated
         in an autofill service, and the service knows what the activity represents (for example, credit card info) [CHAR LIMIT=NONE] -->
    <string name="autofill_update_title_with_type">Update <xliff:g id="type" example="Credit Card">%1$s</xliff:g> in <b><xliff:g id="label" example="MyPass">%2$s</xliff:g></b>?</string>
    <!-- Title for the autofill update dialog shown when the the contents of the activity can be updated
         in an autofill service, and the service knows what the activity represents, and it represents 2 types of
         data (for example, password and credit card info) [CHAR LIMIT=NONE] -->
    <string name="autofill_update_title_with_2types">Update <xliff:g id="type" example="Password">%1$s</xliff:g> and <xliff:g id="type" example="Credit Card">%2$s</xliff:g> in <b><xliff:g id="label" example="MyPass">%3$s</xliff:g></b>?</string>
    <!-- Title for the autofill update dialog shown when the the contents of the activity can be updated
         in an autofill service, and the service knows what the activity represents, and it represents 3 types of
         data (for example, username, password and credit card info) [CHAR LIMIT=NONE] -->
    <string name="autofill_update_title_with_3types">Update these items in <b><xliff:g id="label" example="MyPass">%4$s</xliff:g></b>: <xliff:g id="type" example="Username">%1$s</xliff:g>, <xliff:g id="type" example="Password">%2$s</xliff:g>, and <xliff:g id="type" example="Credit Card">%3$s</xliff:g> ?</string>

    <!-- Label for the autofill save button [CHAR LIMIT=NONE] -->
    <string name="autofill_save_yes">Save</string>
    <!-- Label for the autofill cancel button [CHAR LIMIT=NONE] -->
    <string name="autofill_save_no">No thanks</string>
    <!-- Label for the autofill cancel button, saying not to save the filled data at this moment. [CHAR LIMIT=NONE] -->
    <string name="autofill_save_notnow">Not now</string>
    <!-- Label for the autofill reject button, saying never to save the filled data. [CHAR LIMIT=NONE] -->
    <string name="autofill_save_never">Never</string>
    <!-- Label for the autofill update button [CHAR LIMIT=NONE] -->
    <string name="autofill_update_yes">Update</string>
    <!-- Label for the autofill continue button [CHAR LIMIT=NONE] -->
    <string name="autofill_continue_yes">Continue</string>

    <!-- Label for the type of data being saved for autofill when it represent user credentials with a password [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_password">password</string>
    <!-- Label for the type of data being saved for autofill when it represent an address (street, city, etc.) [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_address">address</string>
    <!-- Label for the type of data being saved for autofill when it represents a credit card [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_credit_card">credit card</string>
    <!-- Label for the type of data being saved for autofill when it represents a debit card [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_debit_card">debit card</string>
    <!-- Label for the type of data being saved for autofill when it represents a payment card [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_payment_card">payment card</string>
    <!-- Label for the type of data being saved for autofill when it represents a card that does not a specified type or cannot identify what the type is for [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_generic_card">card</string>
    <!-- Label for the type of data being saved for autofill when it represents an username [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_username">username</string>
    <!-- Label for the type of data being saved for autofill when it represents an email address [CHAR LIMIT=NONE] -->
    <string name="autofill_save_type_email_address">email address</string>

    <!-- Primary ETWS (Earthquake and Tsunami Warning System) default message for earthquake -->
    <string name="etws_primary_default_message_earthquake">Stay calm and seek shelter nearby.</string>

    <!-- Primary ETWS (Earthquake and Tsunami Warning System) default message for Tsunami -->
    <string name="etws_primary_default_message_tsunami">Evacuate immediately from coastal regions and riverside areas to a safer place such as high ground.</string>

    <!-- Primary ETWS (Earthquake and Tsunami Warning System) default message for earthquake and Tsunami -->
    <string name="etws_primary_default_message_earthquake_and_tsunami">Stay calm and seek shelter nearby.</string>

    <!-- Primary ETWS (Earthquake and Tsunami Warning System) default message for test -->
    <string name="etws_primary_default_message_test">Emergency messages test</string>

    <!-- Content description for the reply button in the notification area [CHAR LIMIT=NONE]-->
    <string name="notification_reply_button_accessibility">Reply</string>

    <!-- Primary ETWS (Earthquake and Tsunami Warning System) default message for others -->
    <string name="etws_primary_default_message_others"></string>

    <!-- Title of notification when UE fails CS registration with MM reject cause code from network. -->
    <string name="mmcc_authentication_reject">SIM not allowed for voice</string>
    <string name="mmcc_imsi_unknown_in_hlr">SIM not provisioned for voice</string>
    <string name="mmcc_illegal_ms">SIM not allowed for voice</string>
    <string name="mmcc_illegal_me">Phone not allowed for voice</string>

    <!-- Title of notification when UE fails to register network with MM reject cause code when multiple SIMs are active. -->
    <string name="mmcc_authentication_reject_msim_template">SIM <xliff:g id="simNumber" example="1">%d</xliff:g> not allowed</string>
    <string name="mmcc_imsi_unknown_in_hlr_msim_template">SIM <xliff:g id="simNumber" example="1">%d</xliff:g> not provisioned</string>
    <string name="mmcc_illegal_ms_msim_template">SIM <xliff:g id="simNumber" example="1">%d</xliff:g> not allowed</string>
    <string name="mmcc_illegal_me_msim_template">SIM <xliff:g id="simNumber" example="1">%d</xliff:g> not allowed</string>

    <!-- Popup window default title to be read by a screen reader-->
    <string name="popup_window_default_title">Popup Window</string>

    <!-- Format string for indicating there is more content in a slice view -->
    <string name="slice_more_content">+ <xliff:g id="number" example="5">%1$d</xliff:g></string>

    <!--
    A toast message shown when an app shortcut that was restored from a previous device is clicked,
    but it cannot be started because the shortcut was created by a newer version of the app.
    -->
    <string name="shortcut_restored_on_lower_version">App version downgraded, or isn\u2019t compatible with this shortcut</string>

    <!--
    A toast message shown when an app shortcut that was restored from a previous device is clicked,
    but it cannot be started because the shortcut was created by an app that doesn't support backup
    and restore.
    -->
    <string name="shortcut_restore_not_supported">Couldn\u2019t restore shortcut because app doesn\u2019t support backup and restore</string>

    <!--
    A toast message shown when an app shortcut that was restored from a previous device is clicked,
    but it cannot be started because the shortcut was created by an app with a different signature.
    -->
    <string name="shortcut_restore_signature_mismatch">Couldn\u2019t restore shortcut because of app signature mismatch</string>

    <!--
    A toast message shown when an app shortcut that wasn't restored due to an unknown issue is clicked,
    -->
    <string name="shortcut_restore_unknown_issue">Couldn\u2019t restore shortcut</string>

    <!--
    A toast message shown when an app shortcut is disabled for an unknown rason.
    -->
    <string name="shortcut_disabled_reason_unknown">Shortcut is disabled</string>

    <!-- Label for the uninstall button on the harmful app warning dialog. [CHAR LIMIT=20] -->
    <string name="harmful_app_warning_uninstall">UNINSTALL</string>
    <!-- Label for the open anyway button on the harmful app warning dialog. [CHAR LIMIT=20] -->
    <string name="harmful_app_warning_open_anyway">OPEN ANYWAY</string>
    <!-- Title for the harmful app warning dialog. [CHAR LIMIT=40] -->
    <string name="harmful_app_warning_title">Harmful app detected</string>

    <!-- Text describing a permission request for one app to show another app's
         slices [CHAR LIMIT=NONE] -->
    <string name="slices_permission_request"><xliff:g id="app" example="Example App">%1$s</xliff:g> wants to show <xliff:g id="app_2" example="Other Example App">%2$s</xliff:g> slices</string>

    <!-- Notification action for editing a screenshot (drawing on it, cropping it, etc) -->
    <string name="screenshot_edit">Edit</string>

    <string name="volume_dialog_ringer_guidance_vibrate">Calls and notifications will vibrate</string>
    <string name="volume_dialog_ringer_guidance_silent">Calls and notifications will be muted</string>

    <!-- Title for the notification channel notifying user of settings system changes. [CHAR LIMIT=NONE] -->
    <string name="notification_channel_system_changes">System changes</string>
    <!-- Title for the notification channel notifying user of do not disturb system changes (i.e. Do Not Disturb has changed). [CHAR LIMIT=NONE] -->
    <string name="notification_channel_do_not_disturb">Do Not Disturb</string>
    <!-- Title of notification indicating do not disturb visual interruption settings have changed when upgrading to P -->
    <string name="zen_upgrade_notification_visd_title">New: Do Not Disturb is hiding notifications</string>
    <!-- Content of notification indicating users can tap on the notification to go to dnd behavior settings -->
    <string name="zen_upgrade_notification_visd_content">Tap to learn more and change.</string>
    <!-- Title of notification indicating do not disturb settings have changed when upgrading to P -->
    <string name="zen_upgrade_notification_title">Do Not Disturb has changed</string>
    <!-- Content of notification indicating users can tap on the notification to go to dnd behavior settings -->
    <string name="zen_upgrade_notification_content">Tap to check what\'s blocked.</string>

    <!-- Application name displayed in notifications [CHAR LIMIT=60] -->
    <string name="notification_app_name_system">System</string>
    <!-- Application name displayed in notifications [CHAR LIMIT=60] -->
    <string name="notification_app_name_settings">Settings</string>

    <!-- Active Permission - accessibility support -->
    <!-- Content description of the camera icon in the notification. [CHAR LIMIT=NONE] -->
    <string name="notification_appops_camera_active">Camera</string>
    <!-- Content description of the mic icon in the notification. [CHAR LIMIT=NONE] -->
    <string name="notification_appops_microphone_active">Microphone</string>
    <!-- Content description of the overlay icon in the notification. [CHAR LIMIT=NONE] -->
    <string name="notification_appops_overlay_active">displaying over other apps on your screen</string>

    <!-- Dynamic mode battery saver strings -->
    <!-- The user visible name of the notification channel for the routine mode battery saver fyi notification [CHAR_LIMIT=80]-->
    <string name="dynamic_mode_notification_channel_name">Routine Mode info notification</string>
    <!-- Title of notification letting users know why battery saver was turned on automatically [CHAR_LIMIT=NONE]-->
    <string name="dynamic_mode_notification_title">Battery may run out before usual charge</string>
    <!-- Summary of notification letting users know why battery saver was turned on automatically [CHAR_LIMIT=NONE]-->
    <string name="dynamic_mode_notification_summary">Battery Saver activated to extend battery life</string>

    <!-- Battery saver strings -->
    <!-- The user visible name of the notification channel for battery saver notifications [CHAR_LIMIT=80] -->
    <string name="battery_saver_notification_channel_name">Battery Saver</string>
    <!-- Title of notification letting users know that battery saver is now off [CHAR_LIMIT=80] -->
    <string name="battery_saver_off_notification_title">Battery Saver turned off</string>
    <!-- Title of notification letting users know the battery level at the time the notification was posted [CHAR_LIMIT=80] -->
    <string name="battery_saver_charged_notification_summary" product="default">Phone has enough charge. Features no longer restricted.</string>
    <!-- Title of notification letting users know the battery level at the time the notification was posted [CHAR_LIMIT=80] -->
    <string name="battery_saver_charged_notification_summary" product="tablet">Tablet has enough charge. Features no longer restricted.</string>
    <!-- Title of notification letting users know the battery level at the time the notification was posted [CHAR_LIMIT=80] -->
    <string name="battery_saver_charged_notification_summary" product="device">Device has enough charge. Features no longer restricted.</string>

    <!-- Description of media type: folder or directory that contains additional files. [CHAR LIMIT=32] -->
    <string name="mime_type_folder">Folder</string>
    <!-- Description of media type: application file, such as APK. [CHAR LIMIT=32] -->
    <string name="mime_type_apk">Android application</string>

    <!-- Description of media type: generic file with unknown contents. [CHAR LIMIT=32] -->
    <string name="mime_type_generic">File</string>
    <!-- Description of media type: generic file with unknown contents. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_generic_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> file</string>

    <!-- Description of media type: audio file, such as MP3 or WAV. [CHAR LIMIT=32] -->
    <string name="mime_type_audio">Audio</string>
    <!-- Description of media type: audio file, such as MP3 or WAV. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_audio_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> audio</string>

    <!-- Description of media type: video file, such as MP4 or MKV. [CHAR LIMIT=32] -->
    <string name="mime_type_video">Video</string>
    <!-- Description of media type: video file, such as MP4 or MKV. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_video_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> video</string>

    <!-- Description of media type: image file, such as JPG or PNG. [CHAR LIMIT=32] -->
    <string name="mime_type_image">Image</string>
    <!-- Description of media type: image file, such as JPG or PNG. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_image_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> image</string>

    <!-- Description of media type: archive file, such as ZIP or TAR. [CHAR LIMIT=32] -->
    <string name="mime_type_compressed">Archive</string>
    <!-- Description of media type: archive file, such as ZIP or TAR. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_compressed_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> archive</string>

    <!-- Description of media type: document file, such as DOC or PDF. [CHAR LIMIT=32] -->
    <string name="mime_type_document">Document</string>
    <!-- Description of media type: document file, such as DOC or PDF. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_document_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> document</string>

    <!-- Description of media type: spreadsheet file, such as XLS. [CHAR LIMIT=32] -->
    <string name="mime_type_spreadsheet">Spreadsheet</string>
    <!-- Description of media type: spreadsheet file, such as XLS. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_spreadsheet_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> spreadsheet</string>

    <!-- Description of media type: presentation file, such as PPT. [CHAR LIMIT=32] -->
    <string name="mime_type_presentation">Presentation</string>
    <!-- Description of media type: presentation file, such as PPT. The 'extension' variable is the file name extension. [CHAR LIMIT=32] -->
    <string name="mime_type_presentation_ext"><xliff:g id="extension" example="PDF">%1$s</xliff:g> presentation</string>

    <!-- Strings for Bluetooth service -->
    <!-- toast message informing user that Bluetooth stays on after airplane mode is turned on. [CHAR LIMIT=NONE] -->
    <string name="bluetooth_airplane_mode_toast">Bluetooth will stay on during airplane mode</string>

    <!-- Strings for car -->
    <!-- String displayed when loading a user in the car [CHAR LIMIT=30] -->
    <string name="car_loading_profile">Loading</string>

    <plurals name="file_count">
        <item quantity="one"><xliff:g id="file_name">%s</xliff:g> + <xliff:g id="count">%d</xliff:g> file</item>
        <item quantity="other"><xliff:g id="file_name">%s</xliff:g> + <xliff:g id="count">%d</xliff:g> files</item>
    </plurals>

    <!-- ChooserActivity - No direct share targets are available. [CHAR LIMIT=NONE] -->
    <string name="chooser_no_direct_share_targets">Direct share not available</string>

    <!-- ChooserActivity - Alphabetically sorted apps list label. [CHAR LIMIT=NONE] -->
    <string name="chooser_all_apps_button_label">Apps list</string>

    <!-- Prompt for the USB device resolver dialog with warning text for USB device dialogs.  [CHAR LIMIT=200] -->
    <string name="usb_device_resolve_prompt_warn">This app has not been granted record permission but could capture audio through this USB device.</string>

    <!-- Accessibility system actions -->
    <!-- Label for Home action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_home_label">Home</string>
    <!-- Label for Back action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_back_label">Back</string>
    <!-- Label for showing recent apps action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_recents_label">Recent Apps</string>
    <!-- Label for opening notifications action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_notifications_label">Notifications</string>
    <!-- Label for opening quick settings action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_quick_settings_label">Quick Settings</string>
    <!-- Label for opening power dialog action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_power_dialog_label">Power Dialog</string>
    <!-- Label for toggle split screen action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_toggle_split_screen_label">Toggle Split Screen</string>
    <!-- Label for lock screen action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_lock_screen_label">Lock Screen</string>
    <!-- Label for taking screenshot action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_screenshot_label">Screenshot</string>
    <!-- Label for showing accessibility menu action [CHAR LIMIT=NONE] -->
    <string name="accessibility_system_action_accessibility_menu_label">Accessibility Menu</string>
    <!-- Accessibility description of caption view -->
    <string name="accessibility_freeform_caption">Caption bar of <xliff:g id="app_name">%1$s</xliff:g>.</string>

    <!-- Text to tell the user that a package has been forced by themselves in the RESTRICTED bucket. [CHAR LIMIT=NONE] -->
    <string name="as_app_forced_to_restricted_bucket">
        <xliff:g id="package_name" example="com.android.example">%1$s</xliff:g> has been put into the RESTRICTED bucket</string>

    <!-- ResolverActivity - profile tabs -->
    <!-- Label for the perosnal tab of the share sheet and intent resolver [CHAR LIMIT=NONE] -->
    <string name="resolver_personal_tab">Personal</string>
    <!-- Label for the work tab of the share sheet and intent resolver [CHAR LIMIT=NONE] -->
    <string name="resolver_work_tab">Work</string>
    <!-- Label to indicate that the user cannot share with work apps [CHAR LIMIT=NONE] -->
    <string name="resolver_cant_share_with_work_apps">Can\u2019t share with work apps</string>
    <!-- Label to indicate that the user cannot share with personal apps [CHAR LIMIT=NONE] -->
    <string name="resolver_cant_share_with_personal_apps">Can\u2019t share with personal apps</string>
    <!-- Label to explain to the user that sharing between personal and work apps is not enabled by the IT admin [CHAR LIMIT=NONE] -->
    <string name="resolver_cant_share_cross_profile_explanation">Your IT admin blocked sharing between personal and work apps</string>
    <!-- Label to indicate that the user has to turn on work apps in order to access work data [CHAR LIMIT=NONE] -->
    <string name="resolver_turn_on_work_apps">Turn on work apps</string>
    <!-- Label to explain that the user has to turn on work apps in order to access work data [CHAR LIMIT=NONE] -->
    <string name="resolver_turn_on_work_apps_explanation">Turn on work apps to access work apps &amp; contacts</string>
    <!-- Label to indicate that no apps are resolved [CHAR LIMIT=NONE] -->
    <string name="resolver_no_apps_available">No apps available</string>
    <!-- Label to explain that no apps are resolved [CHAR LIMIT=NONE] -->
    <string name="resolver_no_apps_available_explanation">We couldn\u2019t find any apps</string>
    <!-- Button which switches on the disabled work profile [CHAR LIMIT=NONE] -->
    <string name="resolver_switch_on_work">Switch on work</string>
</resources>
