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

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

    <!-- Used to replace a range of characters in text that is too wide
         for the space allocated to it. -->
    <string name="ellipsis">\u2026</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 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 is not correct.</string>
    <!-- Displayed when a SIM PUK password is entered incorrectly. -->
    <string name="badPuk">The PUK you typed is not correct.</string>
    <!-- Displayed when SIM PIN passwords are entered inconsistently. -->
    <string name="mismatchPin">The PINs you entered do not 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 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 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 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>

    <!-- 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">The caller ID setting cannot be changed.</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>

    <!--
        {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 web request was successful. -->
    <string name="httpErrorOk">OK</string>
    <!-- Displayed when a web request failed because we don't know the exact reason. -->
    <string name="httpError">The Web page contains an error.</string>
    <!-- Displayed when a web request failed because the URL could not be found. -->
    <string name="httpErrorLookup">The URL could not be found.</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 is not supported.</string>
    <!-- Displayed when a web request failed because the authentication failed. -->
    <string name="httpErrorAuth">Authentication was unsuccessful.</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">The connection to the server was unsuccessful.</string>
    <!-- Displayed when a web request failed because there was an input or output error. -->
    <string name="httpErrorIO">The server failed to communicate. 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 is not supported.</string>
    <!-- Displayed when a web request failed because the a secure connection couldn't be made to the server.-->
    <string name="httpErrorFailedSslHandshake">A secure connection could not be established.</string>
    <!-- Displayed when a web request failed because the URL isn't in a valid form. -->
    <string name="httpErrorBadUrl">The page could not be opened because the URL is invalid.</string>
    <!-- Displayed when a request failed because we failed to open the file. -->
    <string name="httpErrorFile">The file could not be accessed.</string>
    <!-- Displayed when a request failed because the file wasn't found. -->
    <string name="httpErrorFileNotFound">The requested file was not found.</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>

    <!-- 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. -->
    <string name="contentServiceSyncNotificationTitle">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. -->
    <string name="contentServiceTooManyDeletesNotificationDesc">Too many <xliff:g id="content_type">%s</xliff:g> deletes.</string>

    <!-- If MMS discovers there isn't much space left on the device, it will show a toast with this message. -->
    <string name="low_memory">Phone storage is full! Delete some files to free space.</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">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>

    <!-- 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">Your phone will shut down.</string>

    <!-- Recent Tasks dialog -->
    <string name="no_recent_tasks">No recent applications.</string>

    <!-- Title of the Global Actions Dialog -->
    <string name="global_actions">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 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>

    <!-- Displayed to the user to tell them that they have started up the phone in "safe mode" -->
    <string name="safeMode">Safe mode</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_costMoney">Services that cost you money</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_costMoney">Allow applications to do things
        that can cost you money.</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_messages">Your messages</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_messages">Read and write your SMS,
        e-mail, and other 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_personalInfo">Your personal information</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_personalInfo">Direct access to your contacts
        and calendar stored on the phone.</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">Your 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">Monitor your physical 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_network">Network communication</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_network">Allow applications to access
        various network features.</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_accounts">Your Google accounts</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_accounts">Access the available Google accounts.</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_hardwareControls">Hardware controls</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_hardwareControls">Direct access to hardware on
        the handset.</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_phoneCalls">Phone calls</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_phoneCalls">Monitor, record, and process
        phone calls.</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_systemTools">System tools</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_systemTools">Lower-level access and control
        of the system.</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_developmentTools">Development tools</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_developmentTools">Features only needed for
        application developers.</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 application 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_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 application to
        expand or collapse 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_processOutgoingCalls">intercept 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 application to
        process outgoing calls and change the number to be dialed.  Malicious
        applications may monitor, redirect, or prevent outgoing 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_receiveSms">receive 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 application to receive
      and process SMS messages. Malicious applications may monitor
      your messages or delete them 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 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 application to receive
      and process MMS messages. Malicious applications may monitor
      your messages or delete them 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_sendSms">send 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 application to send SMS
      messages. Malicious applications 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 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">Allows application to read
      SMS messages stored on your phone or SIM card. Malicious applications
      may read your confidential messages.</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_writeSms">edit 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_writeSms">Allows application to write
      to SMS messages stored on your phone or SIM card. Malicious applications
      may delete your messages.</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 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 application to receive
      and process WAP messages. Malicious applications may monitor
      your messages or delete them 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 applications</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 application to retrieve
        information about currently and recently running tasks. May allow
        malicious applications to discover private information about other applications.</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 applications</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 an application to move
        tasks to the foreground and background. Malicious applications can force
        themselves to the front without your control.</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_setDebugApp">enable application debugging</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_setDebugApp">Allows an application to turn
        on debugging for another application. Malicious applications can use this
        to kill other applications.</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_changeConfiguration">change your UI 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_changeConfiguration">Allows an application to
        change the current configuration, such as the locale or overall font
        size.</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_restartPackages">restart other applications</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_restartPackages">Allows an application to
        forcibly restart other applications.</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_setProcessForeground">keep from being stopped</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_setProcessForeground">Allows an application to make
        any process run in the foreground, so it can\'t be killed.
        Should never be needed for normal applications.</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_forceBack">force application to close</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_forceBack">Allows an application to force any
        activity that is in the foreground to close and go back.
        Should never be needed for normal applications.</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_dump">retrieve system internal state</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_dump">Allows application to retrieve
        internal state of the system. Malicious applications may retrieve
        a wide variety of private and secure information that they should
        never normally need.</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_addSystemService">publish low-level 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_addSystemService">Allows application to publish
        its own low-level system services. Malicious applications may hijack
        the system, and steal or corrupt any data on it.</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_runSetActivityWatcher">monitor and control all application launching</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_runSetActivityWatcher">Allows an application to
        monitor and control how the system launches activities.
        Malicious applications may completely compromise the system. This
        permission is only needed for development, never for normal
        phone 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_broadcastPackageRemoved">send package removed 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_broadcastPackageRemoved">Allows an application to
        broadcast a notification that an application package has been removed.
        Malicious applications may use this to kill any other running
        application.</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_broadcastSmsReceived">send SMS-received 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_broadcastSmsReceived">Allows an application to
        broadcast a notification that an SMS message has been received.
        Malicious applications may use this to forge incoming SMS messages.</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_broadcastWapPush">send WAP-PUSH-received 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_broadcastWapPush">Allows an application to
        broadcast a notification that a WAP PUSH message has been received.
        Malicious applications may use this to forge MMS message receipt or to
        silently replace the content of any web page with malicious variants.</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_setProcessLimit">limit number of running processes</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_setProcessLimit">Allows an application
        to control the maximum number of processes that will run. Never
        needed for normal applications.</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_setAlwaysFinish">make all background applications close</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_setAlwaysFinish">Allows an application
        to control whether activities are always finished as soon as they
        go to the background. Never needed for normal applications.</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_fotaUpdate">automatically install system updates</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_fotaUpdate">Allows an application to receive
        notifications about pending system updates and trigger their
        installation. Malicious applications may use this to corrupt the system
        with unauthorized updates, or generally interfere with the update
        process.</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_batteryStats">modify battery 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_batteryStats">Allows the modification of
        collected battery statistics. Not for use by normal applications.</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_internalSystemWindow">display unauthorized windows</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_internalSystemWindow">Allows the creation of
        windows that are intended to be used by the internal system
        user interface. Not for use by normal applications.</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">display system-level alerts</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">Allows an application to
        show system alert windows. Malicious applications can take over the
        entire screen of 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_setAnimationScale">modify global animation speed</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_setAnimationScale">Allows an application to change
        the global animation speed (faster or slower animations) 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_manageAppTokens">manage application tokens</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_manageAppTokens">Allows applications to
        create and manage their own tokens, bypassing their normal
        Z-ordering. Should never be needed for normal applications.</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_injectEvents">press keys and control buttons</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_injectEvents">Allows an application to deliver
        its own input events (key presses, etc.) to other applications. Malicious
        applications can use this to take over 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_readInputState">record what you type and actions you take</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_readInputState">Allows applications to watch the
        keys you press even when interacting with another application (such
        as entering a password). Should never be needed for normal applications.</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_bindInputMethod">bind to an input method</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_bindInputMethod">Allows the holder to bind to the top-level
        interface of an input method. Should never be needed for normal applications.</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_setOrientation">change screen orientation</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_setOrientation">Allows an application to change
        the rotation of the screen at any time. Should never be needed for
        normal applications.</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_signalPersistentProcesses">send Linux signals to applications</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_signalPersistentProcesses">Allows application to request that the
        supplied signal be sent to all persistent processes.</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 application 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">Allows an application to make
        parts of itself persistent, so the system can\'t use it for other
        applications.</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_deletePackages">delete applications</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_deletePackages">Allows an application to delete
        Android packages. Malicious applications can use this to delete important applications.</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_clearAppUserData">delete other applications\' 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_clearAppUserData">Allows an application to clear user 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_deleteCacheFiles">delete other applications\' caches</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_deleteCacheFiles">Allows an application to delete
        cache files.</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 application 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 an application 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_installPackages">directly install applications</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_installPackages">Allows an application to install new or updated
        Android packages. Malicious applications can use this to add new applications with arbitrarily
        powerful permissions.</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_clearAppCache">delete all application cache 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_clearAppCache">Allows an application to free phone storage
        by deleting files in application cache directory. Access is very
        restricted usually to system process.</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_readLogs">read system log files</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_readLogs">Allows an application to read from the
        system\'s various log files.  This allows it to discover general
        information about what you are doing with the phone, but they should
        not contain any personal or private information.</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_diagnostic">read/write to resources owned by diag</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_diagnostic">Allows an application to read and write to
    any resource owned by the diag group; for example, files in /dev. This could
    potentially affect system stability and security. This should be ONLY be used
    for hardware-specific diagnostics by the manufacturer or operator.</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_changeComponentState">enable or disable application components</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_changeComponentState">Allows an application to change whether a
        component of another application is enabled or not. Malicious applications can use this
        to disable important phone capabilities. Care must be used with permission, as it is
        possible to get application components into an unusable, inconsistent, or unstable 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_setPreferredApplications">set preferred applications</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_setPreferredApplications">Allows an application to
        modify your preferred applications. This can allow malicious applications
        to silently change the applications that are run, spoofing your
        existing applications to collect private data from 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_writeSettings">modify global 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 an application to modify the
        system\'s settings data. Malicious applications can corrupt your system\'s
        configuration.</string>

    <string name="permlab_writeSecureSettings">modify secure system settings</string>
    <string name="permdesc_writeSecureSettings">Allows an application to modify the
        system's secure settings data. Not for use by normal applications.</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_writeGservices">modify the Google services map</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_writeGservices">Allows an application to modify the
        Google services map.  Not for use by normal applications.</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">automatically start at boot</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">Allows an application 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
        application 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">Allows an application to send
        sticky broadcasts, which remain after the broadcast ends.
        Malicious applications can 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 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_readContacts">Allows an application to read all
        of the contact (address) data stored on your phone. Malicious applications
        can use this to send your data to other people.</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">write 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">Allows an application to modify the
        contact (address) data stored on your phone. Malicious
        applications can use this to erase or modify your 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_writeOwnerData">write owner 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_writeOwnerData">Allows an application to modify the
        phone owner data stored on your phone. Malicious
        applications can use this to erase or modify owner 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_readOwnerData">read owner 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_readOwnerData">Allows an application read the
        phone owner data stored on your phone. Malicious
        applications can use this to read phone owner 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_readCalendar">read 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">Allows an application to read all
        of the calendar events stored on your phone. Malicious applications
        can use this to send your calendar events to other people.</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">write 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_writeCalendar">Allows an application to modify the
        calendar events stored on your phone. Malicious
        applications can use this to erase or modify 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_accessMockLocation">mock location sources for testing</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_accessMockLocation">Create mock location sources for testing.
        Malicious applications can use this to override the location and/or status returned by real
        location sources such as GPS or Network providers.</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_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">Access extra location provider commands.
        Malicious applications could use this 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">fine (GPS) location</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">Access fine location sources such as the
        Global Positioning System on the phone, where available.
        Malicious applications can use this to determine where you are, and may
        consume additional battery power.</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">coarse (network-based) location</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">Access coarse location sources such as the cellular
        network database to determine an approximate phone location, where available. Malicious
        applications can use this to determine approximately where you are.</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_accessSurfaceFlinger">access SurfaceFlinger</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_accessSurfaceFlinger">Allows application to use
        SurfaceFlinger low-level features.</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_readFrameBuffer">read frame buffer</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_readFrameBuffer">Allows application to use
        read the content of the frame buffer.</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 application to modify
        global audio settings such as volume and routing.</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">Allows application to access
        the audio record path.</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</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">Allows application to take pictures
        with the camera. This allows the application at any time to collect
        images the camera is seeing.</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_brick">permanently disable phone</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_brick">Allows the application to
        disable the entire phone permanently. 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. -->
    <string name="permlab_reboot">force phone reboot</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_reboot">Allows the application to
        force the phone to reboot.</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_mount_unmount_filesystems">mount and unmount filesystems</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_mount_unmount_filesystems">Allows the application to mount and
        unmount filesystems for removable 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_vibrate">control 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_vibrate">Allows the application to control
        the vibrator.</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_flashlight">control flashlight</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_flashlight">Allows the application to control
        the flashlight.</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_hardware_test">test 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_hardware_test">Allows the application to control
        various peripherals for the purpose of hardware testing.</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 application to call
        phone numbers without your intervention. Malicious applications may
        cause unexpected calls on your phone bill. Note that this does not
        allow the application to call emergency numbers.</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_callPrivileged">directly call any 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_callPrivileged">Allows the application to call
        any phone number, including emergency numbers, without your intervention.
        Malicious applications may place unnecessary and illegal calls to emergency
        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_locationUpdates">control location update 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_locationUpdates">Allows enabling/disabling location
        update notifications from the radio.  Not for use by normal applications.</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_checkinProperties">access checkin properties</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_checkinProperties">Allows read/write access to
        properties uploaded by the checkin service.  Not for use by normal
        applications.</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_modifyPhoneState">modify phone state</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_modifyPhoneState">Allows the application to control the
        phone features of the device. An application with this permission can switch
        networks, turn the phone radio on and off and the like without ever notifying
        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_readPhoneState">read phone state</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 application to access the phone
        features of the device.  An application with this permission can determine the phone
        number of this phone, whether a call is active, the number that call is connected to
        and the like.</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">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">Allows an application 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_devicePower">power phone on or 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_devicePower">Allows the application to turn the
        phone on or off.</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_factoryTest">run in factory test 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_factoryTest">Run as a low-level manufacturer test,
        allowing complete access to the phone hardware. Only available
        when a phone is running in manufacturer test 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_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 application
        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">set wallpaper size hints</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 application
        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_masterClear">reset system to factory defaults</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_masterClear">Allows an application to completely
        reset the system to its factory settings, erasing all data,
        configuration, and installed applications.</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">Allows an application 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">discover known accounts</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">Allows an application to get
      the list of accounts known by 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_accessNetworkState">view network state</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 an application to view
      the state of all 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_createNetworkSockets">full Internet 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 an application to
      create network sockets.</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_writeApnSettings">write Access Point Name 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_writeApnSettings">Allows an application to modify the APN
        settings, such as Proxy and Port of any APN.</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 an application to change
      the state 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 state</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 an application to view
      the information about the state of Wi-Fi.</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">change Wi-Fi state</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 an application to connect
      to and disconnect from Wi-Fi access points, and to make changes to
      configured 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_bluetoothAdmin">bluetooth administration</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">Allows an application to configure
      the local Bluetooth phone, and to discover and pair with remote
      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_bluetooth">create Bluetooth 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_bluetooth">Allows an application to view
      configuration of the local Bluetooth 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_disableKeyguard">disable keylock</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 an application to disable
      the keylock and any associated password security. A legitimate example of
      this is the phone disabling the keylock when receiving an incoming phone call,
      then re-enabling 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. -->
    <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 an application to read the sync settings,
        such as whether sync is enabled for Contacts.</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">write 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_writeSyncSettings">Allows an application to modify the sync
        settings, such as whether sync is enabled for Contacts.</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 application to read the sync stats; e.g., the
        history of syncs that have occurred.</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 an application 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_subscribedFeedsWrite">write 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_subscribedFeedsWrite">Allows an application to modify
      your currently synced feeds. This could allow a malicious application to
      change your 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_readDictionary">read user defined dictionary</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_readDictionary">Allows an application to read any private
      words, names and phrases that the user may have stored in the user dictionary.</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_writeDictionary">write to user defined dictionary</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_writeDictionary">Allows an application to write new words into the
      user dictionary.</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>

    <!-- Instructions telling the user to enter their pin to unlock the keyguard.
         Displayed in one line in a large font.  -->
    <string name="keyguard_password_enter_pin_code">Enter PIN code</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. -->
    <string name="lockscreen_emergency_call">Emergency 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">Sorry, try again</string>

    <!-- When the lock screen is showing and the phone plugged in, show the current
         charge %.  -->
    <string name="lockscreen_plugged_in">Charging (<xliff:g id="number">%d%%</xliff:g>)</string>

    <!-- When the lock screen is showing and the battery is low, warn user to plug
         in the phone soon. -->
    <string name="lockscreen_low_battery">Connect your charger.</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">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">Please insert a SIM card.</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">Please 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 -->
    <string name="lockscreen_too_many_failed_attempts_dialog_message">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%d</xliff:g> times.
        \n\nPlease try again in <xliff:g id="number">%d</xliff:g> seconds.
    </string>

    <!-- For the unlock screen, Information 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">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%d</xliff:g> times.
       After <xliff:g id="number">%d</xliff:g> more unsuccessful attempts,
       you will be asked to unlock your phone using your Google sign-in.\n\n
       Please try again in <xliff:g id="number">%d</xliff:g> seconds.
    </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 -->
    <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,\nsign 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>

    <!-- A format string for 12-hour time of day (example: "12:30 PM"). -->
    <string name="status_bar_time_format">"<xliff:g id="hour" example="12">h</xliff:g>:<xliff:g id="minute" example="30">mm</xliff:g> <xliff:g id="ampm" example="AM">AA</xliff:g>"</string>

    <!-- A format string for 12-hour time of day, with lower-case "am" or "pm" (example: "12:30pm"). -->
    <string name="hour_minute_ampm">"<xliff:g id="hour" example="12">%-l</xliff:g>:<xliff:g id="minute" example="30">%M</xliff:g><xliff:g id="ampm" example="am">%P</xliff:g>"</string>

    <!-- A format string for 12-hour time of day, with capital "AM" or "PM" (example: "12:30PM"). -->
    <string name="hour_minute_cap_ampm">"<xliff:g id="hour" example="12">%-l</xliff:g>:<xliff:g id="minute" example="30">%M</xliff:g><xliff:g id="ampm" example="AM">%p</xliff:g>"</string>

    <!-- A format string for 12-hour time of day, just the hour, not the minute, with lower-case "am" or "pm" (example: "3pm"). -->
    <string name="hour_ampm">"<xliff:g id="hour" example="3">%-l</xliff:g><xliff:g id="ampm" example="pm">%P</xliff:g>"</string>

    <!-- A format string for 12-hour time of day, just the hour, not the minute, with capital "AM" or "PM" (example: "3PM"). -->
    <string name="hour_cap_ampm">"<xliff:g id="hour" example="3">%-l</xliff:g><xliff:g id="ampm" example="PM">%p</xliff:g>"</string>

    <!-- The text for the button in the notification window-shade that clears
         all of the currently visible notifications. -->
    <string name="status_bar_clear_all_button">Clear notifications</string>

    <!-- The label in the bar at the top of the status bar when there are no notifications
         showing. -->
    <string name="status_bar_no_notifications_title">No notifications</string>

    <!-- The label for the group of notifications for ongoing events in the opened version of
         the status bar.  An ongoing call is the prime example of this.  The MP3 music player
         might be another example.  -->
    <string name="status_bar_ongoing_events_title">Ongoing</string>

    <!-- The label for the group of notifications for recent events in the opened version of
         the status bar.  Recently received text messsages (SMS), emails, calendar alerts, etc. -->
    <string name="status_bar_latest_events_title">Notifications</string>

    <!-- The big percent text in the middle of the battery icon that appears when you plug in
         the charger. -->
    <string name="battery_status_text_percent_format"><xliff:g id="number" example="50">%d</xliff:g><xliff:g id="percent" example="%">%%</xliff:g></string>

    <!-- The big percent text in the middle of the battery icon that appears when you plug in
         the charger. This indicates the current status of the battery.  -->
    <string name="battery_status_charging">Charging\u2026</string>

    <!-- When the battery is low, this is displayed to the user in a dialog.  The title of the low battery alert. -->
    <string name="battery_low_title">Please connect charger</string>

    <!-- When the battery is low, this is displayed to the user in a dialog. The subtitle of the low battery alert. -->
    <string name="battery_low_subtitle">The battery is getting low:</string>

    <!-- A message that appears when the battery level is getting low in a dialog.  This is appened to the subtitle of the low battery alert. -->
    <string name="battery_low_percent_format">less than <xliff:g id="number">%d%%</xliff:g>
    remaining.</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.  WebView User Agent string -->
    <string name="web_user_agent"><xliff:g id="x">Mozilla/5.0 (Linux; U; Android %s)
        AppleWebKit/528.5+ (KHTML, like Gecko) Version/3.1.2 Mobile Safari/525.20.1</xliff:g></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>
    <!-- Message in a javascript dialog asking if the user wishes to leave the
             current page -->
    <string name="js_dialog_before_unload">Navigate away from this page?\n\n<xliff:g id="message">%s</xliff:g>\n\nSelect OK to continue, or Cancel to stay on the current 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>
    
    <!-- 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 do not 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>

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

    <!-- String used to display the date. This is shown instead of a date if the date is today's date. -->
    <string name="today">Today</string>
    <!-- String used to display the date. This is shown instead of a date if the date is yesterday's date. -->
    <string name="yesterday">Yesterday</string>
    <!-- String used to display the date. This is shown instead of a date if the date is tomorrow's date. -->
    <string name="tomorrow">Tomorrow</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 some number of seconds in the past (e.g., 5 seconds ago). -->
    <plurals name="num_seconds_ago">
        <item quantity="one">1 second ago</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> seconds ago</item>
    </plurals>

    <!-- This is used to express that something occurred some number of minutes in the past (e.g., 5 minutes ago). -->
    <plurals name="num_minutes_ago">
        <item quantity="one">1 minute ago</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> minutes ago</item>
    </plurals>

    <!-- This is used to express that something occurred some number of hours in the past (e.g., 5 hours ago). -->
    <plurals name="num_hours_ago">
        <item quantity="one">1 hour ago</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> hours ago</item>
    </plurals>

    <!-- This is used to express that something occurred some number of days in the past (e.g., 5 days ago). -->
    <plurals name="num_days_ago">
        <item quantity="one">yesterday</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> days ago</item>
    </plurals>

    <!-- This is used to express that something will occur some number of seconds in the future (e.g., in 5 seconds). -->
    <plurals name="in_num_seconds">
        <item quantity="one">in 1 second</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> seconds</item>
    </plurals>

    <!-- This is used to express that something will occur some number of minutes in the future (e.g., in 5 minutes). -->
    <plurals name="in_num_minutes">
        <item quantity="one">in 1 minute</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> minutes</item>
    </plurals>

    <!-- This is used to express that something will occur some number of hours in the future (e.g., in 5 hours). -->
    <plurals name="in_num_hours">
        <item quantity="one">in 1 hour</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> hours</item>
    </plurals>

    <!-- This is used to express that something will occur some number of days in the future (e.g., in 5 days). -->
    <plurals name="in_num_days">
        <item quantity="one">tomorrow</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> days</item>
    </plurals>
    
    <!-- This is used to express that something occurred some number of abbreviated seconds in the past (e.g., 5 secs ago). -->
    <plurals name="abbrev_num_seconds_ago">
        <item quantity="one">1 sec ago</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> secs ago</item>
    </plurals>

    <!-- This is used to express that something occurred some number of abbreviated minutes in the past (e.g., 5 mins ago). -->
    <plurals name="abbrev_num_minutes_ago">
        <item quantity="one">1 min ago</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> mins ago</item>
    </plurals>

    <!-- This is used to express that something occurred some number of abbreviated hours in the past (e.g., 5 hrs ago). -->
    <plurals name="abbrev_num_hours_ago">
        <item quantity="one">1 hour ago</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> hours ago</item>
    </plurals>

    <!-- This is used to express that something occurred some number of abbreviated days in the past (e.g., 5 days ago). -->
    <plurals name="abbrev_num_days_ago">
        <item quantity="one">yesterday</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> days ago</item>
    </plurals>

    <!-- This is used to express that something will occur some number of abbreviated seconds in the future (e.g., in 5 secs). -->
    <plurals name="abbrev_in_num_seconds">
        <item quantity="one">in 1 sec</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> secs</item>
    </plurals>

    <!-- This is used to express that something will occur some number of abbreviated minutes in the future (e.g., in 5 mins). -->
    <plurals name="abbrev_in_num_minutes">
        <item quantity="one">in 1 min</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> mins</item>
    </plurals>

    <!-- This is used to express that something will occur some number of abbreviated hours in the future (e.g., in 5 hrs). -->
    <plurals name="abbrev_in_num_hours">
        <item quantity="one">in 1 hour</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> hours</item>
    </plurals>

    <!-- This is used to express that something will occur some number of abbreviated days in the future (e.g., in 5 days). -->
    <plurals name="abbrev_in_num_days">
        <item quantity="one">tomorrow</item>
        <item quantity="other">in <xliff:g id="count">%d</xliff:g> days</item>
    </plurals>

    <!-- String used to display the date. Preposition for date display ("on May 29") -->
    <string name="preposition_for_date">on %s</string>
    <!-- String used to display the date. Preposition for time display ("at 2:33am") -->
    <string name="preposition_for_time">at %s</string>
    <!-- String used to display the date. Preposition for year display ("in 2008") -->
    <string name="preposition_for_year">in %s</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>

    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="sunday">Sunday</string>
    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="monday">Monday</string>
    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="tuesday">Tuesday</string>
    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="wednesday">Wednesday</string>
    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="thursday">Thursday</string>
    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="friday">Friday</string>
    <!-- Used in the list of which days of the week a calendar event recurrs on -->
    <string name="saturday">Saturday</string>

    <!-- Calendar spinner item, to select that an event recurs every weekday. -->
    <string name="every_weekday">"Every weekday (Mon\u2013Fri)"</string>
    <!-- Calendar spinner item, to select that an event recurs every day. -->
    <string name="daily">Daily</string>
    <!-- Calendar spinner item, to select that an event recurs every week on a particular day of the week. -->
    <string name="weekly">"Weekly on <xliff:g id="day">%s</xliff:g>"</string>
    <!-- Calendar spinner item, to select that an event recurs every month. -->
    <string name="monthly">Monthly</string>
    <!-- Calendar spinner item, to select that an event recurs every year. -->
    <string name="yearly">Yearly</string>


    <!-- Title for error alert when a video cannot be played.  it can be used by any app. -->
    <string name="VideoView_error_title">Cannot play video</string>
    <!-- Text for error alert when a video cannot be played. it can be used by any app. -->
    <string name="VideoView_error_text_unknown">Sorry, this video cannot be played.</string>
    <!-- Button to close error alert when a video cannot be played -->
    <string name="VideoView_error_button">OK</string>


    <!-- AM - as in morning - as in 10:30 AM -->
    <string name="am">"AM"</string>

    <!-- PM - as in afternoon - as in 10:30 PM -->
    <string name="pm">"PM"</string>


    <!-- Numeric form of the day. Example: "12/31/2007" -->
    <string name="numeric_date">"<xliff:g id="month" example="12">%m</xliff:g>/<xliff:g id="day" example="31">%d</xliff:g>/<xliff:g id="year" example="2008">%Y</xliff:g>"</string>

    <!-- Format indicating a range of time, from a time on one day to a time on another day. 
         Example: "Mon, Dec 31, 2007, 8am - Tue, Jan 1, 2008, 5pm" -->
    <string name="wday1_date1_time1_wday2_date2_time2">"<xliff:g id="weekday1" example="Monday">%1$s</xliff:g>, <xliff:g id="date1" example="December 31, 2007">%2$s</xliff:g>, <xliff:g id="time1" example="8am">%3$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Tuesday">%4$s</xliff:g>, <xliff:g id="date2" example="January 1, 2008">%5$s</xliff:g>, <xliff:g id="time2" example="5pm">%6$s</xliff:g>"</string>

    <!-- Format indicating a range of dates, from one date to another.
         Example: "Mon, Dec 31, 2007 - Tue, Jan 1, 2008" -->
    <string name="wday1_date1_wday2_date2">"<xliff:g id="weekday1" example="Monday">%1$s</xliff:g>, <xliff:g id="date1" example="Dec 31, 2007">%2$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Thursday">%4$s</xliff:g>, <xliff:g id="date2" example="Jan 1, 2008">%5$s</xliff:g>"</string>

    <!-- Format indicating a range of time, from a time on one day to a time on another day. 
         Example: "Dec 31, 2007, 8am - Jan 1, 2008, 5pm" -->
    <string name="date1_time1_date2_time2">"<xliff:g id="date1" example="Dec 31, 2007">%2$s</xliff:g>, <xliff:g id="time1" example="8am">%3$s</xliff:g> \u2013 <xliff:g id="date2" example="Jan 1, 2008">%5$s</xliff:g>, <xliff:g id="time2" example="5pm">%6$s</xliff:g>"</string>

    <!-- Format indicating a range of dates, from one date to another.
         Example: "Dec 31, 2007 - Jan 1, 2008" -->
    <string name="date1_date2">"<xliff:g id="date1" example="Dec 31, 2007">%2$s</xliff:g> \u2013 <xliff:g id="date2" example="Jan 1, 2008">%5$s</xliff:g>"</string>

    <!-- Format indicating a range of times, from one time to another.
         Example: "10:00 - 11:00 am" -->
    <string name="time1_time2">"<xliff:g id="time1" example="10:00">%1$s</xliff:g> \u2013 <xliff:g id="time2" example="11:00">%2$s</xliff:g>"</string>

    <!-- Format indicating a range of times on a particular date.
         Example: "8:00 - 11:00 am, Mon, Dec 31, 2007" -->
    <string name="time_wday_date">"<xliff:g id="time_range" example="8:00 - 11:00 am">%1$s</xliff:g>, <xliff:g id="weekday" example="Mon">%2$s</xliff:g>, <xliff:g id="date" example="Dec 31, 2007">%3$s</xliff:g>"</string>

    <!-- Format indicating a weekday and date.
         Example: "Mon, Dec 31, 2007" -->
    <string name="wday_date">"<xliff:g id="weekday" example="Monday">%2$s</xliff:g>, <xliff:g id="date" example="Dec 31, 2007">%3$s</xliff:g>"</string>

    <!-- Format indicating a range of times on a particular date.
         Example: "8:00 - 11:00 am, Dec 31, 2007" -->
    <string name="time_date">"<xliff:g id="time_range" example="8:00 - 11:00 am">%1$s</xliff:g>, <xliff:g id="date" example="Dec 31, 2007">%3$s</xliff:g>"</string>

    <!-- Format indicating a specific date and time.
         Example: "Dec 31, 2007, 11:00 am" -->
    <string name="date_time">"<xliff:g id="date" example="Dec 31, 2007">%1$s</xliff:g>, <xliff:g id="time" example="11:00 am">%2$s</xliff:g>"</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>

    <!-- Format indicating a range of times on a particular day of the week.
         Example: "8:00 - 11:00 am, Mon" -->
    <string name="time_wday">"<xliff:g id="time_range" example="8:00 - 11:00 am">%1$s</xliff:g>, <xliff:g id="weekday" example="Mon">%2$s</xliff:g>"</string>

    <!-- Date format string used in contexts where the user has said they
         want the month first, as used in the USA, with the month fully
         spelled out.  You can remove the comma or add a period,
         or make other punctuation changes appropriate for your locale.
         If you need to add letters, put apostrophes around them to keep
         them from being interpreted as format characters. -->
    <string name="full_date_month_first"><xliff:g id="month" example="December">MMMM</xliff:g> <xliff:g id="day" example="31">dd</xliff:g>, <xliff:g id="year" example="1972">yyyy</xliff:g></string>

    <!-- Date format string used in contexts where the user has said they
         want the day of the month first, as used in Europe, with the month
         fully spelled out.  You can remove the comma or add a period,
         or make other punctuation changes appropriate for your locale.
         If you need to add letters, put apostrophes around them to keep
         them from being interpreted as format characters. -->
    <string name="full_date_day_first"><xliff:g id="day" example="31">dd</xliff:g> <xliff:g id="month" example="December">MMMM</xliff:g>, <xliff:g id="year" example="1972">yyyy</xliff:g></string>

    <!-- Date format string used in contexts where the user has said they
         want the month first, as used in the USA, with the month
         abbreviated.  You can remove the comma or add a period,
         or make other punctuation changes appropriate for your locale.
         If you need to add letters, put apostrophes around them to keep
         them from being interpreted as format characters. -->
    <string name="medium_date_month_first"><xliff:g id="month" example="Dec.">MMM</xliff:g> <xliff:g id="day" example="31">dd</xliff:g>, <xliff:g id="year" example="1972">yyyy</xliff:g></string>

    <!-- Date format string used in contexts where the user has said they
         want the day of the month first, as used in Europe, with the month
         abbreviated.  You can remove the comma or add a period,
         or make other punctuation changes appropriate for your locale.
         If you need to add letters, put apostrophes around them to keep
         them from being interpreted as format characters. -->
    <string name="medium_date_day_first"><xliff:g id="day" example="31">dd</xliff:g> <xliff:g id="month" example="December">MMM</xliff:g>, <xliff:g id="year" example="1972">yyyy</xliff:g></string>

    <!-- Time format string used in the status bar when the user has said they
         want a 12-hour clock with AM and PM.
         You can remove the colon
         or make other punctuation changes appropriate for your locale.
         If you need to add letters, put apostrophes around them to keep
         them from being interpreted as format characters. -->
    <string name="twelve_hour_time_format"><xliff:g id="hour" example="11">h</xliff:g>:<xliff:g id="minute" example="59">mm</xliff:g> <xliff:g id="ampm" example="AM">a</xliff:g></string>

    <!-- Time format string used in the status bar when the user has said they
         want a 24-hour clock.
         You can remove the colon
         or make other punctuation changes appropriate for your locale.
         If you need to add letters, put apostrophes around them to keep
         them from being interpreted as format characters. -->
    <string name="twenty_four_hour_time_format"><xliff:g id="hour" example="23">H</xliff:g>:<xliff:g id="minute" example="59">mm</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>

    <!-- Date format for month and day of month.
         Example: "October 9". -->
    <string name="month_day">"<xliff:g id="month" example="October">%B</xliff:g> <xliff:g id="day" example="9">%-d</xliff:g>"</string>

    <!-- Date format for month alone.
         Example: "October" -->
    <string name="month">"<xliff:g id="month" example="October">%B</xliff:g>"</string>

    <!-- Date format for month, day, and year.
         Example: "October 9, 2007" -->
    <string name="month_day_year">"<xliff:g id="month" example="October">%B</xliff:g> <xliff:g id="day" example="9">%-d</xliff:g>, <xliff:g id="year" example="2007">%Y</xliff:g>"</string>

    <!-- Date format for month and year.
         Example: "October 2007" -->
    <string name="month_year">"<xliff:g id="month" example="October">%B</xliff:g> <xliff:g id="year" example="2007">%Y</xliff:g>"</string>

    <!-- A format string for 24-hour time of day (example "23:59"). -->
    <string name="time_of_day">"<xliff:g id="hour" example="23">%H</xliff:g>:<xliff:g id="minute" example="59">%M</xliff:g>:<xliff:g id="second" example="59">%S</xliff:g>"</string>

    <!-- Format string for date and 24-hour time of day.
         Example: 23:59:15 Jan 31 2008 -->
    <string name="date_and_time">"<xliff:g id="hour" example="23">%H</xliff:g>:<xliff:g id="minute" example="59">%M</xliff:g>:<xliff:g id="second" example="59">%S</xliff:g> <xliff:g id="month" example="Jan">%B</xliff:g> <xliff:g id="day" example="31">%-d</xliff:g>, <xliff:g id="year" example="2008">%Y</xliff:g>"</string>

    <!-- Format indicating a range of dates in the same year.
         Example: "Oct 31 - Nov 3" -->
    <string name="same_year_md1_md2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>"</string>

    <!-- Format indicating a range of dates in the same year, with weekday.
         Example: "Wed, Oct 31 - Sat, Nov 3" -->
    <string name="same_year_wday1_md1_wday2_md2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>"</string>

    <!-- Format indicating a range of dates in the same year.
         Example: "Oct 31 - Nov 3, 2007" -->
    <string name="same_year_mdy1_mdy2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year" example="2007">%9$s</xliff:g>"</string>

    <!-- Format indicating a range of dates in the same year, with weekdays.
         Example: "Wed, Oct 31 - Sat, Nov 3, 2007" -->
    <string name="same_year_wday1_mdy1_wday2_mdy2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year" example="2007">%9$s</xliff:g>"</string>

    <!-- Format indicating a range of time from a time on one day to a time on another.
         Example: "Oct 31, 8:00am - Nov 3, 5:00pm" -->
    <string name="same_year_md1_time1_md2_time2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of time from a time on one day to a time on another, with weekdays.
         Example: "Wed, Oct 31, 8:00am - Sat, Nov 3, 5:00pm" -->
    <string name="same_year_wday1_md1_time1_wday2_md2_time2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id ="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of time from a time on one day to a time on another, with years and weekdays.
         Example: "Oct 31, 2007, 8:00am - Nov 3, 2007, 5:00pm" -->
    <string name="same_year_mdy1_time1_mdy2_time2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="year1" example="2007">%4$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year2" example="2007">%9$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of time from a time on one day to a time on another.
     Example: "Wed, Oct 31, 2007, 8:00am - Sat, Nov 3, 2007, 5:00pm" -->
    <string name="same_year_wday1_mdy1_time1_wday2_mdy2_time2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="year1" example="2007">%4$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year2" example="2007">%9$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>


    <!-- Format indicating a range of (numeric) dates.
          Example: "10/31 - 11/3" -->
    <string name="numeric_md1_md2">"<xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates.
          Example: "Wed, 10/31 - Sat, 11/3" -->
    <string name="numeric_wday1_md1_wday2_md2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates.
          Example: "10/31/2007 - 11/3/2007" -->
    <string name="numeric_mdy1_mdy2">"<xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g>/<xliff:g id="year1" example="2007">%4$s</xliff:g> \u2013 <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>/<xliff:g id="year2" example="2007">%9$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates.
          Example: "Wed, 10/31/2007 - Sat, 11/3/2007" -->
    <string name="numeric_wday1_mdy1_wday2_mdy2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g>/<xliff:g id="year1" example="2007">%4$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>/<xliff:g id="year2" example="2007">%9$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates and times.
          Example: "10/31, 8:00am - 11/3, 5:00pm" -->
    <string name="numeric_md1_time1_md2_time2">"<xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates and times.
          Example: "Wed, 10/31, 8:00am - Sat, 11/3, 5:00pm" -->
    <string name="numeric_wday1_md1_time1_wday2_md2_time2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates and times.
          Example: "10/31/2007, 8:00am - 11/3/2007, 5:00pm"  -->
    <string name="numeric_mdy1_time1_mdy2_time2">"<xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g>/<xliff:g id="year1" example="2007">%4$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>/<xliff:g id="year2" example="2007">%9$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of (numeric) dates and times.
          Example: "Wed, 10/31/2007, 8:00am - Sat, 11/3/2007, 5:00pm" -->
    <string name="numeric_wday1_mdy1_time1_wday2_mdy2_time2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="10">%2$s</xliff:g>/<xliff:g id="day1" example="31">%3$s</xliff:g>/<xliff:g id="year1" example="2007">%4$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="11">%7$s</xliff:g>/<xliff:g id="day2" example="30">%8$s</xliff:g>/<xliff:g id="year2" example="2007">%9$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>


    <!-- Format indicating a range of dates.
          Example: "Oct 9 - 10" -->
    <string name="same_month_md1_md2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="day2" example="3">%8$s</xliff:g>"</string>

    <!-- Format indicating a range of dates.
          Example: "Tue, Oct 9 - Wed, Oct 10"  -->
    <string name="same_month_wday1_md1_wday2_md2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>"</string>

    <!-- Format indicating a range of dates.
          Example: "Oct 9 - 10, 2007" -->
    <string name="same_month_mdy1_mdy2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g> \u2013 <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year2" example="2007">%9$s</xliff:g>"</string>

    <!-- Format indicating a range of dates.
          Example: "Tue, Oct 9, 2007 - Wed, Oct 10, 2007"  -->
    <string name="same_month_wday1_mdy1_wday2_mdy2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="year1" example="2007">%4$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year2" example="2007">%9$s</xliff:g>"</string>

    <!-- Format indicating a range of dates and times.
          Example: "Oct 9, 8:00am - Oct 10, 5:00pm"  -->
    <string name="same_month_md1_time1_md2_time2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of dates and times.
          Example: "Tue, Oct 9, 8:00am - Wed, Oct 10, 5:00pm"  -->
    <string name="same_month_wday1_md1_time1_wday2_md2_time2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of dates and times.
          Example: "Oct 9, 2007, 8:00am - Oct 10, 2007, 5:00pm"  -->
    <string name="same_month_mdy1_time1_mdy2_time2">"<xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="year1" example="2007">%4$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year2" example="2007">%9$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format indicating a range of dates and times.
          Example: "Tue, Oct 9, 2007, 8:00am - Wed, Oct 10, 2007, 5:00pm" -->
    <string name="same_month_wday1_mdy1_time1_wday2_mdy2_time2">"<xliff:g id="weekday1" example="Wed">%1$s</xliff:g>, <xliff:g id="month1" example="Oct">%2$s</xliff:g> <xliff:g id="day1" example="31">%3$s</xliff:g>, <xliff:g id="year1" example="2007">%4$s</xliff:g>, <xliff:g id="time1" example="8:00am">%5$s</xliff:g> \u2013 <xliff:g id="weekday2" example="Sat">%6$s</xliff:g>, <xliff:g id="month2" example="Nov">%7$s</xliff:g> <xliff:g id="day2" example="3">%8$s</xliff:g>, <xliff:g id="year2" example="2007">%9$s</xliff:g>, <xliff:g id="time2" example="5:00pm">%10$s</xliff:g>"</string>

    <!-- Format string for abbreviated month, day, and year.
         Example: "Oct 9, 2007" -->
    <string name="abbrev_month_day_year">"<xliff:g id="month" example="Oct">%b</xliff:g> <xliff:g id="day" example="9">%-d</xliff:g>, <xliff:g id="year" example="2007">%Y</xliff:g>"</string>

    <!-- Format string for abbreviated month and year.
         Example: "Oct 2007" -->
    <string name="abbrev_month_year">"<xliff:g id="month" example="Oct">%b</xliff:g> <xliff:g id="year" example="2007">%Y</xliff:g>"</string>

    <!-- Format string for abbreviated month and day.
         Example: "Oct 9" -->
    <string name="abbrev_month_day">"<xliff:g id="month" example="Oct">%b</xliff:g> <xliff:g id="day" example="31">%-d</xliff:g>"</string>

    <!-- Format string for abbreviated month alone.
         Example: "Oct" -->
    <string name="abbrev_month">"<xliff:g id="month" example="Oct">%b</xliff:g>"</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_sunday">Sunday</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_monday">Monday</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_tuesday">Tuesday</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_wednesday">Wednesday</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_thursday">Thursday</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_friday">Friday</string>

    <!-- The full spelled out version of the day of the week. -->
    <string name="day_of_week_long_saturday">Saturday</string>


    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Sun" stands for Sunday -->
    <string name="day_of_week_medium_sunday">Sun</string>

    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Mon" stands for Monday -->
    <string name="day_of_week_medium_monday">Mon</string>

    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Tue" stands for Tuesday -->
    <string name="day_of_week_medium_tuesday">Tue</string>

    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Wed" stands for Wednesday -->
    <string name="day_of_week_medium_wednesday">Wed</string>

    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Thu" stands for Thursday -->
    <string name="day_of_week_medium_thursday">Thu</string>

    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Fri" stands for Friday -->
    <string name="day_of_week_medium_friday">Fri</string>

    <!-- An abbreviated day of the week.  Three characters typically in western languages.
         In US English: "Sat" stands for Saturday -->
    <string name="day_of_week_medium_saturday">Sat</string>


    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "Su" stands for Sunday -->
    <string name="day_of_week_short_sunday">Su</string>

    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "Mo" stands for Monday -->
    <string name="day_of_week_short_monday">Mo</string>

    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "Tu" stands for Tuesday -->
    <string name="day_of_week_short_tuesday">Tu</string>

    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "We" stands for Wednesday -->
    <string name="day_of_week_short_wednesday">We</string>

    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "Th" stands for Thursday -->
    <string name="day_of_week_short_thursday">Th</string>

    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "Fr" stands for Friday -->
    <string name="day_of_week_short_friday">Fr</string>

    <!-- An abbreviated day of the week.  Two characters typically in western languages.
         In US English: "Sa" stands for Saturday -->
    <string name="day_of_week_short_saturday">Sa</string>


    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "Su" stands for Sunday -->
    <string name="day_of_week_shorter_sunday">Su</string>

    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "M" stands for Monday -->
    <string name="day_of_week_shorter_monday">M</string>

    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "Tu" stands for Tuesday -->
    <string name="day_of_week_shorter_tuesday">Tu</string>

    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "W" stands for Wednesday -->
    <string name="day_of_week_shorter_wednesday">W</string>

    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "Th" stands for Thursday -->
    <string name="day_of_week_shorter_thursday">Th</string>

    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "F" stands for Friday -->
    <string name="day_of_week_shorter_friday">F</string>

    <!-- An abbreviated day of the week.  One character if that is unique.  Two if necessary.
         In US English: "Sa" stands for Saturday -->
    <string name="day_of_week_shorter_saturday">Sa</string>


    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "S" stands for Sunday -->
    <string name="day_of_week_shortest_sunday">S</string>

    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "M" stands for Monday -->
    <string name="day_of_week_shortest_monday">M</string>

    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "T" stands for Tuesday -->
    <string name="day_of_week_shortest_tuesday">T</string>

    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "W" stands for Wednesday -->
    <string name="day_of_week_shortest_wednesday">W</string>

    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "T" stands for Thursday -->
    <string name="day_of_week_shortest_thursday">T</string>

    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "F" stands for Friday -->
    <string name="day_of_week_shortest_friday">F</string>

    <!-- An abbreviated day of the week.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "S" stands for Saturday -->
    <string name="day_of_week_shortest_saturday">S</string>


    <!-- The full spelled out version of the month. -->
    <string name="month_long_january">January</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_february">February</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_march">March</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_april">April</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_may">May</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_june">June</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_july">July</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_august">August</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_september">September</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_october">October</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_november">November</string>

    <!-- The full spelled out version of the month. -->
    <string name="month_long_december">December</string>


    <!-- An abbreviated month name.
        In US English: "Jan" stands for January. -->
    <string name="month_medium_january">Jan</string>

    <!-- An abbreviated month name.
        In US English: "Feb" stands for February. -->
    <string name="month_medium_february">Feb</string>

    <!-- An abbreviated month name.
        In US English: "Mar" stands for March. -->
    <string name="month_medium_march">Mar</string>

    <!-- An abbreviated month name.
        In US English: "Apr" stands for April. -->
    <string name="month_medium_april">Apr</string>

    <!-- An abbreviated month name.
        In US English: "May" stands for May. -->
    <string name="month_medium_may">May</string>

    <!-- An abbreviated month name.
        In US English: "Jun" stands for June. -->
    <string name="month_medium_june">Jun</string>

    <!-- An abbreviated month name.
        In US English: "Jul" stands for July. -->
    <string name="month_medium_july">Jul</string>

    <!-- An abbreviated month name.
        In US English: "Aug" stands for August. -->
    <string name="month_medium_august">Aug</string>

    <!-- An abbreviated month name.
        In US English: "Sep" stands for September. -->
    <string name="month_medium_september">Sep</string>

    <!-- An abbreviated month name.
        In US English: "Oct" stands for October. -->
    <string name="month_medium_october">Oct</string>

    <!-- An abbreviated month name.
        In US English: "Nov" stands for November. -->
    <string name="month_medium_november">Nov</string>

    <!-- An abbreviated month name.
        In US English: "Dec" stands for December. -->
    <string name="month_medium_december">Dec</string>


    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "J" stands for January -->
    <string name="month_shortest_january">J</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
        In US English: "F" stands for February. -->
    <string name="month_shortest_february">F</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "M" stands for March. -->
    <string name="month_shortest_march">M</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "A" stands for April. -->
    <string name="month_shortest_april">A</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "M" stands for May. -->
    <string name="month_shortest_may">M</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "J" stands for June. -->
    <string name="month_shortest_june">J</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "J" stands for July. -->
    <string name="month_shortest_july">J</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "A" stands for August. -->
    <string name="month_shortest_august">A</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "S" stands for September. -->
    <string name="month_shortest_september">S</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "O" stands for October. -->
    <string name="month_shortest_october">O</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "N" stands for November. -->
    <string name="month_shortest_november">N</string>

    <!-- An abbreviated month name.  One character long if it makes sense.  Does not have
         to be unique.
         In US English: "D" stands for December. -->
    <string name="month_shortest_december">D</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 start selecting text in the edit field. -->
    <string name="selectText">Select text</string>

    <!-- Item on EditText context menu. This action is used to start selecting text in the edit field. -->
    <string name="stopSelectingText">Stop selecting text</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 all the text into the clipboard. -->
    <string name="cutAll">Cut all</string>

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

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

    <!-- Item on EditText context menu. This action is used t o paste from the clipboard into the eidt field -->
    <string name="paste">Paste</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>

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

    <!-- Title for EditText context menu -->
    <string name="editTextMenuTitle">Edit 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">Low on space</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">Phone storage space is getting low.</string>

    <!-- Preference framework strings. -->
    <string name="ok">OK</string>
    <!-- Preference framework strings. -->
    <string name="cancel">Cancel</string>
    <!-- Preference framework strings. -->
    <string name="yes">OK</string>
    <!-- Preference framework strings. -->
    <string name="no">Cancel</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>

    <!-- Title of intent resolver dialog when selecting an application to run. -->
    <string name="whichApplication">Complete action using</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>
    <!-- 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 Home Settings &gt; Applications &gt; Manage applications.</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">Select an action</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 applications can perform this action.</string>
    <!-- Title of the alert when an application has crashed. -->
    <string name="aerr_title">Sorry!</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="aerr_application">The application <xliff:g id="application">%1$s</xliff:g>
        (process <xliff:g id="process">%2$s</xliff:g>) has stopped unexpectedly. Please try again.</string>
    <!-- Text of the alert that is displayed when an application has crashed. -->
    <string name="aerr_process">The process <xliff:g id="process">%1$s</xliff:g> has
        stopped unexpectedly. Please try again.</string>
    <!-- Title of the alert when an application is not responding. -->
    <string name="anr_title">Sorry!</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_activity_application">Activity <xliff:g id="activity">%1$s</xliff:g> (in application <xliff:g id="application">%2$s</xliff:g>) is not responding.</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_activity_process">Activity <xliff:g id="activity">%1$s</xliff:g> (in process <xliff:g id="process">%2$s</xliff:g>) is not responding.</string>
    <!-- Text of the alert that is displayed when an application is not responding. -->
    <string name="anr_application_process">Application <xliff:g id="application">%1$s</xliff:g> (in process <xliff:g id="process">%2$s</xliff:g>) is not 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> is not responding.</string>
    <!-- Button allowing the user to close an application that is not responding. This will kill the application. -->
    <string name="force_close">Force close</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>
    <!-- Button allowing a developer to connect a debugger to an application that is not responding. -->
    <string name="debug">Debug</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">Select 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>
    <!-- Title of the dialog where the user is adjusting the phone call volume -->
    <string name="volume_call">In-call volume</string>
    <!-- Hint shown in the volume toast to inform the user that the in-call audio is playing through Bluetooth. -->
    <string name="volume_call_hint_playing_through_bluetooth">Playing through Bluetooth</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>

    <!-- 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 ringtone (<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">Silent</string>
    <!-- The title of the ringtone picker dialog. -->
    <string name="ringtone_picker_title">Ringtones</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 ringtone</string>

    <!-- A notification is shown when there are open wireless networks nearby.  This is the notification's title. -->
    <plurals name="wifi_available">
        <item quantity="one">Wi-Fi network available</item>
        <item quantity="other">Wi-Fi networks available</item>
    </plurals>
    <!-- A notification is shown when there are open wireless networks nearby.  This is the notification's message. -->
    <plurals name="wifi_available_detailed">
        <item quantity="one">Open Wi-Fi network available</item>
        <item quantity="other">Open Wi-Fi networks available</item>
    </plurals>

    <!-- 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 />
    <!-- See SMS_DIALOG.  This is shown if the current application's name cannot be figuerd out. -->
    <string name="sms_control_default_app_name">Unknown application</string>
    <!-- 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. -->
    <string name="sms_control_message">A large number of SMS messages are being sent. Select \"OK\" to continue, or \"Cancel\" to stop sending.</string>
    <!-- See SMS_DIALOG.  This is a button choice to allow sending the SMSes. -->
    <string name="sms_control_yes">OK</string>
    <!-- See SMS_DIALOG.  This is a button choice to disallow sending the SMSes.. -->
    <string name="sms_control_no">Cancel</string>

    <!-- Name of the button in the date/time picker to accept the date/time change -->
    <string name="date_time_set">Set</string>

    <!-- Security Permissions strings-->
    <!-- The default permission group for any permissions that have not explicitly set a group. -->
    <string name="default_permission_group">Default</string>
    <!-- Do not translate. -->
    <string name="permissions_format"><xliff:g id="perm_line1">%1$s</xliff:g>, <xliff:g id="perm_line2">%2$s</xliff:g></string>
    <!-- Shown for an application when it doesn't require any permission grants. -->
    <string name="no_permissions">No permissions required</string>
    <!-- When installing an application, the less-dangerous permissions are hidden.  If the user showed those, this is the text to hide them again.  -->
    <string name="perms_hide"><b>Hide</b></string>
    <!-- When installing an application, the less-dangerous permissions are hidden.  This is the text to show those. -->
    <string name="perms_show_all"><b>Show all</b></string>

    <!-- Shown when there is content loading from the internet into a dialog. -->
    <string name="googlewebcontenthelper_loading">Loading\u2026</string>

    <!-- USB storage dialog strings -->
    <!-- This is the label for the activity, and should never be visible to the user. -->
    <!-- See USB_STORAGE.  USB_STORAGE_DIALOG:  After the user selects the notification, a dialog is shown asking if he wants to mount.  This is the title. -->
    <string name="usb_storage_title">USB connected</string>
    <!-- See USB_STORAGE.    This is the message. -->
    <string name="usb_storage_message">You have connected your phone to your computer via USB. Select \"Mount\" if you want to copy files between your computer and your phone\'s SD card.</string>
    <!-- See USB_STORAGE.    This is the button text to mount the phone on the computer. -->
    <string name="usb_storage_button_mount">Mount</string>
    <!-- See USB_STORAGE.   This is the button text to ignore the plugging in of the phone.. -->
    <string name="usb_storage_button_unmount">Don\'t mount</string>
    <!-- See USB_STORAGE_DIALOG.  IF there was an error mounting, this is hte text. --> 
    <string name="usb_storage_error_message">There is a problem using your SD card for USB storage.</string>
    <!-- USB_STORAGE: When the user connects the phone to a computer via USB, we show a notification asking if he wnats to share files across.  This is the title -->
    <string name="usb_storage_notification_title">USB connected</string>
    <!-- See USB_STORAGE. This is the message. -->
    <string name="usb_storage_notification_message">Select to copy files to/from your computer.</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 input method components. -->
    <string name="select_input_method">Select Input Method</string>
    
    <string name="fast_scroll_alphabet">\u0020ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
    <string name="fast_scroll_numeric_alphabet">\u00200123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ</string>
    
    <string name="candidates_style"><font fgcolor="#ff000000"
            bgcolor="#ff8080ff"><u>candidates</u>u></font></string>
</resources>



