<?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">
    <!-- App label in the manifest  -->
    <string name="app_name">Keyguard</string>
    <!-- Instructions telling the user to enter their SIM PIN to unlock the keyguard.
         Displayed in one line in a large font.  -->
    <string name="keyguard_password_enter_pin_code">Type PIN code</string>

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

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

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

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

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

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

    <!-- When the lock screen is showing, the phone is plugged in and the battery is fully
         charged, say that it is charged. -->
    <string name="keyguard_charged">Charged</string>

    <!-- When the lock screen is showing and the phone plugged in, and the battery
         is not fully charged, say that it's charging.  -->
    <string name="keyguard_plugged_in">Charging</string>

    <!-- When the lock screen is showing and the phone plugged in, and the battery
         is not fully charged, and it's plugged into a fast charger, say that it's charging fast.  -->
    <string name="keyguard_plugged_in_charging_fast">Charging rapidly</string>

    <!-- When the lock screen is showing and the phone plugged in, and the battery
         is not fully charged, and it's plugged into a slow charger, say that it's charging slowly.  -->
    <string name="keyguard_plugged_in_charging_slowly">Charging slowly</string>

    <!-- When the lock screen is showing and the battery is low, warn user to plug
         in the phone soon. -->
    <string name="keyguard_low_battery">Connect your charger.</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="keyguard_instructions_when_pattern_disabled">Press Menu to unlock.</string>

    <!-- SIM messages --><skip />
    <!-- When the user inserts a sim card from an unsupported network, it becomes network locked -->
    <string name="keyguard_network_locked_message">Network locked</string>
    <!-- Shown when there is no SIM card. -->
    <string name="keyguard_missing_sim_message_short">No SIM card</string>
    <!-- Shown when there is no SIM card. -->
    <string name="keyguard_missing_sim_message" product="tablet">No SIM card in tablet.</string>
    <!-- Shown when there is no SIM card. -->
    <string name="keyguard_missing_sim_message" product="default">No SIM card in phone.</string>
    <!-- Shown to ask the user to insert a SIM card. -->
    <string name="keyguard_missing_sim_instructions">Insert a SIM card.</string>
    <!-- Shown to ask the user to insert a SIM card when sim is missing or not readable. -->
    <string name="keyguard_missing_sim_instructions_long">The SIM card is missing or not readable. Insert a SIM card.</string>
    <!-- Shown when SIM card is permanently disabled. -->
    <string name="keyguard_permanent_disabled_sim_message_short">Unusable SIM card.</string>
    <!-- Shown to inform the user to SIM card is permanently disabled. -->
    <string name="keyguard_permanent_disabled_sim_instructions">Your SIM card has been permanently disabled.\n
    Contact your wireless service provider for another SIM card.</string>
    <!-- Shown to tell the user that their SIM is locked and they must unlock it. -->
    <string name="keyguard_sim_locked_message">SIM card is locked.</string>
    <!-- When the user enters a wrong sim pin too many times, it becomes PUK locked (Pin Unlock Kode) -->
    <string name="keyguard_sim_puk_locked_message">SIM card is PUK-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="keyguard_sim_unlock_progress_dialog_message">Unlocking SIM card\u2026</string>

    <!-- Time format strings for fall-back clock widget -->
    <string name="keyguard_widget_12_hours_format" translatable="false">h:mm</string>
    <!-- Time format strings for fall-back clock widget -->
    <string name="keyguard_widget_24_hours_format" translatable="false">kk:mm</string>
    <!-- The character used in keyguard_widget_12_hours_format and keyguard_widget_24_hours_format
         to represent a ":". -->
    <string name="keyguard_fancy_colon" translatable="false"></string>

    <!-- Accessibility description of the PIN password view. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_pin_area">PIN area</string>
    <!-- Accessibility description of the SIM PIN password view. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_sim_pin_area">SIM PIN area</string>
    <!-- Accessibility description of the SIM PUK password view. [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_sim_puk_area">SIM PUK area</string>

    <!-- Accessibility description for the text view that indicates when the next alarm is set (not shown on screen). [CHAR_LIMIT=none] -->
    <string name="keyguard_accessibility_next_alarm">Next alarm set for <xliff:g id="alarm" example="Fri 8:30 AM">%1$s</xliff:g></string>

    <!-- KeyguardPinView - accessibility support --><skip />
    <!-- Description of the Delete button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_delete">Delete</string>
    <!-- Description of the button used to disable current carrier when the device supported embedded SIM. [CHAR LIMIT=30] -->
    <string name="disable_carrier_button_text">Disable eSIM</string>
    <!-- Description of the Enter button in a KeyboardView. [CHAR LIMIT=NONE] -->
    <string name="keyboardview_keycode_enter">Enter</string>

    <!-- Message shown in pattern unlock after some number of unsuccessful attempts -->
    <string name="kg_forgot_pattern_button_text">Forgot Pattern</string>
    <!-- Message shown when user enters wrong pattern -->
    <string name="kg_wrong_pattern">Wrong Pattern</string>
    <!-- Message shown when user enters wrong password -->
    <string name="kg_wrong_password">Wrong Password</string>
    <!-- Message shown when user enters wrong PIN -->
    <string name="kg_wrong_pin">Wrong PIN</string>
    <!-- Countdown message shown after too many failed unlock attempts -->
    <string name="kg_too_many_failed_attempts_countdown">Try again in <xliff:g id="number">%d</xliff:g> seconds.</string>
    <!-- Instructions for using the pattern unlock screen -->
    <string name="kg_pattern_instructions">Draw your pattern</string>
    <!-- Instructions for using the SIM PIN unlock screen -->
    <string name="kg_sim_pin_instructions">Enter SIM PIN.</string>
    <!-- Instructions for using the SIM PIN unlock screen when there's more than one SIM -->
    <string name="kg_sim_pin_instructions_multi">Enter SIM PIN for \"<xliff:g id="carrier" example="CARD 1">%1$s</xliff:g>\".</string>
    <!-- Instructions for disabling eSIM carrier to unlock the phone with embedded SIM -->
    <string name="kg_sim_lock_instructions_esim">Disable eSIM to use device without mobile service.</string>
    <!-- Instructions for using the PIN unlock screen -->
    <string name="kg_pin_instructions">Enter PIN</string>
    <!-- Instructions for using the password unlock screen -->
    <string name="kg_password_instructions">Enter Password</string>
    <!-- Hint shown in the PUK screen that asks the user to enter the PUK code given to them by their provider -->
    <string name="kg_puk_enter_puk_hint">SIM is now disabled. Enter PUK code to continue. Contact carrier for details.</string>
    <!-- Hint shown when there are multiple SIMs in the device to ask the user to enter the PUK code given to them by their provider -->
    <string name="kg_puk_enter_puk_hint_multi">SIM \"<xliff:g id="carrier" example="CARD 1">%1$s</xliff:g>\" is now disabled. Enter PUK code to continue. Contact carrier for details.</string>
    <!-- Hint shown in the PUK unlock screen PIN TextView -->
    <string name="kg_puk_enter_pin_hint">Enter desired PIN code</string>
    <!-- Message shown when the user needs to confirm the PIN they just entered in the PUK screen -->
    <string name="kg_enter_confirm_pin_hint">Confirm desired PIN code</string>
    <!-- Message shown in dialog while the device is unlocking the SIM card -->
    <string name="kg_sim_unlock_progress_dialog_message">Unlocking SIM card\u2026</string>
    <!-- Message shown when the user enters an invalid SIM pin password in PUK screen -->
    <string name="kg_invalid_sim_pin_hint">Type a PIN that is 4 to 8 numbers.</string>
    <!-- Message shown when the user enters an invalid PUK code in the PUK screen -->
    <string name="kg_invalid_sim_puk_hint">PUK code should be 8 numbers or more.</string>
    <!-- Message shown when the user enters an invalid PUK code -->
    <string name="kg_invalid_puk">Re-enter the correct PUK code. Repeated attempts will permanently disable the SIM.</string>
      <!-- String shown in PUK screen when PIN codes don't match -->
    <string name="kg_invalid_confirm_pin_hint" product="default">PIN codes does not match</string>
    <!-- Message shown when the user exceeds the maximum number of pattern attempts -->
    <string name="kg_login_too_many_attempts">Too many pattern attempts</string>
    <!-- Message shown in dialog when max number of attempts are reached for PIN screen of keyguard -->
    <string name="kg_too_many_failed_pin_attempts_dialog_message">
        You have incorrectly typed your PIN <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>
    <!-- Message shown in dialog when max number of attempts are reached for password screen of keyguard -->
    <string name="kg_too_many_failed_password_attempts_dialog_message">
        You have incorrectly typed your password <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>
    <string name="kg_too_many_failed_pattern_attempts_dialog_message">
        You have incorrectly drawn your unlock pattern <xliff:g id="number">%1$d</xliff:g> times.
        \n\nTry again in <xliff:g id="number">%2$d</xliff:g> seconds.
    </string>

    <!-- Message shown when user is almost at the limit of password attempts where the device will be wiped. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_almost_at_wipe" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       this tablet will be reset, which will delete all its data.
    </string>
    <!-- Message shown when user is almost at the limit of password attempts where the device will be wiped. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_almost_at_wipe" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       this phone will be reset, which will delete all its data.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the device will now be wiped [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_now_wiping" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%d</xliff:g> times.
       This tablet will be reset, which will delete all its data.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the device will now be wiped [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_now_wiping" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%d</xliff:g> times.
       This phone will be reset, which will delete all its data.
    </string>

    <!-- Message shown when user is almost at the limit of password attempts where the user will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_almost_at_erase_user" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       this user will be removed, which will delete all user data.
    </string>
    <!-- Message shown when user is almost at the limit of password attempts where the user will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_almost_at_erase_user" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       this user will be removed, which will delete all user data.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the user will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_now_erasing_user" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%d</xliff:g> times.
       This user will be removed, which will delete all user data.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the user will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_now_erasing_user" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%d</xliff:g> times.
       This user will be removed, which will delete all user data.
    </string>

    <!-- Message shown when user is almost at the limit of password attempts where the profile will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_almost_at_erase_profile" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       the work profile will be removed, which will delete all profile data.
    </string>
    <!-- Message shown when user is almost at the limit of password attempts where the profile will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_almost_at_erase_profile" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%1$d</xliff:g> times.
       After <xliff:g id="number">%2$d</xliff:g> more unsuccessful attempts,
       the work profile will be removed, which will delete all profile data.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the profile will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_now_erasing_profile" product="tablet">
       You have incorrectly attempted to unlock the tablet <xliff:g id="number">%d</xliff:g> times.
       The work profile will be removed, which will delete all profile data.
    </string>
    <!-- Message shown in dialog when user has exceeded the maximum attempts and the profile will be removed. [CHAR LIMIT=none] -->
    <string name="kg_failed_attempts_now_erasing_profile" product="default">
       You have incorrectly attempted to unlock the phone <xliff:g id="number">%d</xliff:g> times.
       The work profile will be removed, which will delete all profile data.
    </string>

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

    <!-- Instructions telling the user that they entered the wrong SIM PIN for the last time.
         Displayed in a dialog box.  -->
    <string name="kg_password_wrong_pin_code_pukked">Incorrect SIM PIN code you must now contact your carrier to unlock your device.</string>
    <!-- Instructions telling the user that they entered the wrong SIM PIN while trying
         to unlock the keyguard.  Displayed in a dialog box.  -->
    <plurals name="kg_password_wrong_pin_code">
        <item quantity="one">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempt before you must contact your carrier to unlock your device.</item>
        <item quantity="other">Incorrect SIM PIN code, you have <xliff:g id="number">%d</xliff:g> remaining attempts.</item>
    </plurals>

    <!-- Instructions telling the user that they have exhausted SIM PUK retries and the SIM is now unusable.
         Displayed in a dialog box.  -->
    <string name="kg_password_wrong_puk_code_dead">SIM is unusable. Contact your carrier.</string>
    <!-- Instructions telling the user that they entered the wrong puk while trying
         to unlock the keyguard.  Displayed in a dialog box.  -->
    <plurals name="kg_password_wrong_puk_code">
        <item quantity="one">Incorrect SIM PUK code, you have <xliff:g id="number">%d</xliff:g> remaining attempt before SIM becomes permanently unusable.</item>
        <item quantity="other">Incorrect SIM PUK code, you have <xliff:g id="number">%d</xliff:g> remaining attempts before SIM becomes permanently unusable.</item>
    </plurals>
    <!-- Instructions telling the user that the operation to unlock the keyguard
         with SIM PIN failed. Displayed in one line in a large font.  -->
    <string name="kg_password_pin_failed">SIM PIN operation failed!</string>
    <!-- Instructions telling the user that the operation to unlock the keyguard
         with PUK failed. Displayed in one line in a large font.  -->
    <string name="kg_password_puk_failed">SIM PUK operation failed!</string>
    <!-- Notification telling the user that the PIN1 they entered is valid -->
    <string name="kg_pin_accepted">Code Accepted!</string>

    <!-- 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="keyguard_carrier_default">No service.</string>

    <!-- Content description of the switch input method button for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_ime_switch_button" msgid="5032926134740456424">Switch input method</string>

    <!-- Description of airplane mode -->
    <string name="airplane_mode">Airplane mode</string>

    <!-- An explanation text that the pattern needs to be solved since the device has just been restarted. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_restart_pattern">Pattern required after device restarts</string>

    <!-- An explanation text that the pin needs to be entered since the device has just been restarted. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_restart_pin">PIN required after device restarts</string>

    <!-- An explanation text that the password needs to be entered since the device has just been restarted. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_restart_password">Password required after device restarts</string>

    <!-- An explanation text that the pattern needs to be solved since the user hasn't used strong authentication since quite some time. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_timeout_pattern">Pattern required for additional security</string>

    <!-- An explanation text that the pin needs to be entered since the user hasn't used strong authentication since quite some time. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_timeout_pin">PIN required for additional security</string>

    <!-- An explanation text that the password needs to be entered since the user hasn't used strong authentication since quite some time. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_timeout_password">Password required for additional security</string>

    <!-- An explanation text that the pattern needs to be solved since profiles have just been switched. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_switch_profiles_pattern">Pattern required when you switch profiles</string>

    <!-- An explanation text that the pin needs to be entered since profiles have just been switched. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_switch_profiles_pin">PIN required when you switch profiles</string>

    <!-- An explanation text that the password needs to be entered since profiles have just been switched. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_switch_profiles_password">Password required when you switch profiles</string>

    <!-- An explanation text that the credential needs to be entered because a device admin has
    locked the device. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_device_admin">Device locked by admin</string>

    <!-- An explanation text that the credential needs to be entered because the user has clicked
     the force lock button. [CHAR LIMIT=80] -->
    <string name="kg_prompt_reason_user_request">Device was locked manually</string>

    <!-- An explanation text that the pattern needs to be solved since it hasn't been solved in a while. [CHAR LIMIT=80]-->
    <plurals name="kg_prompt_reason_time_pattern">
        <item quantity="one">Device hasn\'t been unlocked for <xliff:g id="number">%d</xliff:g> hour. Confirm pattern.</item>
        <item quantity="other">Device hasn\'t been unlocked for <xliff:g id="number">%d</xliff:g> hours. Confirm pattern.</item>
    </plurals>

    <!-- An explanation text that the pin needs to be entered since it hasn't been entered in a while. [CHAR LIMIT=80]-->
    <plurals name="kg_prompt_reason_time_pin">
        <item quantity="one">Device hasn\'t been unlocked for <xliff:g id="number">%d</xliff:g> hour. Confirm PIN.</item>
        <item quantity="other">Device hasn\'t been unlocked for <xliff:g id="number">%d</xliff:g> hours. Confirm PIN.</item>
    </plurals>

    <!-- An explanation text that the password needs to be entered since it hasn't been entered in a while. [CHAR LIMIT=80]-->
    <plurals name="kg_prompt_reason_time_password">
        <item quantity="one">Device hasn\'t been unlocked for <xliff:g id="number">%d</xliff:g> hour. Confirm password.</item>
        <item quantity="other">Device hasn\'t been unlocked for <xliff:g id="number">%d</xliff:g> hours. Confirm password.</item>
    </plurals>

    <!-- Fingerprint hint message when finger was not recognized.-->
    <string name="fingerprint_not_recognized">Not recognized</string>

</resources>
