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

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

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

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
-->

<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">

    <!-- Official label of the phone app, as seen in "Manage Applications"
         and other settings UIs.  This is the version of the label for
         tablet devices, where the phone app handles mobile data but not
         actual phone calls. -->
    <string name="phoneAppLabel" product="tablet">Mobile Data</string>

    <!-- Official label of the phone app, as seen in "Manage Applications"
         and other settings UIs. -->
    <string name="phoneAppLabel" product="default">Phone Services</string>

    <!-- Screen title for Emergency Dialer UI -->
    <string name="emergencyDialerIconLabel">Emergency Dialer</string>
    <!-- Activity label for the in-call UI -->
    <string name="phoneIconLabel">Phone</string>
    <!-- Title of FDN list screen -->
    <string name="fdnListLabel">FDN list</string>

    <!-- Call status -->
    <!-- Incoming call screen, name of "unknown" caller -->
    <string name="unknown">Unknown</string>
    <!-- Incoming call screen, string when number hidden -->
    <string name="private_num">Private number</string>
    <!-- Incoming call screen, string when called from a pay phone -->
    <string name="payphone">Payphone</string>
    <!-- In-call screen: status label for a call that's on hold -->
    <string name="onHold">On hold</string>
    <!-- Title for carrier MMI message -->
    <string name="carrier_mmi_msg_title"><xliff:g id="mmicarrier" example="T-Mobile">%s</xliff:g> Message</string>
    <!-- Default title for carrier MMI message -->
    <string name="default_carrier_mmi_msg_title">Carrier Message</string>
    <!-- Possible error messages with outgoing calls --><skip/>
    <string name="mmiStarted">MMI code started</string>
    <!-- Dialog label when a USSD code starts running -->
    <string name="ussdRunning">USSD code running\u2026</string>
    <!-- Dialog label when an MMI code is canceled -->
    <string name="mmiCancelled">MMI code canceled</string>
    <!-- Label for "cancel" button on the MMI dialog -->
    <string name="cancel">Cancel</string>
    <!-- Toast string displayed to user if the input in MMI dialog is < 1 or > 160 -->
    <string name="enter_input">USSD message must be between <xliff:g id="min_len" >%1$d</xliff:g> and <xliff:g id="max_len" >%2$d</xliff:g> characters. Please try again.</string>

    <!-- Label for "Manage conference call" panel [CHAR LIMIT=40] -->
    <string name="manageConferenceLabel">Manage conference call</string>

    <!-- Positive button label ("OK") used in several dialogs in the phone UI [CHAR LIMIT=10] -->
    <string name="ok">OK</string>

    <!-- "Audio mode" popup menu: Item label to select the speakerphone [CHAR LIMIT=25] -->
    <string name="audio_mode_speaker">Speaker</string>
    <!-- "Audio mode" popup menu: Item label to select the handset earpiece [CHAR LIMIT=25] -->
    <string name="audio_mode_earpiece">Handset earpiece</string>
    <!-- "Audio mode" popup menu: Item label to select the wired headset [CHAR LIMIT=25] -->
    <string name="audio_mode_wired_headset">Wired headset</string>
    <!-- "Audio mode" popup menu: Item label to select the bluetooth headset [CHAR LIMIT=25] -->
    <string name="audio_mode_bluetooth">Bluetooth</string>

    <!-- post dial -->
    <!-- In-call screen: body text of the dialog that appears when we encounter
         the "wait" character in a phone number to be dialed; this dialog asks the
         user if it's OK to send the numbers following the "wait". -->
    <string name="wait_prompt_str">Send the following tones?\n</string>
    <!-- In-call screen: body text of the dialog that appears when we encounter
         the "PAUSE" character in a phone number to be dialed; this dialog gives
         informative message to the user to show the sending numbers following the "Pause". -->
    <string name="pause_prompt_str">Sending tones\n</string>
    <!-- In-call screen: button label on the "wait" prompt dialog -->
    <string name="send_button">Send</string>
    <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
    <string name="pause_prompt_yes">Yes</string>
    <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
    <string name="pause_prompt_no">No</string>
    <!-- In-call screen: on the "wild" character dialog, this is the label
         for a text widget that lets the user enter the digits that should
         replace the "wild" character. -->
    <string name="wild_prompt_str">Replace wild character with</string>

    <!-- missing voicemail number -->
    <!-- Title of the "Missing voicemail number" dialog -->
    <string name="no_vm_number">Missing voicemail number</string>
    <!-- Body text of the "Missing voicemail number" dialog -->
    <string name="no_vm_number_msg">No voicemail number is stored on the SIM card.</string>
    <!-- Button label on the "Missing voicemail number" dialog -->
    <string name="add_vm_number_str">Add number</string>
    <!--Toast in Call settings when asked to launch voicemail for a guest user -->
    <string name="voice_number_setting_primary_user_only">Voicemail Settings can only be modified by the Primary User.</string>

    <!-- Status message displayed on SIM PIN unlock panel -->
    <string name="puk_unlocked">Your SIM card has been unblocked. Your phone is unlocking\u2026</string>
    <!-- network depersonalization -->
    <!-- Label text for PIN entry widget on SIM Network Depersonalization panel -->
    <string name="label_ndp">SIM network unlock PIN</string>
    <!-- Label text for Operator displayName on SIM Network Depersonalization panel -->
    <string name="label_phoneid">SIM locked for operator</string>
    <!-- Button label on SIM Network Depersonalization panel -->
    <string name="sim_ndp_unlock_text">Unlock</string>
    <!-- Button label on SIM Network Depersonalization panel -->
    <string name="sim_ndp_dismiss_text">Dismiss</string>
    <!-- Status message displayed on SIM Network Depersonalization panel -->
    <string name="requesting_unlock">Requesting network unlock\u2026</string>
    <!-- Error message displayed on SIM Network Depersonalization panel -->
    <string name="unlock_failed">Network unlock request unsuccessful.</string>
    <!-- Success message displayed on SIM Network Depersonalization panel -->
    <string name="unlock_success">Network unlock successful.</string>

    <!-- settings strings -->

    <!-- Error message for users that aren't allowed to modify Mobile Network settings [CHAR LIMIT=none] -->
    <string name="mobile_network_settings_not_available">Mobile network settings are not available for this user</string>
    <!-- GSM Call settings screen, setting option name. [CHAR LIMIT=40] -->
    <string name="labelGSMMore">GSM call settings</string>
    <!-- GSM Call settings screen, setting option name with label indicating the SIM the settings
         are applied to. [CHAR LIMIT=40] -->
    <string name="labelGsmMore_with_label">GSM call settings (<xliff:g id="subscriptionlabel" example="T-Mobile">%s</xliff:g>)</string>
    <!-- CDMA Call settings screen, setting option name -->
    <string name="labelCDMAMore">CDMA call settings</string>
    <!-- CDMA Call settings screen, setting option name with label indicating the SIM the settings
         are applied to. [CHAR LIMIT=40] -->
    <string name="labelCdmaMore_with_label">CDMA call settings (<xliff:g id="subscriptionlabel" example="Verizon">%s</xliff:g>)</string>
    <!-- Mobile network settings screen, setting option name -->
    <string name="apn_settings">Access Point Names</string>
    <!-- Label for the "Network settings" screen in the Settings UI -->
    <string name="settings_label">Network settings</string>

    <!-- Label for settings screen for phone accounts. -->
    <string name="phone_accounts">Calling accounts</string>
    <!-- Label for list item which opens a dialog to select the default outgoing account -->
    <string name="phone_accounts_make_calls_with">Make calls with</string>
    <!-- Label for list item which opens a dialog to select the default outgoing account for SIP calls. -->
    <string name="phone_accounts_make_sip_calls_with">Make SIP calls with</string>
    <!-- Entry in dialog to "ask first" for accounts when making a call -->
    <string name="phone_accounts_ask_every_time">Ask first</string>
    <!-- Account label for when a SIM account has no service (i.e. airplane mode) -->
    <string name="phone_accounts_default_account_label">No network available</string>

    <!-- Label for heading of the per-account settings section in the phone accounts settings
         screen. -->
    <string name="phone_accounts_settings_header">Settings</string>
    <!-- Label for invoking phone account selection screen -->
    <string name="phone_accounts_choose_accounts">Choose accounts</string>
    <!-- Label for heading in the phone account selection screen -->
    <string name="phone_accounts_selection_header">Phone accounts</string>
    <!-- Title for the button to add a new sip account. [CHAR LIMIT=NONE] -->
    <string name="phone_accounts_add_sip_account">Add SIP account</string>
    <!-- Description label for icon to configure a phone account's settings. -->
    <string name="phone_accounts_configure_account_settings">Configure account settings</string>
    <!-- Label for heading that takes user to the list of calling accounts where they can enable
         and disable all accounts. -->
    <string name="phone_accounts_all_calling_accounts">All calling accounts</string>
    <!-- Summary for all-calling-account setting indicating that is where the user goes to enable
         and disable phone accounts. -->
    <string name="phone_accounts_all_calling_accounts_summary">Select which accounts can make calls</string>

    <!-- Title for setting to select Wi-Fi call manager account -->
    <string name="wifi_calling">Wi-Fi calling</string>
    <!-- Built-in label for the default connection service setting. -->
    <string name="connection_service_default_label">Built-in connection service</string>
    <!-- Call settings screen, setting option name -->
    <string name="voicemail">Voicemail</string>
    <!-- Title of the "Voicemail" settings screen, with a text label identifying which SIM the settings are for. -->
    <string name="voicemail_settings_with_label">Voicemail (<xliff:g id="subscriptionlabel" example="Mock Carrier">%s</xliff:g>)</string>
    <!-- Call forwarding dialog box, voicemail number prefix -->
    <string name="voicemail_abbreviated">VM:</string>
    <!-- DO NOT TRANSLATE. Internal key for a voicemail notification preference. -->
    <string name="voicemail_notifications_key" translatable="false">voicemail_notification_key</string>

    <!-- Title for Make and receive calls category. -->
    <string name="make_and_receive_calls">Make &amp; receive calls</string>
    <!-- Title for the button to launch smart forwarding which will configure call forwarding on both SIMs to forward the call to the other SIM number when its not reachable. -->
    <string name="smart_forwarding_settings_menu">Smart Forwarding</string>
    <!-- Description of smart forwarding setting. -->
    <string name="smart_forwarding_settings_menu_summary">When one number isn\'t reachable, always forward calls to your other number</string>

    <!-- Voicemail notifications title. The user clicks on this preference navigate to the system settings screen for that channel
    .[CHAR LIMIT=30] -->
    <string name="voicemail_notifications_preference_title">Notifications</string>
    <!-- Cell Broadcast settings title.  [CHAR LIMIT=50] -->
    <string name="cell_broadcast_settings">Emergency broadcasts</string>
    <!-- Call settings screen title -->
    <string name="call_settings">Call settings</string>
    <!-- GSM Call settings screen, setting option name -->
    <string name="additional_gsm_call_settings">Additional settings</string>
    <!-- GSM Call settings screen, setting option name, with label identifying the SIM the settings are for. -->
    <string name="additional_gsm_call_settings_with_label">Additional settings (<xliff:g id="subscriptionlabel" example="Verizon">%s</xliff:g>)</string>
    <!-- GSM-only Call settings screen, setting option name-->
    <string name="sum_gsm_call_settings">Additional GSM only call settings</string>
    <!-- CDMA Call settings screen, setting option name -->
    <string name="additional_cdma_call_settings">Additional CDMA call settings</string>
    <!-- CDMA-only Call settings screen, setting option name-->
    <string name="sum_cdma_call_settings">Additional CDMA only call settings</string>
    <!-- Call setting screen, nework service setting name -->
    <string name="labelNwService">Network service settings</string>
    <!-- Call settings screen, setting option name -->
    <string name="labelCallerId">Caller ID</string>
    <!-- Additional call settings screen, setting summary text when the setting is being loaded [CHAR LIMIT=40] -->
    <string name="sum_loading_settings">Loading settings\u2026</string>
    <!-- Additional call settings screen, setting summary text when Caller ID is hidden -->
    <string name="sum_hide_caller_id">Number hidden in outgoing calls</string>
    <!-- Additional call settings screen, setting summary text when Caller ID is shown -->
    <string name="sum_show_caller_id">Number displayed in outgoing calls</string>
    <!-- Additional call settings screen, setting summary text for default Caller ID value -->
    <string name="sum_default_caller_id">Use default operator settings to display my number in outgoing calls</string>
    <!-- Additional call settings screen, setting check box name -->
    <string name="labelCW">Call waiting</string>
    <!-- Additional call settings screen, setting summary text when call waiting check box is selected -->
    <string name="sum_cw_enabled">During a call, notify me of incoming calls</string>
    <!-- Additional call settings screen, setting summary text when call waiting check box is clear -->
    <string name="sum_cw_disabled">During a call, notify me of incoming calls</string>
    <!-- Call forwarding settings screen, section heading -->
    <string name="call_forwarding_settings">Call forwarding settings</string>
    <!-- Call forwarding settings screen, section heading, with a label identifying the SIM the settings are for. -->
    <string name="call_forwarding_settings_with_label">Call forwarding settings (<xliff:g id="subscriptionlabel" example="Verizon">%s</xliff:g>)</string>
    <!-- Call settings screen, setting option name -->
    <string name="labelCF">Call forwarding</string>

    <!-- Call forwarding settings screen, setting option name -->
    <string name="labelCFU">Always forward</string>
    <!-- Call forwarding dialog box, text field label -->
    <string name="messageCFU">Always use this number</string>
    <!-- Call forwarding settings screen, setting summary text when forwarding all calls -->
    <string name="sum_cfu_enabled_indicator">Forwarding all calls</string>
    <!-- Call forwarding settings screen, setting summary text the Always forward is set -->
    <string name="sum_cfu_enabled">Forwarding all calls to <xliff:g id="phonenumber" example="555-1212">{0}</xliff:g></string>
    <!-- Call forwarding settings screen, Always forward is enabled but the number is unavailable -->
    <string name="sum_cfu_enabled_no_number">Number is unavailable</string>
    <!-- Call forwarding settings screen, setting summary text when Always forward is disabled -->
    <string name="sum_cfu_disabled">Off</string>

    <!-- Call forwarding settings screen, setting option name -->
    <string name="labelCFB">When busy</string>
    <!-- Call forwarding dialog box, text field label -->
    <string name="messageCFB">Number when busy</string>
    <!-- Call forwarding settings screen, setting summary text when forwarding to specific number when busy -->
    <string name="sum_cfb_enabled">Forwarding to <xliff:g id="phonenumber" example="555-1212">{0}</xliff:g></string>
    <!-- Call forwarding settings screen, setting summary text when forwarding when busy is disabled -->
    <string name="sum_cfb_disabled">Off</string>
    <!-- Error message displayed after failing to disable forwarding calls when the phone is busy -->
    <string name="disable_cfb_forbidden">Your operator doesn\'t support disabling call forwarding when your phone is busy.</string>

    <!-- Call forwarding settings screen, setting option name -->
    <string name="labelCFNRy">When unanswered</string>
    <!-- Call forwarding dialog box, text field label -->
    <string name="messageCFNRy">Number when unanswered</string>
    <!-- Call forwarding settings screen, setting summary text when forwarding to a specific number when unanswered -->
    <string name="sum_cfnry_enabled">Forwarding to <xliff:g id="phonenumber" example="555-1212">{0}</xliff:g></string>
    <!-- Call forwarding settings screen, setting summary text when Forward when unanswered is disabled -->
    <string name="sum_cfnry_disabled">Off</string>
    <!-- Error message displayed after failing to disable forwarding calls when the phone does not answer -->
    <string name="disable_cfnry_forbidden">Your operator doesn\'t support disabling call forwarding when your phone doesn\'t answer.</string>

    <!-- Call forwarding settings screen, setting option name -->
    <string name="labelCFNRc">When unreachable</string>
    <!-- Call forwarding dialog box, text field label -->
    <string name="messageCFNRc">Number when unreachable</string>
    <!-- Call forwarding settings screen, setting summary text when forwarding to a specific number when unreachable-->
    <string name="sum_cfnrc_enabled">Forwarding to <xliff:g id="phonenumber" example="555-1212">{0}</xliff:g></string>
    <!-- Call forwarding settings screen, setting summary text when Forward when unreachable is disabled -->
    <string name="sum_cfnrc_disabled">Off</string>
    <!-- Error message displayed after failing to disable forwarding calls when the phone is unreachable -->
    <string name="disable_cfnrc_forbidden">Your carrier doesn\'t support disabling call forwarding when your phone is unreachable.</string>
    <string name="registration_cf_forbidden">Your carrier doesn\'t support call forwarding.</string>

    <!-- Cdma Call waiting settings screen, setting option name -->
    <string name="cdma_call_waiting">Turn on call waiting?</string>
    <string name="enable_cdma_call_waiting_setting">During a call, you\'ll be notified about incoming calls</string>
    <string name="enable_cdma_cw">Turn on</string>
    <string name="disable_cdma_cw">Cancel</string>
    <string name="cdma_call_waiting_in_ims_on">CDMA Call Waiting under IMS On</string>
    <string name="cdma_call_waiting_in_ims_off">CDMA Call Waiting under IMS Off</string>

    <!-- Title of the progress dialog displayed while updating Call settings -->
    <string name="updating_title">Call settings</string>
    <!-- Toast in Call settings when asked to launch settings for a secondary user -->
    <string name="call_settings_admin_user_only">Call settings can only be changed by the admin user.</string>
    <!-- Toast in Phone Account settings when asked to launch settings for a secondary/guest user -->
    <string name="phone_account_settings_user_restriction">Phone account settings can only be changed by the admin or work user.</string>
    <!-- Title of the "Call settings" settings screen, with a text label identifying which SIM the settings are for. -->
    <string name="call_settings_with_label">Settings (<xliff:g id="subscriptionlabel" example="Mock Carrier">%s</xliff:g>)</string>
    <!-- Title of the alert dialog displayed if an error occurs while updating Call settings -->
    <string name="error_updating_title">Call settings error</string>
    <!-- Toast in Call settings dialog while settings are being read -->
    <string name="reading_settings">Reading settings\u2026</string>
    <!-- Toast in Call settings dialog while settings are being saved -->
    <string name="updating_settings">Updating settings\u2026</string>
    <!-- Toast in Call settings dialog while settings are being reverted -->
    <string name="reverting_settings">Reverting settings\u2026</string>
    <!-- Status message displayed in the "Call settings error" dialog -->
    <string name="response_error">Unexpected response from network.</string>
    <!-- Status message displayed in the "Call settings error" dialog -->
    <string name="exception_error">Network or SIM card error.</string>
    <!-- Status message displayed in the "Call settings error" dialog when
         current SS request is modified to a different request by STK CC -->
    <string name="stk_cc_ss_to_dial_error">SS request changed to regular call</string>
    <string name="stk_cc_ss_to_ussd_error">SS request changed to USSD request</string>
    <string name="stk_cc_ss_to_ss_error">Changed to new SS request</string>
    <string name="stk_cc_ss_to_dial_video_error">SS request changed to video call</string>

    <!-- Status message displayed in the "Call settings error" dialog when operation fails due to FDN
         [CHAR LIMIT=NONE] -->
    <string name="fdn_check_failure">Your Phone app\'s Fixed Dialing Numbers setting is turned on. As a result, some call-related features aren\'t working.</string>
    <!-- Status message displayed in the "Call settings error" dialog -->
    <string name="radio_off_error">Turn on the radio before viewing these settings.</string>
    <!-- Button label used to dismiss the "Call settings error" dialog -->
    <string name="close_dialog">OK</string>
    <!-- Button label used in several settings-related dialogs -->
    <string name="enable">Turn on</string>
    <!-- Button label used in several settings-related dialogs -->
    <string name="disable">Turn off</string>
    <!-- Button label which indicates the user wants to update a stored
         phone number; used in several settings-related dialogs -->
    <string name="change_num">Update</string>
    <!-- Phone settings: Caller ID preference values -->
    <string-array name="clir_display_values">
        <!-- Phone settings "Caller ID" preference option: use the default value -->
        <item>Network default</item>
        <!-- Phone settings "Caller ID" preference option: hide outgoing Caller ID info -->
        <item>Hide number</item>
        <!-- Phone settings "Caller ID" preference option: show outgoing Caller ID info -->
        <item>Show number</item>
    </string-array>
    <!-- Phone settings: Internal keys used for Caller ID preference values.  DO NOT TRANSLATE. -->
    <string-array name="clir_values" translatable="false">
        <!-- Phone settings: Internal key used for Caller ID preference values.  DO NOT TRANSLATE. -->
        <item><xliff:g>DEFAULT</xliff:g></item>
        <!-- Phone settings: Internal key used for Caller ID preference values.  DO NOT TRANSLATE. -->
        <item><xliff:g>HIDE</xliff:g></item>
        <!-- Phone settings: Internal key used for Caller ID preference values.  DO NOT TRANSLATE. -->
        <item><xliff:g>SHOW</xliff:g></item>
    </string-array>

    <!-- voicemail setting strings --><skip/>
    <!-- Call settings screen, Set voicemail number dialog text -->
    <string name="vm_changed">Voicemail number changed.</string>
    <!-- Call settings screen, Set voicemail number dialog text -->
    <string name="vm_change_failed">Couldn\'t change the voicemail number.\nContact your carrier if this problem persists.</string>
    <!-- Call settings screen, displayed when vm provider supplied forwarding number change fails-->
    <string name="fw_change_failed">Couldn\'t change the forwarding number.\nContact your carrier if this problem persists.</string>
    <!-- Call settings screen, displayed when forwarding number read fails-->
    <string name="fw_get_in_vm_failed">Couldn\'t retrieve and save current forwarding number settings.\nSwitch to the new provider anyway?</string>
    <!-- Call settings screen, Set voicemail number dialog text -->
    <string name="no_change">No changes were made.</string>
    <!-- Call settings screen, "Voicemail" provider setting summary text when no provider is selected -->
    <string name="sum_voicemail_choose_provider">Choose voicemail service</string>
    <!-- Call settings screen, "Voicemail" screen, default option - Your Carrier -->
    <string name="voicemail_default">Your carrier</string>

    <!-- Hint for the old PIN field in the change vociemail PIN dialog -->
    <string name="vm_change_pin_old_pin">Old PIN</string>
    <!-- Hint for the new PIN field in the change vociemail PIN dialog -->
    <string name="vm_change_pin_new_pin">New PIN</string>

    <!-- Message on the dialog when PIN changing is in progress -->
    <string name="vm_change_pin_progress_message">Please wait.</string>
    <!-- Error message for the voicemail PIN change if the PIN is too short -->
    <string name="vm_change_pin_error_too_short">The new PIN is too short.</string>
    <!-- Error message for the voicemail PIN change if the PIN is too long -->
    <string name="vm_change_pin_error_too_long">The new PIN is too long.</string>
    <!-- Error message for the voicemail PIN change if the PIN is too weak -->
    <string name="vm_change_pin_error_too_weak">The new PIN is too weak. A strong password should not have continuous sequence or repeated digits.</string>
    <!-- Error message for the voicemail PIN change if the old PIN entered doesn't match  -->
    <string name="vm_change_pin_error_mismatch">The old PIN does not match.</string>
    <!-- Error message for the voicemail PIN change if the new PIN contains invalid character -->
    <string name="vm_change_pin_error_invalid">The new PIN contains invalid characters.</string>
    <!-- Error message for the voicemail PIN change if operation has failed -->
    <string name="vm_change_pin_error_system_error">Unable to change PIN</string>
    <!-- Message to replace the transcription if a visual voicemail message is not supported-->
    <string name="vvm_unsupported_message_format">Unsupported message type, call <xliff:g id="number" example="*86">%s</xliff:g> to listen.</string>

    <!-- networks setting strings --><skip/>
    <!-- Mobile network settings screen title/heading -->
    <string name="network_settings_title">Mobile network</string>
    <!-- Available networks screen title/heading -->
    <string name="label_available">Available networks</string>
    <!-- Mobile network settings screen, toast when searching for available networks -->
    <string name="load_networks_progress">Searching\u2026</string>
    <!-- Available networks screen, text when no networks are found -->
    <string name="empty_networks_list">No networks found.</string>
    <!-- Available networks screen, toast when an error is encountered when searching for networks -->
    <string name="network_query_error">Couldn\'t find networks. Try again.</string>
    <!-- Available networks screen, toast when registering on a specific network -->
    <string name="register_on_network">Registering on <xliff:g id="network">%s</xliff:g>\u2026</string>
    <!-- Available networks screen, toast when SIM card isn't allowed on a network -->
    <string name="not_allowed">Your SIM card doesn\'t allow a connection to this network.</string>
    <!-- Available networks screen, toast when unable to connect to a network temporarily -->
    <string name="connect_later">Can\'t connect to this network right now. Try again later.</string>
    <!-- Available networks screen, toast when registered on a specific network -->
    <string name="registration_done">Registered on network.</string>
    <!-- Available networks, toast when user selects automatic selection  -->
    <string name="already_auto">Already in automatic selection.</string>
    <!-- Available networks screen, name of switch button for whether to select network automatically -->
    <string name="select_automatically">Automatically select network</string>
    <!-- Available networks screen, summary when button disallowed due to permanent automatic mode -->
    <string name="manual_mode_disallowed_summary">Unavailable when connected to %1$s</string>
    <!-- Available networks screen, name of button when user wants to select network manually  -->
    <string name="network_select_title">Network</string>
    <string name="register_automatically">Automatic registration\u2026</string>
    <string name="preferred_network_mode_title">Preferred network type</string>
    <string name="preferred_network_mode_summary">Change the network operating mode</string>
    <string name="preferred_network_mode_dialogtitle">Preferred network type</string>
    <string name="forbidden_network">(forbidden)</string>
    <!-- Available networks screen, name of button when user wants to select network manually  -->
    <string name="choose_network_title">Choose network</string>
    <!-- Available networks screen, text when no networks connected -->
    <string name="network_disconnected">Disconnected</string>
    <!-- Available networks screen, text when network connected -->
    <string name="network_connected">Connected</string>
    <!-- Available networks screen, text when a network is connecting -->
    <string name="network_connecting">Connecting...</string>
    <!-- Available networks screen, text when a network cannot be connected -->
    <string name="network_could_not_connect">Couldn’t connect</string>

    <!-- The preferred network modes in Mobile network settings -->
    <string-array name="preferred_network_mode_choices">
        <item>GSM/WCDMA preferred</item>
        <item>GSM only</item>
        <item>WCDMA only</item>
        <item>GSM/WCDMA auto</item>
        <item>CDMA/EvDo auto</item>
        <item>CDMA w/o EvDo</item>
        <item>EvDo only</item>
        <item>CDMA/EvDo/GSM/WCDMA</item>
        <item>CDMA + LTE/EvDo</item>
        <item>GSM/WCDMA/LTE</item>
        <item>Global</item>
        <item>LTE</item>
        <item>LTE / WCDMA</item>
        <item>TDSCDMA only</item>
        <item>TDSCDMA/WCDMA</item>
        <item>LTE/TDSCDMA</item>
        <item>TDSCDMA/GSM</item>
        <item>LTE/TDSCDMA/GSM</item>
        <item>TDSCDMA/GSM/WCDMA</item>
        <item>LTE/TDSCDMA/WCDMA</item>
        <item>LTE/TDSCDMA/GSM/WCDMA</item>
        <item>TDSCDMA/CDMA/EVDO/GSM/WCDMA </item>
        <item>LTE/TDSCDMA/CDMA/EVDO/GSM/WCDMA</item>
        <item>NR only</item>
        <item>NR/LTE</item>
        <item>NR/LTE/CDMA/EvDo</item>
        <item>NR/LTE/GSM/WCDMA</item>
        <item>NR/LTE/CDMA/EvDo/GSM/WCDMA</item>
        <item>NR/LTE/WCDMA</item>
        <item>NR/LTE/TDSCDMA</item>
        <item>NR/LTE/TDSCDMA/GSM</item>
        <item>NR/LTE/TDSCDMA/WCDMA</item>
        <item>NR/LTE/TDSCDMA/GSM/WCDMA</item>
        <item>NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA</item>
    </string-array>
    <!-- The preferred network modes RIL constants, in order of the modes above,
         e.g. the choice "GSM/WCDMA preferred" has the corresponding value "0" -->
    <string-array name="preferred_network_mode_values"  translatable="false">
        <item>"0"</item>
        <item>"1"</item>
        <item>"2"</item>
        <item>"3"</item>
        <item>"4"</item>
        <item>"5"</item>
        <item>"6"</item>
        <item>"7"</item>
        <item>"8"</item>
        <item>"9"</item>
        <item>"10"</item>
        <item>"11"</item>
        <item>"12"</item>
        <item>"13"</item>
        <item>"14"</item>
        <item>"15"</item>
        <item>"16"</item>
        <item>"17"</item>
        <item>"18"</item>
        <item>"19"</item>
        <item>"20"</item>
        <item>"21"</item>
        <item>"22"</item>
        <item>"23"</item>
        <item>"24"</item>
        <item>"25"</item>
        <item>"26"</item>
        <item>"27"</item>
        <item>"28"</item>
        <item>"29"</item>
        <item>"30"</item>
        <item>"31"</item>
        <item>"32"</item>
        <item>"33"</item>
    </string-array>

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

    <!-- Mobile network settings screen, name for call settings category -->
    <string name="call_category">Calling</string>
    <!-- Mobile network settings screen, name for network operator category -->
    <string name="network_operator_category">Network</string>

    <!-- Mobile network 4G title [CHAR LIMIT=30] -->
    <string name="enhanced_4g_lte_mode_title">Enhanced 4G LTE Mode</string>
    <!-- Carrier variant of Enhaced 4G LTE Mode title.  [CHAR LIMIT=50] -->
    <string-array name="enhanced_4g_lte_mode_title_variant">
        <!-- 0: Default -->
        <item>@string/enhanced_4g_lte_mode_title</item>
        <!-- 1: Verizon -->
        <item>Advanced Calling</item>
        <!-- 2: O2 UK -->
        <item>4G Calling</item>
    </string-array>

    <!-- Mobile network 4G summary [CHAR LIMIT=80] -->
    <string name="enhanced_4g_lte_mode_summary">Use LTE services to improve voice and other communications (recommended)</string>
    <string name="enhanced_4g_lte_mode_summary_o2">Use 4G services to improve voice and other communications (recommended)</string>
    <!-- Carrier variant of Enhaced 4G LTE Mode summary.  [CHAR LIMIT=80] -->
    <string-array name="enhanced_4g_lte_mode_sumary_variant">
        <!-- 0: Default -->
        <item>@string/enhanced_4g_lte_mode_summary</item>
        <!-- 1: Verizon -->
        <item>@string/enhanced_4g_lte_mode_summary</item>
        <!-- 2: O2 UK -->
        <item>@string/enhanced_4g_lte_mode_summary_o2</item>
    </string-array>

    <!-- Mobile network settings screen, data enabling checkbox name -->
    <string name="data_enabled">Data enabled</string>
    <!-- Mobile network settings screen, setting summary text when check box is not selected (explains what selecting it would do) [CHAR LIMITS=40] -->
    <string name="data_enable_summary">Allow data usage</string>
    <!-- Mobile network settings screen, title for alert dialog -->
    <string name="dialog_alert_title">Attention</string>
    <!-- Mobile network settings screen, setting check box name -->
    <string name="roaming">Roaming</string>
    <!-- Mobile network settings screen, setting summary text when check box is selected -->
    <string name="roaming_enable">Connect to data services when roaming</string>
    <!-- Mobile network settings screen, setting summary text when check box is clear -->
    <string name="roaming_disable">Connect to data services when roaming</string>
    <!-- Mobile network settings UI: notification message shown when you
         lose data connectivity because you're roaming and you have the
         "data roaming" feature turned off. -->
    <string name="roaming_reenable_message">Data roaming is turned off. Tap to turn on.</string>
    <!-- Mobile network settings UI: notification message shown when you
         are roaming and you have the "data roaming" feature turned on. -->
    <string name="roaming_enabled_message">Roaming charges may apply. Tap to modify.</string>
    <!-- Roaming notification tile, notifying lost of roaming data connection -->
    <string name="roaming_notification_title">Lost mobile data connection</string>
    <!-- Roaming notification tile, notifying continued roaming data connection -->
    <string name="roaming_on_notification_title">Data roaming is on</string>
    <!-- Mobile network settings screen, dialog message when user selects the Data roaming check box -->
    <string name="roaming_warning">You may incur significant charges.</string>
    <!-- Mobile network settings screen, message asking the user to check their pricing with their Carrier, when enabling Data roaming. -->
    <string name="roaming_check_price_warning">Check with your network provider for pricing.</string>
    <!-- Mobile network settings screen, dialog message title when user selects the Data roaming check box -->
    <string name="roaming_alert_title">Allow data roaming?</string>
    <!-- Notification title for limited sim function during dual sim -->
    <string name="limited_sim_function_notification_title">Limited SIM functionality</string>
    <!-- Notification message for limited sim function during dual sim [CHAR LIMIT=80]-->
    <string name="limited_sim_function_with_phone_num_notification_message"><xliff:g id="carrier_name">%1$s</xliff:g> calls and data services may be blocked while using <xliff:g id="phone_number">%2$s</xliff:g>.</string>
    <!-- Notification message for limited sim function during dual sim [CHAR LIMIT=80]-->
    <string name="limited_sim_function_notification_message"><xliff:g id="carrier_name">%1$s</xliff:g> calls and data services may be blocked while using another SIM.</string>
    <!-- Notification title for SIP accounts removed -->
    <string name="sip_accounts_removed_notification_title">Deprecated SIP accounts found and removed</string>
    <!-- Notification message for SIP accoutns removed -->
    <string name="sip_accounts_removed_notification_message">
        SIP calling is no longer supported by Android platform.\nYour existing SIP accounts <xliff:g id="removed_sip_accounts">%s</xliff:g> have been removed.\nPlease confirm your default calling account setting.
    </string>
    <string name="sip_accounts_removed_notification_action">Go to settings</string>
    <!-- Mobile network settings screen, data usage setting check box name -->
    <string name="data_usage_title">App data usage</string>
    <!-- Summary about how much data has been used in a date range [CHAR LIMIT=100] -->
    <string name="data_usage_template"><xliff:g name="amount" example="200 MB">%1$s</xliff:g> mobile data used <xliff:g name="date_range" example="Jan 1 -- Feb 2">%2$s</xliff:g></string>
    <!-- Mobile network settings screen, Advanced button to show more items when clicked [CHAR LIMIT=50] -->
    <string name="advanced_options_title">Advanced</string>
    <!-- Mobile network settings screen, name of the option to manage carrier profiles on devices which support embedded carrier profiles -->
    <string name="carrier_settings_euicc">Carrier</string>
    <!-- Keywords used to search the carrier menu for managing carrier profiles on devices which support embedded carrier profiles. eSIM/eUICC is embedded SIM card used to store this data.  -->
    <string name="keywords_carrier_settings_euicc">carrier, esim, sim, euicc, switch carriers, add carrier</string>
    <!-- Mobile network settings screen, summary of the option to manage carrier profiles on devices which support embedded carrier profiles -->
    <string name="carrier_settings_euicc_summary"><xliff:g id="carrier_name">%1$s</xliff:g> &#8212; <xliff:g id="phone_number">%2$s</xliff:g></string>
    <!-- Mobile network settings screen, title of Mobile Data switch preference -->
    <string name="mobile_data_settings_title">Mobile data</string>
    <!-- Mobile network settings screen, title of Mobile data switch preference -->
    <string name="mobile_data_settings_summary">Access data using mobile network</string>
    <!-- Message to show when user trying to turn off mobile data, in single sim mode [CHAR LIMIT=100]-->
    <string name="data_usage_disable_mobile">Turn off mobile data?</string>
    <!-- When a SIM preference hasn't been selected yet, this string is displayed as the pref summary until the user chooses a SIM subscription from the preference list [CHAR LIMIT=50] -->
    <string name="sim_selection_required_pref">Selection required</string>
    <!-- Title asking user if they wish to change the default sim for cellular data.  [CHAR LIMIT=30] -->
    <string name="sim_change_data_title">Change data SIM?</string>
    <!-- Message confirming the user wishes to change the default data SIM from one to another.  [CHAR LIMIT=NONE] -->
    <string name="sim_change_data_message">Use <xliff:g id="new_sim">%1$s</xliff:g> instead of <xliff:g id="old_sim">%2$s</xliff:g> for mobile data?</string>
    <!-- Mobile network settings screen, title of Wi-Fi calling setting -->
    <string name="wifi_calling_settings_title">Wi-Fi calling</string>
    <!-- Mobile network settings screen, title of Video calling setting -->
    <string name="video_calling_settings_title">Carrier video calling</string>


    <!-- USSD aggregation dialog box: separator strings between messages (new-lines will be added before and after) -->
    <string name="ussd_dialog_sep" translatable="false">----------</string>

    <string name="gsm_umts_options">GSM/UMTS Options</string>
    <string name="cdma_options">CDMA Options</string>

    <!-- Screen option on the mobile network settings to go into data usage settings -->
    <string name="throttle_data_usage">Data usage</string>
    <!-- Data usage settings screen option for checking the current usage -->
    <string name="throttle_current_usage">Data used in current period</string>
    <!-- Data usage settings screen option for time frame-->
    <string name="throttle_time_frame">Data use period</string>
    <!-- Data usage settings screen option for throttling rate-->
    <string name="throttle_rate">Data rate policy</string>
    <!-- Data usage settings screen option for accessing the carrier website-->
    <string name="throttle_help">Learn more</string>

    <string name="throttle_status_subtext"><xliff:g id="used">%1$s</xliff:g> (<xliff:g id="used">%2$d</xliff:g>\u066A) of <xliff:g id="used">%3$s</xliff:g> period maximum\nNext period starts in <xliff:g id="used">%4$d</xliff:g> days (<xliff:g id="used">%5$s</xliff:g>)</string>

    <string name="throttle_data_usage_subtext"><xliff:g id="used">%1$s</xliff:g> (<xliff:g id="used">%2$d</xliff:g>\u066A) of <xliff:g id="used">%3$s</xliff:g> period maximum</string>

    <string name="throttle_data_rate_reduced_subtext"><xliff:g id="used">%1$s</xliff:g> maximum exceeded\nData rate reduced to <xliff:g id="used">%2$d</xliff:g> Kb/s</string>

    <string name="throttle_time_frame_subtext"><xliff:g id="used">%1$d</xliff:g>\u066A of cycle elapsed\nNext period starts in <xliff:g id="used">%2$d</xliff:g> days (<xliff:g id="used">%3$s</xliff:g>)</string>

    <string name="throttle_rate_subtext">Data rate reduced to <xliff:g id="used">%1$d</xliff:g> Kb/s if data use limit is exceeded</string>

    <string name="throttle_help_subtext">More information about your carrier\'s mobile network data use policy</string>

    <string name="cell_broadcast_sms">Cell Broadcast SMS</string>

    <string name="enable_disable_cell_bc_sms">Cell Broadcast SMS</string>
    <string name="cell_bc_sms_enable">Cell Broadcast SMS enabled</string>
    <string name="cell_bc_sms_disable">Cell Broadcast SMS disabled</string>

    <string name="cb_sms_settings">Cell Broadcast SMS settings</string>

    <string name="enable_disable_emergency_broadcast">Emergency Broadcast</string>
    <string name="emergency_broadcast_enable">Emergency Broadcast enabled</string>
    <string name="emergency_broadcast_disable">Emergency Broadcast disabled</string>

    <string name="enable_disable_administrative">Administrative</string>
    <string name="administrative_enable">Administrative enabled</string>
    <string name="administrative_disable">Administrative disabled</string>

    <string name="enable_disable_maintenance">Maintenance</string>
    <string name="maintenance_enable">Maintenance enabled</string>
    <string name="maintenance_disable">Maintenance disabled</string>

    <string name="general_news_settings">General News</string>
    <string name="bf_news_settings">Business and Financial News</string>
    <string name="sports_news_settings">Sports News</string>
    <string name="entertainment_news_settings">Entertainment News</string>

    <string name="enable_disable_local">Local</string>
    <string name="local_enable">Local news enabled</string>
    <string name="local_disable">Local news disabled</string>

    <string name="enable_disable_regional">Regional</string>
    <string name="regional_enable">Regional news enabled</string>
    <string name="regional_disable">Regional news disabled</string>

    <string name="enable_disable_national">National</string>
    <string name="national_enable">National news enabled</string>
    <string name="national_disable">National news disabled</string>

    <string name="enable_disable_international">International</string>
    <string name="international_enable">International news enabled</string>
    <string name="international_disable">International news disabled</string>

    <string name="list_language_title">Language</string>
    <string name="list_language_summary">Select the news language</string>
    <string-array name="list_language_entries">
        <item>English</item>
        <item>French</item>
        <item>Spanish</item>
        <item>Japanese</item>
        <item>Korean</item>
        <item>Chinese</item>
        <item>Hebrew</item>
    </string-array>
    <string-array name="list_language_values">
        <item>"1"</item>
        <item>"2"</item>
        <item>"3"</item>
        <item>"4"</item>
        <item>"5"</item>
        <item>"6"</item>
        <item>"7"</item>
    </string-array>
    <string name="list_language_dtitle">Languages</string>

    <string name="enable_disable_local_weather">Local Weather</string>
    <string name="local_weather_enable">Local Weather enabled</string>
    <string name="local_weather_disable">Local Weather disabled</string>

    <string name="enable_disable_atr">Area Traffic Reports</string>
    <string name="atr_enable">Area Traffic Reports enabled</string>
    <string name="atr_disable">Area Traffic Reports disabled</string>

    <string name="enable_disable_lafs">Local Airport Flight Schedules</string>
    <string name="lafs_enable">Local Airport Flight Schedules enabled</string>
    <string name="lafs_disable">Local Airport Flight Schedules disabled</string>

    <string name="enable_disable_restaurants">Restaurants</string>
    <string name="restaurants_enable">Restaurants enabled</string>
    <string name="restaurants_disable">Restaurants disabled</string>

    <string name="enable_disable_lodgings">Lodgings</string>
    <string name="lodgings_enable">Lodgings enabled</string>
    <string name="lodgings_disable">Lodgings disabled</string>

    <string name="enable_disable_retail_directory">Retail Directory</string>
    <string name="retail_directory_enable">Retail Directory enabled</string>
    <string name="retail_directory_disable">Retail Directory disabled</string>

    <string name="enable_disable_advertisements">Advertisements</string>
    <string name="advertisements_enable">Advertisements enabled</string>
    <string name="advertisements_disable">Advertisements disabled</string>

    <string name="enable_disable_stock_quotes">Stock Quotes</string>
    <string name="stock_quotes_enable">Stock Quotes enabled</string>
    <string name="stock_quotes_disable">Stock Quotes disabled</string>

    <string name="enable_disable_eo">Employment Opportunities</string>
    <string name="eo_enable">Employment Opportunities enabled</string>
    <string name="eo_disable">Employment Opportunities disabled</string>

    <string name="enable_disable_mhh">Medical, Health, and Hospital</string>
    <string name="mhh_enable">Medical, Health, and Hospital enabled</string>
    <string name="mhh_disable">Medical, Health, and Hospital disabled</string>

    <string name="enable_disable_technology_news">Technology News</string>
    <string name="technology_news_enable">Technology News enabled</string>
    <string name="technology_news_disable">Technology News disabled</string>

    <string name="enable_disable_multi_category">Multi-category</string>
    <string name="multi_category_enable">Multi-category enabled</string>
    <string name="multi_category_disable">Multi-category disabled</string>

    <string name="network_recommended">\u0020(recommended)</string>
    <string name="network_5G" translatable="false">5G</string>
    <string name="network_lte_pure" translatable="false">LTE</string>
    <string name="network_4G_pure" translatable="false">4G</string>
    <string name="network_lte">LTE (recommended)</string>
    <string name="network_4G">4G (recommended)</string>
    <string name="network_3G" translatable="false">3G</string>
    <string name="network_2G" translatable="false">2G</string>
    <string name="network_1x" translatable="false">1x</string>
    <string name="network_global">Global</string>

    <string-array name="enabled_networks_except_gsm_choices" translatable="false">
        <item>@string/network_lte</item>
        <item>@string/network_3G</item>
    </string-array>
    <string-array name="enabled_networks_except_gsm_4g_choices" translatable="false">
        <item>@string/network_4G</item>
        <item>@string/network_3G</item>
    </string-array>
    <string-array name="enabled_networks_except_gsm_values" translatable="false">
        <item>"9"</item>
        <item>"0"</item>
    </string-array>

    <string-array name="enabled_networks_except_lte_choices" translatable="false">
        <item>@string/network_3G</item>
        <item>@string/network_2G</item>
    </string-array>
    <string-array name="enabled_networks_except_lte_values" translatable="false">
        <item>"0"</item>
        <item>"1"</item>
    </string-array>

    <string-array name="enabled_networks_except_gsm_lte_choices" translatable="false">
        <item>@string/network_3G</item>
    </string-array>
    <string-array name="enabled_networks_except_gsm_lte_values" translatable="false">
        <item>"0"</item>
    </string-array>

    <string-array name="enabled_networks_choices" translatable="false">
        <item>@string/network_lte</item>
        <item>@string/network_3G</item>
        <item>@string/network_2G</item>
    </string-array>
    <string-array name="enabled_networks_4g_choices" translatable="false">
        <item>@string/network_4G</item>
        <item>@string/network_3G</item>
        <item>@string/network_2G</item>
    </string-array>
    <string-array name="enabled_networks_values" translatable="false">
        <item>"9"</item>
        <item>"0"</item>
        <item>"1"</item>
    </string-array>

    <string-array name="enabled_networks_cdma_choices" translatable="false">
        <item>@string/network_lte</item>
        <item>@string/network_3G</item>
        <item>@string/network_1x</item>
        <item>@string/network_global</item>
    </string-array>
    <string-array name="enabled_networks_cdma_values" translatable="false">
        <item>"8"</item>
        <item>"4"</item>
        <item>"5"</item>
        <item>"10"</item>
    </string-array>

    <string-array name="enabled_networks_cdma_no_lte_choices" translatable="false">
        <item>@string/network_3G</item>
        <item>@string/network_1x</item>
    </string-array>
    <string-array name="enabled_networks_cdma_no_lte_values" translatable="false">
        <item>"4"</item>
        <item>"5"</item>
    </string-array>

    <string-array name="enabled_networks_cdma_only_lte_choices" translatable="false">
        <item>@string/network_lte</item>
        <item>@string/network_global</item>
    </string-array>
    <string-array name="enabled_networks_cdma_only_lte_values" translatable="false">
        <item>"8"</item>
        <item>"10"</item>
    </string-array>

    <string-array name="enabled_networks_tdscdma_choices" translatable="false">
        <item>@string/network_lte</item>
        <item>@string/network_3G</item>
        <item>@string/network_2G</item>
    </string-array>
    <string-array name="enabled_networks_tdscdma_values" translatable="false">
        <item>"22"</item>
        <item>"18"</item>
        <item>"1"</item>
    </string-array>

    <!-- CDMA System select strings -->
    <!-- Mobile network settings screen, setting option name -->
    <string name="cdma_system_select_title">System select</string>
    <!-- Mobile network settings screen, setting summary text -->
    <string name="cdma_system_select_summary">Change the CDMA roaming mode</string>
    <!-- System select settings screen title -->
    <string name="cdma_system_select_dialogtitle">System select</string>
    <string-array name="cdma_system_select_choices">
        <!-- System select dialog screen, setting option name -->
        <item>Home only</item>
        <!-- Remove the following option "Affiliated Networks" from the option list -->
        <!-- <item>Affiliated Networks</item> -->
        <!-- System select dialog screen, setting option name -->
        <item>Automatic</item>
    </string-array>
    <string-array name="cdma_system_select_values" translatable="false">
        <!-- Do not translate. -->
        <item>"0"</item>
        <!-- Remove the following value "1" which corresponds to "Affiliated Networks" above -->
        <!-- <item>"1"</item>  -->
        <!-- Do not translate. -->
        <item>"2"</item>
    </string-array>

    <string name="cdma_subscription_title">CDMA subscription</string>
    <string name="cdma_subscription_summary">Change between RUIM/SIM and NV</string>
    <string name="cdma_subscription_dialogtitle">subscription</string>
    <string-array name="cdma_subscription_choices">
        <item>RUIM/SIM</item>
        <item>NV</item>
    </string-array>
    <string-array name="cdma_subscription_values">
        <item>"0"</item>
        <item>"1"</item>
    </string-array>
    <!-- Preference title with which users can activate CDMA network [CHAR LIMIT=30] -->
    <string name="cdma_activate_device">Activate device</string>
    <!-- Preference title for launching an account manager page for prepaid LTE [CHAR LIMIT=30] -->
    <string name="cdma_lte_data_service">Set up data service</string>

    <!-- A menu item in "Mobile network settings" that allows the user to update the phone
         with mobile operator specific settings. [CHAR LIMIT=25] -->
    <string name="carrier_settings_title">Carrier settings</string>

    <!-- FDN settings strings -->
    <!-- Label for "Fixed Dialing Number" settings in call settings. -->
    <string name="fdn">Fixed Dialing Numbers</string>
    <!-- Title for "Fixed Dialing Number" settings, with a label to identify the SIM the settings
        apply to. -->
    <string name="fdn_with_label">Fixed Dialing Numbers (<xliff:g id="subscriptionlabel" example="Verizon">%s</xliff:g>)</string>

    <!-- Call settings screen, button label that takes you to the Fixed Dialing Number management screen -->
    <string name="manage_fdn_list">FDN list</string>
    <!-- Title for settings screen to manage Fixed Dialing Number contacts, with a label to identify
         the SIM the settings apply to. -->
    <string name="fdn_list_with_label">FDN list (<xliff:g id="subscriptionlabel" example="Verizon">%s</xliff:g>)</string>
    <!-- Call settings screen, preference item label -->
    <string name="fdn_activation">FDN activation</string>
    <!-- Call settings setting option name when FDN is enabled -->
    <string name="fdn_enabled">Fixed Dialing Numbers are enabled</string>
    <!-- Call settings setting option name  when FDN is disabled-->
    <string name="fdn_disabled">Fixed Dialing Numbers are disabled</string>
    <!-- Call settings screen, setting option name -->
    <string name="enable_fdn">Enable FDN</string>
    <!-- Call settings screen, setting option name -->
    <string name="disable_fdn">Disable FDN</string>
    <!-- Call settings screen, setting option name -->
    <string name="change_pin2">Change PIN2</string>
    <!-- Call settings screen, setting option name when FDN is enabled -->
    <string name="enable_fdn_ok">Disable FDN</string>
    <!-- Call settings screen, setting option name when FDN is disabled -->
    <string name="disable_fdn_ok">Enable FDN</string>
    <!-- Call settings screen, setting summary text -->
    <string name="sum_fdn">Manage Fixed Dialing Numbers</string>
    <!-- Call settings, FDN screen, setting option name -->
    <string name="sum_fdn_change_pin">Change PIN for FDN access</string>
    <!-- Call settings, FDN screen, setting option name -->
    <string name="sum_fdn_manage_list">Manage phone number list</string>
    <!-- Voice privacy on CDMA is an added layer of voice encryption. Theoretically, it would be harder to break in to a phone call with this feature enabled. -->
    <string name="voice_privacy">Voice privacy</string>
    <string name="voice_privacy_summary">Enable enhanced privacy mode</string>
    <string name="tty_mode_option_title">TTY mode</string>
    <string name="tty_mode_option_summary">Set TTY mode</string>
    <string name="auto_retry_mode_title">Auto-retry</string>
    <string name="auto_retry_mode_summary">Enable Auto-retry mode</string>
    <!-- TTY Mode change is NOT allowed during a video call -->
    <string name="tty_mode_not_allowed_video_call">TTY Mode change is not allowed during a video call</string>
    <!-- FDN list screen: menu item label -->
    <string name="menu_add">Add contact</string>
    <!-- FDN list screen: menu item label -->
    <string name="menu_edit">Edit contact</string>
    <!-- FDN list screen: menu item label -->
    <string name="menu_delete">Delete contact</string>
    <!-- FDN list screen: menu item label -->
    <string name="menu_dial">Dial contact</string>

    <!-- FDN related strings -->
    <!-- Label for PIN2 entry screen -->
    <string name="get_pin2">Type PIN2</string>
    <!-- "Edit FDN Contact" screen: Label for the "name" text field -->
    <string name="name">Name</string>
    <!-- "Edit FDN Contact" screen: Label for the "number" text field -->
    <string name="number">Number</string>
    <!-- "Edit FDN Contact" screen: Button label for "save" action -->
    <string name="save">Save</string>
    <!-- Title of "Edit FDN Contact" screen for a new contact -->
    <string name="add_fdn_contact">Add fixed dialing number</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="adding_fdn_contact">Adding fixed dialing number\u2026</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="fdn_contact_added">Fixed dialing number added.</string>
    <!-- Title of "Edit FDN Contact" screen when editing an already-existing contact -->
    <string name="edit_fdn_contact">Edit fixed dialing number</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="updating_fdn_contact">Updating fixed dialing number\u2026</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="fdn_contact_updated">Fixed dialing number updated.</string>
    <!-- Title of "Delete FDN Contact" screen -->
    <string name="delete_fdn_contact">Delete fixed dialing number</string>
    <!-- "Delete FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="deleting_fdn_contact">Deleting fixed dialing number\u2026</string>
    <!-- "Delete FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="fdn_contact_deleted">Fixed dialing number deleted.</string>
    <!-- FDN settings: error message displayed in a popup (toast) -->
    <string name="pin2_invalid">FDN wasn\'t updated because you typed an incorrect PIN.</string>
    <!-- FDN settings: error message displayed in a popup (toast) -->
    <string name="fdn_invalid_number">FDN wasn\'t updated because the number exceeds <xliff:g id="FDN_NUMBER_LIMIT_LENGTH">%d</xliff:g> digits.</string>
    <!-- FDN settings: error message displayed in a popup (toast), when the entered
         FDN number was inappropriate, OR, PIN2 the user entered was incorrect.
         Because of API restriction, there's no way to determine which is the exact
         cause of the failure.
         [CHAR LIMIT=NONE] -->
    <string name="pin2_or_fdn_invalid">FDN wasn\'t updated. The PIN2 was incorrect, or the phone number was rejected.</string>
    <!-- FDN settings: error message displayed in a popup (toast) -->
    <string name="fdn_failed">FDN operation failed.</string>

    <!-- ADN related strings -->
    <!-- Placeholder text displayed while loading the list of SIM contacts -->
    <string name="simContacts_emptyLoading">Reading from SIM card\u2026</string>
    <!-- Call settings, string that appears on FDN contact list when there are no contacts on the SIM. -->
    <string name="simContacts_empty">No contacts on your SIM card.</string>
    <!-- Call settings: title of the dialog that lets you select contacts from the SIM. -->
    <string name="simContacts_title">Select contacts to import</string>
    <!-- Appears when user tries to import contacts in SIM during airplane mode [CHAR LIMIT=NONE] -->
    <string name="simContacts_airplaneMode">Turn off airplane mode to import contacts from the SIM card.</string>

    <!-- SIM PIN strings -->
    <!-- Title of "Enable/disable SIM PIN" screen -->
    <string name="enable_pin">Enable/disable SIM PIN</string>
    <!-- Title of "Change SIM PIN" screen -->
    <string name="change_pin">Change SIM PIN</string>
    <!-- SIM PIN screen: label for PIN entry widget -->
    <string name="enter_pin_text">SIM PIN:</string>
    <!-- SIM PIN screen: label for PIN entry widget -->
    <string name="oldPinLabel">Old PIN</string>
    <!-- SIM PIN screen: label for PIN entry widget -->
    <string name="newPinLabel">New PIN</string>
    <!-- SIM PIN screen: label for PIN entry widget -->
    <string name="confirmPinLabel">Confirm new PIN</string>
    <!-- SIM PIN screen: error message -->
    <string name="badPin">The old PIN you typed isn\'t correct. Try again.</string>
    <!-- SIM PIN screen: error message -->
    <string name="mismatchPin">The PINs you typed don\'t match. Try again.</string>
    <!-- SIM PIN screen: error message when PIN is too short or too long -->
    <string name="invalidPin">Type a PIN that is 4 to 8 numbers.</string>
    <!-- Title of "Disable SIM PIN" screen -->
    <string name="disable_sim_pin">Clear SIM PIN</string>
    <!-- Title of "Enable SIM PIN" screen -->
    <string name="enable_sim_pin">Set SIM PIN</string>
    <!-- SIM PIN screen: progress message displayed while enabling -->
    <string name="enable_in_progress">Setting PIN\u2026</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="enable_pin_ok">PIN set</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="disable_pin_ok">PIN cleared</string>
    <!-- SIM PIN screen: error message displayed in a popup (toast) -->
    <string name="pin_failed">PIN incorrect</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="pin_changed">PIN updated</string>
    <!-- SIM PIN screen: error message displayed in a dialog -->
    <string name="puk_requested">Password incorrect. PIN now blocked. PUK requested.</string>

    <!-- SIM PIN2 strings -->
    <!-- SIM PIN2 screen: label for PIN entry widget -->
    <string name="enter_pin2_text">PIN2</string>
    <!-- SIM PIN2 screen: label for PIN entry widget -->
    <string name="oldPin2Label">Old PIN2</string>
    <!-- SIM PIN2 screen: label for PIN entry widget -->
    <string name="newPin2Label">New PIN2</string>
    <!-- SIM PIN2 screen: label for PIN entry widget -->
    <string name="confirmPin2Label">Confirm new PIN2</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="badPuk2">PUK2 incorrect. Try again.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="badPin2">Old PIN2 incorrect. Try again.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="mismatchPin2">PIN2s don\'t match. Try again.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="invalidPin2">Enter a PIN2 that is 4 to 8 numbers.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="invalidPuk2">Enter a PUK2 that is 8 numbers.</string>
    <!-- SIM PIN2 screen: status message displayed in a popup (toast) -->
    <string name="pin2_changed">PIN2 updated</string>
    <!-- SIM PIN2 screen: label for PUK2 entry widget -->
    <string name="label_puk2_code">Enter PUK2 code</string>
    <!-- SIM PIN2 screen: error message displayed in a dialog -->
    <string name="fdn_enable_puk2_requested">Password incorrect. PIN2 now Blocked. To try again, change PIN 2.</string>
    <!-- SIM PIN2 screen: error message displayed in a dialog -->
    <string name="puk2_requested">Password incorrect. SIM now locked. Enter PUK2.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="puk2_blocked">PUK2 is permanently blocked.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="pin2_attempts">\nYou have <xliff:g id="number">%d</xliff:g> remaining attempts.</string>
    <!-- SIM PIN2 screen: error message displayed in a dialog -->
    <string name="puk2_locked">PUK2 locked. Contact service provider to unlock.</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="pin2_unblocked">PIN2 no longer blocked</string>
    <!-- SIM PIN screen: error message shown in dialog when there is a network or sim error.
         [CHAR LIMIT=NONE] -->
    <string name="pin2_error_exception">Network or SIM card error</string>

    <!-- SIM PIN screen: button label -->
    <string name="doneButton">Done</string>

    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
    <string name="fake_phone_activity_phoneNumber_text" translatable="false">(650) 555-1234</string>
    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
    <string name="fake_phone_activity_infoText_text" translatable="false">Incoming phone number</string>
    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
    <string name="fake_phone_activity_placeCall_text" translatable="false">Fake Incoming Call</string>

    <!-- Call settings screen, Set voicemail dialog title -->
    <string name="voicemail_settings_number_label">Voicemail number</string>

    <!-- Card titles -->
    <!-- In-call screen: status label for a call in the "dialing" state -->
    <string name="card_title_dialing">Dialing</string>
    <!-- In-call screen: status label for a re-dialing call -->
    <string name="card_title_redialing">Redialing</string>
    <!-- In-call screen: status label for a conference call -->
    <string name="card_title_conf_call">Conference call</string>
    <!-- In-call screen: status label for an incoming call -->
    <string name="card_title_incoming_call">Incoming call</string>
    <!-- In-call screen: status label displayed briefly after a call ends -->
    <string name="card_title_call_ended">Call ended</string>
    <!-- In-call screen: status label for call that's on hold -->
    <string name="card_title_on_hold">On hold</string>
    <!-- In-call screen: status label for a call that's in the process of hanging up -->
    <string name="card_title_hanging_up">Hanging up</string>
    <!-- In-call screen: status label for a call that's in CDMA flash mode -->
    <string name="card_title_in_call">In call</string>

    <!-- Notification strings -->
    <!-- Label for the "Voicemail" notification item, when expanded. -->
    <string name="notification_voicemail_title">New voicemail</string>
    <!-- Label for the expanded "Voicemail" notification item,
         including a count of messages. -->
    <string name="notification_voicemail_title_count">New voicemail (<xliff:g id="count">%d</xliff:g>)</string>
    <!-- Message displayed in the "Voicemail" notification item, allowing the user
         to dial the indicated number. -->
    <string name="notification_voicemail_text_format">Dial <xliff:g id="voicemail_number">%s</xliff:g></string>
    <!-- Message displayed in the "Voicemail" notification item,
         indicating that there's no voicemail number available -->
    <string name="notification_voicemail_no_vm_number">Voicemail number unknown</string>
    <!-- Label for the "No service" notification item, when expanded. -->
    <string name="notification_network_selection_title">No service</string>
    <!-- Label for the expanded "No service" notification item, including the
         operator name set by user. No space after "network", appended in nonempty value. -->
    <string name="notification_network_selection_text">Selected network<xliff:g id="operator_name">%s</xliff:g> unavailable</string>

    <!-- In-call screen: call failure message displayed in an error dialog. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_power_off" product="watch">Turn on mobile network, turn off airplane mode or turn off battery saver mode to make a call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_power_off" product="default">Turn off airplane mode to make a call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog when in airplane mode, WFC is enabled, not wifi-only, and not connected to wireless networks. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_power_off_wfc">Turn off airplane mode or connect to a wireless network to make a call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog when radio off due to thermal mitigation. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_power_off_thermal" product="default"><b>Phone too hot</b>\n\nCan\'t complete this call. Try again when your phone cools down.\n\nYou can still make emergency calls.</string>
    <!-- In-call screen: call failure message displayed when the user attempts to make a non-emergency call while the phone is in emergency callback mode. -->
    <string name="incall_error_ecm_emergency_only">Exit emergency callback mode to make a non-emergency call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog.
         This string is currently unused (see comments in InCallScreen.java.) -->
    <string name="incall_error_emergency_only">Not registered on network.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_out_of_service">Mobile network not available.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_out_of_service_wfc">Mobile network is not available. Connect to a wireless network to make a call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_no_phone_number_supplied">To place a call, enter a valid number.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_call_failed">Call failed.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_cannot_add_call">Call cannot be added at this time.  You can try to reach out by sending a message.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_unknown">Service not supported</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_switch">Can\'t switch calls.</string>
    <!-- In-call screen: message displayed in an error dialog when the user attempts to resume a
         call, and the system encountered an error which prevented the call from being resumed. -->
    <string name="incall_error_supp_service_resume">Can\'t resume call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_separate">Can\'t separate call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_transfer">Can\'t transfer.</string>
    <!-- In-call screen: message displayed in an error dialog.  Shown when the user attempts to
        merge calls to form a conference call, but there was an error which prevented this from
        occurring. -->
    <string name="incall_error_supp_service_conference">Unable to merge calls.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_reject">Can\'t reject call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_hangup">Can\'t release call(s).</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_hold">Can\'t hold calls.</string>
    <!-- In-call screen: call failure message displayed in an error dialog when WFC is enabled, is wifi-only, and not connected to a wireless network. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_wfc_only_no_wireless_network">Connect to a wireless network to make a call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog when the user is connected to a wireless network, but wifi calling is turned off. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_promote_wfc">Enable Wi-Fi calling to make a call.</string>
    <!-- In-call screen: call failure message displayed in an error dialog when the satellite modem is on. [CHAR_LIMIT=NONE] -->
    <string name="incall_error_satellite_enabled">Disable satellite mode to make a call.</string>

    <!-- Hint for the button of emergency information -->
    <string name="emergency_information_hint">Emergency information</string>
    <!-- Hint for the owner of emergency information -->
    <string name="emergency_information_owner_hint">Owner</string>
    <!-- Hint for confirm the emergency information -->
    <string name="emergency_information_confirm_hint">Tap again to view info</string>
    <!-- Dialog title for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_title">Emergency call</string>
    <!-- Emergency dialer: Title of single emergency shortcut button -->
    <string name="single_emergency_number_title">Emergency number</string>
    <!-- Emergency dialer: Title of numerous emergency shortcut buttons -->
    <string name="numerous_emergency_numbers_title">Emergency numbers</string>
    <!-- Emergency dialer: Hint of selected emergency shortcut button -->
    <string name="emergency_call_shortcut_hint">Tap again to call <xliff:g id="emergency_number">%s</xliff:g></string>
    <!-- Status message for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_message">Turning on radio\u2026</string>
    <!-- Status message for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_retry">No service. Trying again\u2026</string>
    <!-- Toast message shown when user tries to turn on airplane mode while in an emergency call -->
    <string name="radio_off_during_emergency_call">Cannot enter airplane mode during an emergency call.</string>

    <!-- Dialer text on Emergency Dialer -->
    <!-- Emergency dialer: message displayed in an error dialog -->
    <string name="dial_emergency_error">Can\'t call. <xliff:g id="non_emergency_number">%s</xliff:g> is not an emergency number.</string>
    <!-- Emergency dialer: message displayed in an error dialog -->
    <string name="dial_emergency_empty_error">Can\'t call. Dial an emergency number.</string>
    <!-- Message displayed over top of the emergency dialer dialpad indicating to the user that
         emergency calling is not currently available. -->
    <string name="dial_emergency_calling_not_available">Emergency calling not available</string>

    <!-- Only handle pin entry when phone user is system-->
    <string name="pin_puk_system_user_only">Only the owner of the device can enter PIN/PUK codes.</string>

    <!-- Text for description of police calling type -->
    <string name="police_type_description">Police</string>
    <!-- Text for description of ambulance calling type -->
    <string name="ambulance_type_description">Ambulance</string>
    <!-- Text for description of fire calling type -->
    <string name="fire_type_description">Fire</string>

    <!-- Format for concatenating multiple emergency type descriptions. The separator may differ in
         different locales, for example arabic comma "،" is used in some countries. Some languages
         may use full-width separator without leading or trailing spaces, eg. Ideographic comma "、"
         in Chinese and Japanese. -->
    <string name="description_concat_format">%1$s, %2$s</string>

    <!-- Displayed in the text entry box in the dialer when in landscape mode to guide the user
         to dial using the physical keyboard -->
    <string name="dialerKeyboardHintText">Use keyboard to dial</string>

    <!-- Text for the onscreen "Hold" button -->
    <string name="onscreenHoldText">Hold</string>
    <!-- Text for the onscreen "End call" button -->
    <string name="onscreenEndCallText">End</string>
    <!-- Text for the onscreen "Show Dialpad" button -->
    <string name="onscreenShowDialpadText">Dialpad</string>
    <!-- Text for the onscreen "Mute" button -->
    <string name="onscreenMuteText">Mute</string>
    <!-- Text for the onscreen "Add call" button -->
    <string name="onscreenAddCallText">Add call</string>
    <!-- Text for the onscreen "Merge calls" button -->
    <string name="onscreenMergeCallsText">Merge calls</string>
    <!-- Text for the onscreen "Swap calls" button -->
    <string name="onscreenSwapCallsText">Swap</string>
    <!-- Text for the onscreen "Manage calls" button -->
    <string name="onscreenManageCallsText">Manage calls</string>
    <!-- Text for the onscreen "Manage conference" button [CHAR LIMIT=20] -->
    <string name="onscreenManageConferenceText">Manage conference</string>
    <!-- Text for the onscreen "Audio" button that lets you switch
         between speaker / bluetooth / earpiece [CHAR LIMIT=10] -->
    <string name="onscreenAudioText">Audio</string>
    <!-- Text for the onscreen "Video call" button used to change a voice call
         to a video call. [CHAR LIMIT=10] -->
    <string name="onscreenVideoCallText">Video call</string>

    <!-- Menu item label in SIM Contacts: Import a single contact entry from the SIM card -->
    <string name="importSimEntry">Import</string>
    <!-- Menu item label in SIM Contacts: Import all contact entries from the SIM card -->
    <string name="importAllSimEntries">Import all</string>
    <!-- SIM Contacts: status message displayed while importing card -->
    <string name="importingSimContacts">Importing SIM contacts</string>
    <!-- Import a single contact entry from contacts to the SIM card -->
    <string name="importToFDNfromContacts">Import from contacts</string>

    <!-- Message shown when a single contact is imported from SIM card -->
    <string name="singleContactImportedMsg">Imported contact</string>
    <!-- Message shown when a single contact could not be imported from SIM card -->
    <string name="failedToImportSingleContactMsg">Failed to import contact</string>

    <!-- Hearing aid settings -->
    <string name="hac_mode_title">Hearing aids</string>
    <string name="hac_mode_summary">Turn on hearing aid compatibility</string>

    <!-- RTT settings: used to turn on/off Real-Time Text, an accessibility feature similar to
         TTY that allows users to send text over a phone call. -->
    <string name="rtt_mode_title">Real-time text (RTT) call</string>
    <string name="rtt_mode_summary">Allow messaging within a voice call</string>
    <string name="rtt_mode_more_information">
       RTT assists callers who are deaf, hard of hearing, have a speech disability,
       or need more than voice alone.&lt;br>
       &lt;a href="<xliff:g example="http://www.google.com" id="url">http://support.google.com/mobile?p=telephony_rtt</xliff:g>">Learn more&lt;/a>
       &lt;br>&lt;br> - RTT calls are saved as a message transcript
       &lt;br> - RTT is not available for video calls</string>

    <string name="no_rtt_when_roaming">Note: RTT is not available while roaming</string>

    <!-- Service option entries.  -->
    <string-array name="tty_mode_entries">
        <item>TTY Off</item>
        <item>TTY Full</item>
        <item>TTY HCO</item>
        <item>TTY VCO</item>
    </string-array>

    <!-- Do not translate. -->
    <string-array name="tty_mode_values" translatable="false">
        <!-- Do not translate. -->
        <item>0</item>
        <!-- Do not translate. -->
        <item>1</item>
        <!-- Do not translate. -->
        <item>2</item>
        <!-- Do not translate. -->
        <item>3</item>
    </string-array>

    <!-- Dtmf tones settings -->
    <!-- Title for the DTMF Tones options displayed in Call Settings -->
    <string name="dtmf_tones_title">DTMF tones</string>
    <!-- Summary for the DTMF Tones options displayed in Call Settings -->
    <string name="dtmf_tones_summary">Set the length of DTMF tones</string>
    <!-- Options displayed as part of DTMF Tones in Call Settings -->
    <string-array name="dtmf_tone_entries">
      <item>Normal</item>
      <item>Long</item>
    </string-array>
    <!-- Do not translate. -->
    <string-array name="dtmf_tone_values" translatable="false">
       <item>0</item>
       <item>1</item>
    </string-array>

    <!-- Title for the dialog used to display CDMA DisplayInfo -->
    <string name="network_info_message">Network message</string>
    <!-- Title for the dialog used to display a network error message to the user -->
    <string name="network_error_message">Error message</string>

    <!-- OTA-specific strings -->
    <!-- Title shown on OTA screen -->
    <string name="ota_title_activate">Activate your phone</string>
    <!-- Message displayed on the OTA activation screen. -->
    <string name="ota_touch_activate">A special call needs to be made to activate your phone service.
    \n\nAfter pressing \u201CActivate\u201D, listen to the instructions provided to activate your phone.</string>
    <!-- Title shown during Hands Free Activation -->
    <string name="ota_hfa_activation_title">Activating...</string>
    <!-- Message shown during the hands free activation screen of the setup wizard. -->
    <string name="ota_hfa_activation_dialog_message">The phone is activating your mobile data service.\n\nThis can take up to 5 minutes.</string>
    <!-- Title of skip activation dialog -->
    <string name="ota_skip_activation_dialog_title">Skip activation\?</string>
    <!-- Message displayed in skip activation dialog  -->
    <string name="ota_skip_activation_dialog_message">If you skip activation, you can\'t place calls or connect to mobile data networks (though you can connect to Wi-Fi networks). Until you activate your phone, you are asked to activate it each time you turn it on.</string>
    <!-- Label shown on dialog button that allows the user to skip activation -->
    <string name="ota_skip_activation_dialog_skip_label">Skip</string>

    <!-- Button label within the OTA activation screen -->
    <string name="ota_activate">Activate</string>
    <!-- Title text shown when phone activation is successful -->
    <string name="ota_title_activate_success">Phone is activated.</string>
    <!-- Title text shown on screen where activation fails -->
    <string name="ota_title_problem_with_activation">Problem with activation</string>
    <!-- Message displayed on the OTA "listening" screen. This message
         needs to be kept at 2 lines or less to be sure that there's
         enough room for the dialpad. [CHAR LIMIT=80] -->
    <string name="ota_listen">Follow the spoken instructions until you hear that activation is complete.</string>

    <!-- Button label within the OTA listen screen -->
    <string name="ota_speaker">Speaker</string>
    <!-- String to be displayed on OTA listen screen once user has selected the
         correct option to begin provisioning -->
    <string name="ota_progress">Programming your phone\u2026</string>
    <!-- String to display within the OTA Fail Notice dialog -->
    <string name="ota_failure">Couldn\'t program your phone</string>
    <!-- String to be displayed on the OTA Fail/Success screen upon successful provisioning -->
    <string name="ota_successful">Your phone is now activated.  It may take up to 15 minutes for service to start.</string>
    <!-- String to be displayed on the OTA Fail/Success screen upon unsuccessful provisioning -->
    <string name="ota_unsuccessful">Your phone didn\'t activate.
    \nYou may need to find an area with better coverage (near a window, or outside).
    \n\nTry again or call customer service for more options.</string>
    <!-- String to display within the OTA SPC Fail Notice dialog -->
    <string name="ota_spc_failure">EXCESS SPC FAILURES</string>
    <!-- Button label in OTA listen screen that cancels activation and goes to the previous screen -->
    <string name="ota_call_end">Back</string>
    <!-- Button label shown on OTA error screen to allow the user to try again -->
    <string name="ota_try_again">Try again</string>
    <!-- Button label shown on OTA screens that have a next screen -->
    <string name="ota_next">Next</string>

    <!-- Emergency Callback Mode (ECM) -->
    <string name="ecm_exit_dialog">EcmExitDialog</string>
    <!-- ECM: Status bar notification message -->
    <string name="phone_entered_ecm_text">Entered Emergency Callback Mode</string>
    <!-- ECM: Notification title -->
    <string name="phone_in_ecm_notification_title">Emergency Callback Mode</string>
    <!-- ECM: Notification body -->
    <string name="phone_in_ecm_call_notification_text">Data connection disabled</string>
    <!-- ECM: Displays the time when ECM will end, Example: "No Data Connection until 10:45 AM" -->
    <string name="phone_in_ecm_notification_complete_time">No data connection until <xliff:g id="completeTime">%s</xliff:g></string>
    <!-- ECM: Dialog box message for exiting from the notifications screen -->
    <string name="alert_dialog_exit_ecm"> {count, plural,
        <!-- number of minutes is one -->
        =1    {The phone will be in Emergency Callback mode for one minute. While in this mode no apps using a data connection can be used. Do you want to exit now?}
        <!-- number of minutes is not equal to one -->
        other {The phone will be in Emergency Callback mode for %s minutes. While in this mode no applications using a data connection can be used. Do you want to exit now?}
    }</string>
    <!-- ECM: Dialog box message for exiting from any other app -->
    <string name="alert_dialog_not_avaialble_in_ecm"> {count, plural,
        <!-- number of minutes is one -->
        =1    {The selected action isn\'t available while in the Emergency Callback mode. The phone will be in this mode for one minute. Do you want to exit now?}
        <!-- number of minutes is not equal to one -->
        other {The selected action isn\'t available while in the Emergency Callback mode. The phone will be in this mode for %s minutes. Do you want to exit now?}
    }</string>
    <!-- ECM: Dialog box message while in emergency call -->
    <string name="alert_dialog_in_ecm_call">The selected action isn\'t available while in an emergency call.</string>
    <!-- ECM: Progress text -->
    <string name="progress_dialog_exiting_ecm">Exiting Emergency Callback mode</string>
    <!-- ECM: ECM exit dialog choice -->
    <string name="alert_dialog_yes">Yes</string>
    <!-- ECM: ECM exit dialog choice -->
    <string name="alert_dialog_no">No</string>
    <!-- ECM: ECM exit dialog choice -->
    <string name="alert_dialog_dismiss">Dismiss</string>
    <!-- ECM: Notification body wihout data restriction hint -->
    <string name="phone_in_ecm_call_notification_text_without_data_restriction_hint">The phone is in emergency callback mode</string>
    <!-- ECM: Displays the time when ECM will end without data restriction hint, Example: "Until 10:45 AM" -->
    <string name="phone_in_ecm_notification_complete_time_without_data_restriction_hint">Until <xliff:g id="completeTime">%s</xliff:g></string>
    <!-- ECM: Dialog box message without data restriction hint for exiting from the notifications screen -->
    <string name="alert_dialog_exit_ecm_without_data_restriction_hint"> {count, plural,
        <!-- number of minutes is one -->
        =1    {The phone will be in emergency callback mode for one minute.\nDo you want to exit now?}
        <!-- number of minutes is not equal to one -->
        other {The phone will be in emergency callback mode for %s minutes.\nDo you want to exit now?}
    }</string>

    <!-- For incoming calls, this is a string we can get from a CDMA network instead of
         the actual phone number, to indicate there's no number present.  DO NOT TRANSLATE. -->
    <string-array name="absent_num" translatable="false">
        <item>ABSENT NUMBER</item>
        <item>ABSENTNUMBER</item>
    </string-array>

    <!-- Preference for Voicemail service provider under "Voicemail" settings.
         [CHAR LIMIT=40] -->
    <string name="voicemail_provider">Service</string>

    <!-- Preference for Voicemail setting of each provider.
         [CHAR LIMIT=40] -->
    <string name="voicemail_settings">Setup</string>

    <!-- String to display in voicemail number summary when no voicemail num is set -->
    <string name="voicemail_number_not_set">&lt;Not set&gt;</string>

    <!-- Title displayed above settings coming after voicemail in the call features screen -->
    <string name="other_settings">Other call settings</string>

    <!-- Title displayed in the overlay when a call is placed using a 3rd party provider.
         [CHAR LIMIT=40] -->
    <string name="calling_via_template">Calling via <xliff:g id="provider_name">%s</xliff:g></string>

    <!-- Use this as a default to describe the contact photo; currently for screen readers through accessibility. -->
    <string name="contactPhoto">contact photo</string>
    <!-- Use this to describe the separate conference call button; currently for screen readers through accessibility. -->
    <string name="goPrivate">go private</string>
    <!--  Use this to describe the select contact button in EditPhoneNumberPreference; currently for screen readers through accessibility. -->
    <string name="selectContact">select contact</string>

    <!-- Dialog title to notify user that Voice calling is not supported
         on this device. [CHAR LIMIT=40] -->
    <string name="not_voice_capable">Voice calling not supported</string>

    <!-- String describing the Dial ImageButton

         Used by AccessibilityService to announce the purpose of the button.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_dial_button">dial</string>

    <!-- String describing the Dialpad ImageButton

         Used by AccessibilityService to announce the purpose of the button.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_dialpad_button">show dialpad</string>

    <!-- Pane title of the Emergency Dialpad

     Used by AccessibilityService to announce the purpose of the pane of emergency dialpad.
     [CHAR LIMIT=NONE]
    -->
    <string name="pane_title_emergency_dialpad">Emergency Dialpad</string>

    <!-- Visual voicemail on/off title [CHAR LIMIT=40] -->
    <string name="voicemail_visual_voicemail_switch_title">Visual Voicemail</string>

    <!-- Voicemail change PIN dialog title [CHAR LIMIT=40] -->
    <string name="voicemail_set_pin_dialog_title">Set PIN</string>
    <!-- Voicemail change PIN dialog title [CHAR LIMIT=40] -->
    <string name="voicemail_change_pin_dialog_title">Change PIN</string>

    <!-- Title for the category "ringtone", which is shown above ringtone and vibration
         related settings.
         [CHAR LIMIT=30] -->
    <string name="preference_category_ringtone">Ringtone &amp; Vibrate</string>

    <!-- String resource for the font-family to use for the call setting activity's title
         Do not translate. -->
    <string name="call_settings_title_font_family">sans-serif-light</string>

    <!-- Label for PSTN connection service. -->
    <string name="pstn_connection_service_label">Built-in SIM cards</string>

    <!-- Label for enabling video calling. -->
    <string name="enable_video_calling_title">Turn on video calling</string>

    <!-- Message for dialog shown when the user tries to turn on video calling but enhanced 4G LTE
         is disabled. They have to turn on Enhanced 4G LTE capability in network settings first. -->
    <string name="enable_video_calling_dialog_msg">
        To turn on video calling, you need to enable Enhanced 4G LTE Mode in network settings.
    </string>

    <!-- Label for action button in dialog which opens mobile network settings, for video calling
         setting. -->
    <string name="enable_video_calling_dialog_settings">Network settings</string>

    <!-- Label for close button in dialog, for video calling setting. -->
    <string name="enable_video_calling_dialog_close">Close</string>

    <!-- Strings used in Settings->Sim cards for each installed Sim. -->
    <string name="sim_label_emergency_calls">Emergency calls</string>
    <string name="sim_description_emergency_calls">Emergency calling only</string>
    <string name="sim_description_default">SIM card, slot: <xliff:g id="slot_id">%s</xliff:g></string>

    <!-- Title for activity to control accessibility settings such as TTY mode and hearing aid
         compatability. [CHAR LIMIT=40] -->
    <string name="accessibility_settings_activity_title">Accessibility</string>

    <!-- Configuration setting for world mode Format is <true;GID if any to be checked>-->
    <string translatable="false" name="config_world_mode"/>

    <!-- Status hint label for an incoming call over a wifi network which has not been accepted yet.
         [CHAR LIMIT=25] -->
    <string name="status_hint_label_incoming_wifi_call">Wi-Fi call from</string>
    <!-- Status hint label for a call being made over a wifi network. [CHAR LIMIT=25] -->
    <string name="status_hint_label_wifi_call">Wi-Fi call</string>

    <!-- DO NOT TRANSLATE. Internal key for a visual voicemail preference. -->
    <string name="voicemail_visual_voicemail_key">voicemail_visual_voicemail_key</string>
    <!-- DO NOT TRANSLATE. Internal key for a voicemail change pin preference. -->
    <string name="voicemail_change_pin_key">voicemail_change_pin_key</string>
    <!-- DO NOT TRANSLATE. Internal key for tty mode preference. -->
    <string name="tty_mode_key">button_tty_mode_key</string>
    <!-- DO NOT TRANSLATE. Internal key for a voicemail notification preference. -->
    <string name="wifi_calling_settings_key">button_wifi_calling_settings_key</string>

    <!-- Strings for IMAP -->

    <!-- String used in place of a message that could not be properly decoded (e.g. bad base64
       data was received.) [CHAR LIMIT=none] -->
    <string name="message_decode_error">There was an error while decoding the message.</string>

    <!-- Call failure reason: SIM card and roaming capabilities have already been activated. [CHAR LIMIT=NONE]-->
    <string name="callFailed_cdma_activation">
        A SIM card has activated your service and updated your phone\'s roaming capabilities.
    </string>

    <!-- Call failure reason: Cannot add a call because there are already too many active calls. -->
    <string name="callFailed_cdma_call_limit">
        There are too many active calls. Please end or merge existing calls before placing a new one.
    </string>

    <!-- Call failure reason: If the network does not accept the emergency call request, e.g., because IMEI was used as identification and this capability is not supported -->
    <string name="callFailed_imei_not_accepted">
        Unable to connect, please insert a valid SIM card.
    </string>

    <!-- Call failure reason displayed when an in-progress WIFI call fails due to a loss of WIFI
         connectivity, or the WIFI signal has degraded to the point the call cannot continue. -->
    <string name="callFailed_wifi_lost">
        Wi-Fi connection lost.  Call ended.
    </string>

    <!-- Call failure reason displayed when the user's outgoing call cannot be placed due to a low
         battery. -->
    <string name="dialFailed_low_battery">Your video call cannot be placed due to low battery.</string>

    <!-- Call failure reason displayed when the user's call is ended due to a low battery. This
         message is shown when an in-progress call is ended due to the battery being low. -->
    <string name="callFailed_low_battery">Video call ended due to low battery.</string>

    <!-- In-call screen: error message shown when the user attempts to place an emergency call
         over wifi calling (WFC), but emergency services are not available in the current
         location. -->
    <string name="callFailed_emergency_call_over_wfc_not_available">Emergency calls over Wi-Fi calling not available in this location.</string>

    <!-- In-call screen: error message shown when the user attempts to place a call over wifi
         calling (WFC), but wifi calling is not available in the current location. -->
    <string name="callFailed_wfc_service_not_available_in_this_location">Wi-Fi calling is not available in this location.</string>

    <!-- The title for the change voicemail PIN activity -->
    <string name="change_pin_title">Change Voicemail PIN</string>
    <!-- The label for the continue button in change voicemail PIN activity -->
    <string name="change_pin_continue_label">Continue</string>
    <!-- The label for the cancel button in change voicemail PIN activity -->
    <string name="change_pin_cancel_label">Cancel</string>
    <!-- The label for the ok button in change voicemail PIN activity -->
    <string name="change_pin_ok_label">Ok</string>
    <!-- The title for the enter old pin step in change voicemail PIN activity -->
    <string name="change_pin_enter_old_pin_header">Confirm your old PIN</string>
    <!-- The hint for the enter old pin step in change voicemail PIN activity -->
    <string name="change_pin_enter_old_pin_hint">Enter your voicemail PIN to continue.</string>
    <!-- The title for the enter new pin step in change voicemail PIN activity -->
    <string name="change_pin_enter_new_pin_header">Set a new PIN</string>
    <!-- The hint for the enter new pin step in change voicemail PIN activity -->
    <string name="change_pin_enter_new_pin_hint">PIN must be <xliff:g id="min" example="4">%1$d</xliff:g>-<xliff:g id="max" example="7">%2$d</xliff:g> digits.</string>
    <!-- The title for the confirm new pin step in change voicemail PIN activity -->
    <string name="change_pin_confirm_pin_header">Confirm your PIN</string>
    <!-- The error message for th confirm new pin step in change voicemail PIN activity, if the pin doen't match the one previously entered -->
    <string name="change_pin_confirm_pins_dont_match">PINs don\'t match</string>
    <!-- The toast to show after the voicemail PIN has been successfully changed -->
    <string name="change_pin_succeeded">Voicemail PIN updated</string>
    <!-- The error message to show if the server reported an error while attempting to change the voicemail PIN -->
    <string name="change_pin_system_error">Unable to set PIN</string>

    <!-- The subtext for mobile data setting. shown if roaming settings turned off -->
    <string name="mobile_data_status_roaming_turned_off_subtext">Data roaming is turned off</string>
    <!-- The subtext for mobile data setting. shown if roaming settings turned on -->
    <string name="mobile_data_status_roaming_turned_on_subtext">Data roaming is turned on</string>
    <!-- The subtext for mobile data setting. shown if currently roaming, have roaming settings turned on but don't have a roaming data plan-->
    <string name="mobile_data_status_roaming_without_plan_subtext">Currently roaming, need data plan</string>
    <!-- The subtext for mobile data setting. shown if currently roaming, have roaming settings turned and have an active roaming data plan-->
    <string name="mobile_data_status_roaming_with_plan_subtext">Currently roaming, data plan is active</string>
    <!-- The subtext for mobile data setting. shown if not in roaming and prepaid sim has run out of balance -->
    <string name="mobile_data_status_no_plan_subtext">No mobile data left</string>

    <!-- The setting option name for activate prepaid mobile data plan -->
    <string name="mobile_data_activate_prepaid">No mobile data left</string>
    <!-- The setting option summary for activate prepaid mobile data plan -->
    <string name="mobile_data_activate_prepaid_summary">Add mobile data through <xliff:g id="provider_name">%s</xliff:g></string>
    <!-- The setting option name for for adding roaming data plan -->
    <string name="mobile_data_activate_roaming_plan">No roaming plan</string>
    <!-- The setting option summary for adding roaming data plan -->
    <string name="mobile_data_activate_roaming_plan_summary">Add roaming plan through <xliff:g id="provider_name">%s</xliff:g></string>
    <!-- The setting option footer for adding data either prepaid or roaming -->
    <string name="mobile_data_activate_footer">You can add mobile data or a roaming plan through your carrier, <xliff:g id="provider_name">%s</xliff:g>.</string>
    <!-- activate data plan dialogue title for either prepaid or roaming -->
    <string name="mobile_data_activate_diag_title">Add data?</string>
    <!-- activate data plan dialogue message for either prepaid or roaming -->
    <string name="mobile_data_activate_diag_message">You may need to add data through <xliff:g id="provider_name">%s</xliff:g></string>
    <!-- activate data plan dialogue button for adding data, which will take users out of the setting page -->
    <string name="mobile_data_activate_button">ADD DATA</string>
    <!-- activate data plan dialogue button for cancel further actions-->
    <string name="mobile_data_activate_cancel_button">CANCEL</string>

    <!-- Call failed messages -->
    <!-- In-call screen: status label displayed briefly after a call ends -->
    <string name="clh_card_title_call_ended_txt">Call ended</string>
    <!-- In-call screen: call failure reason (radio is off) -->
    <string name="clh_callFailed_powerOff_txt">Airplane mode is on</string>
    <!-- In-call screen: call failure reason (SIM error) -->
    <string name="clh_callFailed_simError_txt">Can\'t access SIM card</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="clh_incall_error_out_of_service_txt">Mobile network not available</string>
    <!-- In-call screen: call failure reason (satellite modem is enabled) -->
    <string name="clh_callFailed_satelliteEnabled_txt">Satellite mode is on</string>

    <!-- See CallFailCause for details on what causes each message -->
    <!-- In-call screen: call failure reason (Cause Number 1) -->
    <string name="clh_callFailed_unassigned_number_txt">Issue with phone number you are trying to dial. Error code 1.</string>
    <!-- In-call screen: call failure reason (Cause Number 3) -->
    <string name="clh_callFailed_no_route_to_destination_txt">Couldn\'t complete call. Error code 3.</string>
    <!-- In-call screen: call failure reason (Cause Number 6) -->
    <string name="clh_callFailed_channel_unacceptable_txt">Couldn\'t complete call. Error code 6.</string>
    <!-- In-call screen: call failure reason (Cause Number 8) -->
    <string name="clh_callFailed_operator_determined_barring_txt">Couldn\'t complete call. Error code 8.</string>
    <!-- In-call screen: call failure reason (Cause Number 16) -->
    <string name="clh_callFailed_normal_call_clearing_txt">Couldn\'t complete call. Error code 16.</string>
    <!-- In-call screen: call failure reason (Cause Number 17) -->
    <string name="clh_callFailed_user_busy_txt">User busy</string>
    <!-- In-call screen: call failure reason (Cause Number 18) -->
    <string name="clh_callFailed_no_user_responding_txt">User not responding</string>
    <!-- In-call screen: call failure reason (Cause Number 19) -->
    <string name="clh_callFailed_user_alerting_txt">Couldn\'t complete call. Error code 19.</string>
    <!-- In-call screen: call failure reason (Cause Number 21) -->
    <string name="clh_callFailed_call_rejected_txt">Call rejected</string>
    <!-- In-call screen: call failure reason (Cause Number 22) -->
    <string name="clh_callFailed_number_changed_txt">Number changed</string>
    <!-- In-call screen: call failure reason (Cause Number 25) -->
    <string name="clh_callFailed_pre_emption_txt">Couldn\'t complete call. Error code 25.</string>
    <!-- In-call screen: call failure reason (Cause Number 26) -->
    <string name="clh_callFailed_non_selected_user_clearing_txt">Couldn\'t complete call. Error code 26.</string>
    <!-- In-call screen: call failure reason (Cause Number 27) -->
    <string name="clh_callFailed_destination_out_of_order_txt">Couldn\'t complete call. Error code 27.</string>
    <!-- In-call screen: call failure reason (Cause Number 28) -->
    <string name="clh_callFailed_invalid_number_format_txt">Invalid number format (incomplete number)</string>
    <!-- In-call screen: call failure reason (Cause Number 29) -->
    <string name="clh_callFailed_facility_rejected_txt">Couldn\'t complete call. Error code 29.</string>
    <!-- In-call screen: call failure reason (Cause Number 30) -->
    <string name="clh_callFailed_response_to_STATUS_ENQUIRY_txt">Couldn\'t complete call. Error code 30.</string>
    <!-- In-call screen: call failure reason (Cause Number 31) -->
    <string name="clh_callFailed_normal_unspecified_txt">Couldn\'t complete call. Error code 31.</string>
    <!-- In-call screen: call failure reason (Cause Number 34) -->
    <string name="clh_callFailed_no_circuit_available_txt">Couldn\'t complete call. Error code 34.</string>
    <!-- In-call screen: call failure reason (Cause Number 38) -->
    <string name="clh_callFailed_network_out_of_order_txt">Couldn\'t complete call. Error code 38.</string>
    <!-- In-call screen: call failure reason (Cause Number 41) -->
    <string name="clh_callFailed_temporary_failure_txt">Couldn\'t complete call. Error code 41.</string>
    <!-- In-call screen: call failure reason (Cause Number 42) -->
    <string name="clh_callFailed_switching_equipment_congestion_txt">Couldn\'t complete call. Error code 42.</string>
    <!-- In-call screen: call failure reason (Cause Number 43) -->
    <string name="clh_callFailed_access_information_discarded_txt">Couldn\'t complete call. Error code 43.</string>
    <!-- In-call screen: call failure reason (Cause Number 44) -->
    <string name="clh_callFailed_requested_circuit_txt">Couldn\'t complete call. Error code 44.</string>
    <!-- In-call screen: call failure reason (Cause Number 47) -->
    <string name="clh_callFailed_resources_unavailable_unspecified_txt">Couldn\'t complete call. Error code 47.</string>
    <!-- In-call screen: call failure reason (Cause Number 49) -->
    <string name="clh_callFailed_quality_of_service_unavailable_txt">Couldn\'t complete call. Error code 49.</string>
    <!-- In-call screen: call failure reason (Cause Number 50) -->
    <string name="clh_callFailed_requested_facility_not_subscribed_txt">Couldn\'t complete call. Error code 50.</string>
    <!-- In-call screen: call failure reason (Cause Number 55) -->
    <string name="clh_callFailed_incoming_calls_barred_within_the_CUG_txt">Couldn\'t complete call. Error code 55.</string>
    <!-- In-call screen: call failure reason (Cause Number 57) -->
    <string name="clh_callFailed_bearer_capability_not_authorized_txt">Couldn\'t complete call. Error code 57.</string>
    <!-- In-call screen: call failure reason (Cause Number 58) -->
    <string name="clh_callFailed_bearer_capability_not_presently_available_txt">Couldn\'t complete call. Error code 58.</string>
    <!-- In-call screen: call failure reason (Cause Number 63) -->
    <string name="clh_callFailed_service_or_option_not_available_unspecified_txt">Couldn\'t complete call. Error code 63.</string>
    <!-- In-call screen: call failure reason (Cause Number 65) -->
    <string name="clh_callFailed_bearer_service_not_implemented_txt">Couldn\'t complete call. Error code 65.</string>
    <!-- In-call screen: call failure reason (Cause Number 68) -->
    <string name="clh_callFailed_ACM_equal_to_or_greater_than_ACMmax_txt">Couldn\'t complete call. Error code 68.</string>
    <!-- In-call screen: call failure reason (Cause Number 69) -->
    <string name="clh_callFailed_requested_facility_not_implemented_txt">Couldn\'t complete call. Error code 69.</string>
    <!-- In-call screen: call failure reason (Cause Number 70) -->
    <string name="clh_callFailed_only_restricted_digital_information_bearer_capability_is_available_txt">Couldn\'t complete call. Error code 70.</string>
    <!-- In-call screen: call failure reason (Cause Number 79) -->
    <string name="clh_callFailed_service_or_option_not_implemented_unspecified_txt">Couldn\'t complete call. Error code 79.</string>
    <!-- In-call screen: call failure reason (Cause Number 81) -->
    <string name="clh_callFailed_invalid_transaction_identifier_value_txt">Couldn\'t complete call. Error code 81.</string>
    <!-- In-call screen: call failure reason (Cause Number 87) -->
    <string name="clh_callFailed_user_not_member_of_CUG_txt">Couldn\'t complete call. Error code 87.</string>
    <!-- In-call screen: call failure reason (Cause Number 88) -->
    <string name="clh_callFailed_incompatible_destination_txt">Couldn\'t complete call. Error code 88.</string>
    <!-- In-call screen: call failure reason (Cause Number 91) -->
    <string name="clh_callFailed_invalid_transit_network_selection_txt">Couldn\'t complete call. Error code 91.</string>
    <!-- In-call screen: call failure reason (Cause Number 95) -->
    <string name="clh_callFailed_semantically_incorrect_message_txt">Couldn\'t complete call. Error code 95.</string>
    <!-- In-call screen: call failure reason (Cause Number 96) -->
    <string name="clh_callFailed_invalid_mandatory_information_txt">Couldn\'t complete call. Error code 96.</string>
    <!-- In-call screen: call failure reason (Cause Number 97) -->
    <string name="clh_callFailed_message_type_non_existent_or_not_implemented_txt">Couldn\'t complete call. Error code 97.</string>
    <!-- In-call screen: call failure reason (Cause Number 98) -->
    <string name="clh_callFailed_message_type_not_compatible_with_protocol_state_txt">Couldn\'t complete call. Error code 98.</string>
    <!-- In-call screen: call failure reason (Cause Number 99) -->
    <string name="clh_callFailed_information_element_non_existent_or_not_implemented_txt">Couldn\'t complete call. Error code 99.</string>
    <!-- In-call screen: call failure reason (Cause Number 100) -->
    <string name="clh_callFailed_conditional_IE_error_txt">Couldn\'t complete call. Error code 100.</string>
    <!-- In-call screen: call failure reason (Cause Number 101) -->
    <string name="clh_callFailed_message_not_compatible_with_protocol_state_txt">Couldn\'t complete call. Error code 101.</string>
    <!-- In-call screen: call failure reason (Cause Number 102) -->
    <string name="clh_callFailed_recovery_on_timer_expiry_txt">Couldn\'t complete call. Error code 102.</string>
    <!-- In-call screen: call failure reason (Cause Number 111) -->
    <string name="clh_callFailed_protocol_Error_unspecified_txt">Couldn\'t complete call. Error code 111.</string>
    <!-- In-call screen: call failure reason (Cause Number 127) -->
    <string name="clh_callFailed_interworking_unspecified_txt">Couldn\'t complete call. Error code 127.</string>
    <!-- Call settings screen, setting option name -->
    <string name="labelCallBarring">Call barring</string>
    <!-- Call barring settings screen, setting summary text when a call barring option is activated -->
    <string name="sum_call_barring_enabled">On</string>
    <!-- Call barring settings screen, setting summary text when a call barring option is deactivated -->
    <string name="sum_call_barring_disabled">Off</string>
    <!-- Call barring settings screen, setting option name -->
    <string name="call_barring_baoc">All outgoing</string>
    <!-- Call barring settings screen, Disable blocking of all outgoing calls -->
    <string name="call_barring_baoc_enabled">Disable blocking of all outgoing calls?</string>
    <!-- Call barring settings screen, Block all outgoing calls -->
    <string name="call_barring_baoc_disabled">Block all outgoing calls?</string>
    <!-- Call barring settings screen, setting option name -->
    <string name="call_barring_baoic">Outgoing international</string>
    <!-- Call barring settings screen, Disable blocking of outgoing international calls -->
    <string name="call_barring_baoic_enabled">Disable blocking of outgoing international calls?</string>
    <!-- Call barring settings screen, Block outgoing international calls-->
    <string name="call_barring_baoic_disabled">Block outgoing international calls?</string>
    <!-- Call barring settings screen, setting option name -->
    <string name="call_barring_baoicr">Outgoing international roaming</string>
    <!-- Call barring settings screen, Disable blocking of outgoing international roaming -->
    <string name="call_barring_baoicr_enabled">Disable blocking of outgoing international roaming?</string>
    <!-- Call barring settings screen, Block outgoing international roaming -->
    <string name="call_barring_baoicr_disabled">Block outgoing international roaming?</string>
    <!-- Call barring settings screen, setting option name -->
    <string name="call_barring_baic">All incoming</string>
    <!-- Call barring settings screen, Disable blocking of all incoming calls -->
    <string name="call_barring_baic_enabled">Disable blocking of all incoming calls?</string>
    <!-- Call barring settings screen, Block all incoming calls -->
    <string name="call_barring_baic_disabled">Block all incoming calls?</string>
    <!-- Call barring settings screen, setting option name -->
    <string name="call_barring_baicr">Incoming international roaming</string>
    <!-- Call barring settings screen, Disable blocking of all incoming international roaming -->
    <string name="call_barring_baicr_enabled">Disable blocking of all incoming international roaming?</string>
    <!-- Call barring settings screen, Block incoming international roaming-->
    <string name="call_barring_baicr_disabled">Block incoming international roaming?</string>
    <!-- Call barring settings screen, setting option name -->
    <string name="call_barring_deactivate_all">Deactivate all</string>
    <!-- Call barring settings screen, setting summary text when BAAll check box is selected -->
    <string name="call_barring_deactivate_all_description">Deactivate all call barring settings</string>
    <!-- Call barring settings screen, deactivate all successfully -->
    <string name="call_barring_deactivate_success">Call barring deactivated</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_change_pwd">Change password</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_change_pwd_description">Change call barring password</string>
    <!-- Call barring settings screen, not possible to change call barring password -->
    <string name="call_barring_change_pwd_description_disabled">Cannot change call barring password</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_pwd_not_match">Passwords do not match</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_right_pwd_number">Enter a password with 4 numbers</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_change_pwd_success">Password changed</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_old_pwd">Old password</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_new_pwd">New password</string>
    <!-- Call barring settings screen, change password -->
    <string name="call_barring_confirm_pwd">Confirm password</string>
    <!-- Call forwarding dialog box, text field label -->
    <string name="messageCallBarring">Enter password</string>
    <!-- Call barring settings screen, section heading -->
    <string name="call_barring_settings">Call barring settings</string>
    <!-- In-call screen: error message shown when the user attempts to place a call, but the network
         does not have enough resources (e.g. it is busy) and the call cannot be placed. -->
    <string name="callFailed_NetworkBusy">Network is busy.  Please try your call again later.</string>
    <!-- In-call screen: error message shown when the user attempts to place a call, but the network
         does not have enough resources (e.g. it is congested) and the call cannot be placed. -->
    <string name="callFailed_NetworkCongested">Network is congested.  Contact your mobile operator
    for assistance.</string>
    <!-- Message displayed to the user when an outgoing call is deflected.  This means that the
         party the user is calling has chosen to send the call to another phone number. -->
    <string name="supp_service_notification_call_deflected">Call deflected.</string>
    <!-- Message displayed to the user when an outgoing call is forwarded to another number.
         This happens because the party the user is calling has call forwarding active. -->
    <string name="supp_service_notification_call_forwarded">Call forwarded.</string>
    <!-- Message displayed to the user when an outgoing call is waiting.  This happens when the
         party the user is calling is already in another call. -->
    <string name="supp_service_notification_call_waiting">Call is waiting.</string>
    <!-- Message displayed to the user when they have chosen to block their phone number for an
         outgoing call, but the network has rejected that request. -->
    <string name="supp_service_clir_suppression_rejected">Number blocking is rejected.</string>
    <!-- Message displayed to the user to inform them that the call is to or from a number which is
         part of a closed user group.  A closed user group is a network feature which restricts
         calls on a device to members of the closed user group. -->
    <string name="supp_service_closed_user_group_call">Closed user group call.</string>
    <!-- Message displayed to the user when incoming call barring is active.  This means that the
         user has enabled the network feature which prevents all incoming calls. -->
    <string name="supp_service_incoming_calls_barred">Incoming calls barred.</string>
    <!-- Message displayed to the user when outgoing call barring is active.  This means that the
         user has enabled the network feature which prevents all outgoing calls. -->
    <string name="supp_service_outgoing_calls_barred">Outgoing calls barred.</string>
    <!-- Message displayed to the user to indicate that call forwarding is active. -->
    <string name="supp_service_call_forwarding_active">Call forwarding active.</string>
    <!-- Message displayed to the user when they receive multiple incoming calls at the same time
         and one of them is forwarded to the network.  Phones can't handle multiple incoming calls
         so the network will typically forward one of the calls to voicemail or another number
         defined by the user. -->
    <string name="supp_service_additional_call_forwarded">Additional call forwarded.</string>
    <!-- Message displayed to the user to indicate that a call has been successfully transferred
         to another phone number. -->
    <string name="supp_service_additional_ect_connected">Explicit call transfer complete.</string>
    <!-- Message displayed to the user to indicate that the call is in the process of being
         transferred to another phone number.-->
    <string name="supp_service_additional_ect_connecting">Explicit call transfer in progress.</string>
    <!-- Message displayed to the user to indicate that the remote party has put the user
         on hold. -->
    <string name="supp_service_call_on_hold">Call on hold.</string>
    <!-- Message displayed to the user to indicate that the remote party has taken the user
         off hold. -->
    <string name="supp_service_call_resumed">Call resumed.</string>
    <!-- Message displayed to the user to indicate that an incoming call was deflected from another
         number.  This means that the call originated as a result of the original caller choosing
         to forward the call to the current user rather than answering it themselves. -->
    <string name="supp_service_deflected_call">Call was deflected.</string>
    <!-- Message displayed to the user to indicate that an incoming call was forwarded from another
         number. -->
    <string name="supp_service_forwarded_call">Forwarded call.</string>
    <!-- Message displayed to the user to indicate that they are joining a conference call. -->
    <string name="supp_service_conference_call">Joining conference call.</string>
    <!-- Message displayed to the user to indicate that a held call has been released /
         disconnected. -->
    <string name="supp_service_held_call_released">Held call has been released.</string>
    <!-- In-call screen: error message shown when the user attempts to place a call, but the device
         is currently in the process of being provisioned for service.  Provisioning is the process
         by which a device confirms which services are available to the user by contacting the
         mobile service provider. -->
    <string name="callFailed_otasp_provisioning_in_process">Cannot place a call as the device is currently being provisioned.</string>
    <!-- In-call screen: error message shown when the user has attempted to place a new outgoing
         call, but there is already a call in dialing state. -->
    <string name="callFailed_already_dialing">Cannot place a call as another outgoing call is already dialing.</string>
    <!-- In-call screen: error message shown when the user has attempted to place a new outgoing
         call while there is already a call in ringing state. -->
    <string name="callFailed_already_ringing">Cannot place a call as there is an unanswered incoming call.  Answer or reject the incoming call prior to placing a new call.</string>
    <!-- In-call screen: error message shown when the user attempts to place a call, but calling has
         been disabled using a debug property. -->
    <string name="callFailed_calling_disabled">Cannot place a call as calling has been disabled using the ro.telephony.disable-call system property.</string>
    <!-- In-call screen: error message shown when the user attempts to place a call, but calling has
         been disabled using a debug property. -->
    <string name="callFailed_too_many_calls">Cannot place a call as there are already two calls in progress.  Disconnect one of the calls or merge them into a conference prior to placing a new call.</string>
    <!-- Message displayed to the user when they attempt to edit options for a supplementary service
         (call waiting, call barring, call forwarding, and caller ID), but they are required to
         enable mobile data first. -->
    <string name="supp_service_over_ut_precautions">To use <xliff:g id="supp service">%s</xliff:g>, make sure mobile data is turned on. You can change this in mobile network settings.</string>
    <!-- Message displayed to the user when they attempt to edit options for a supplementary service
         (call waiting, call barring, call forwarding, and caller ID) in roaming, but they are
         required to enable mobile data and data roaming first. -->
    <string name="supp_service_over_ut_precautions_roaming">To use <xliff:g id="supp service">%s</xliff:g>, make sure mobile data and data roaming are turned on. You can change these in mobile network settings.</string>
    <!-- Message displayed to the user when they attempt to edit options for a supplementary service
         (call waiting, call barring, call forwarding, and caller ID), but they are
         required to enable mobile data first for each sim. -->
    <string name="supp_service_over_ut_precautions_dual_sim">To use <xliff:g id="supp service">%1$s</xliff:g>, make sure mobile data is turned on for SIM <xliff:g id="sim number">%2$d</xliff:g>. You can change this in mobile network settings.</string>
    <!-- Message displayed to the user when they attempt to edit options for a supplementary service
         (call waiting, call barring, call forwarding, and caller ID) in roaming device, but
         they are required to enable mobile data and data roaming first for each sim. -->
    <string name="supp_service_over_ut_precautions_roaming_dual_sim">To use <xliff:g id="supp service">%1$s</xliff:g>, make sure mobile data and data roaming are turned on for SIM <xliff:g id="sim number">%2$d</xliff:g>. You can change these in mobile network settings.</string>
    <!-- supplementary services over ut precaution exit dialog choice -->
    <string name="supp_service_over_ut_precautions_dialog_dismiss">Dismiss</string>

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

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

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

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

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

    <!-- Cbrs enable disable flag. Only shown in diagnostic screen, so precise translation is not needed -->
    <string name="cbrs_data_switch_string">Cbrs Data</string>

    <!-- Dsds enable/disable flag. Only shown in diagnostic screen, so precise translation is not needed, [CHAR LIMIT=none] -->
    <string name="dsds_switch_string">Enable DSDS</string>

    <!-- UI debug setting: Enable/Disable DSDS [CHAR LIMIT=none] -->
    <string name="dsds_dialog_title">Restart Device?</string>

    <!-- UI debug setting: Enable/Disable DSDS [CHAR LIMIT=none] -->
    <string name="dsds_dialog_message">You need to restart your device to change this setting.</string>

    <!-- UI debug setting: Enable/Disable DSDS [CHAR LIMIT=none] -->
    <string name="dsds_dialog_confirm">Restart</string>

    <!-- UI debug setting: Enable/Disable DSDS [CHAR LIMIT=none] -->
    <string name="dsds_dialog_cancel">Cancel</string>

    <!-- Setting Removable esim as default. Only shown in diagnostic screen, so precise translation is not needed -->
    <string name="removable_esim_string">Set Removable eSIM as Default</string>

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

    <!-- Title for simulating device out of service. -->
    <string name="simulate_out_of_service_string">Simulate Out of Service (Debug Build only)</string>

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

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

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

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

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

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

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

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

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

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


    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_subid">Current subId:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_dds">SubId of default data SIM:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_dl_kbps">DL Bandwidth (kbps):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ul_kbps">UL Bandwidth (kbps):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_phy_chan_config">LTE Physical Channel Configuration:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_cell_info_refresh_rate">Cell Info Refresh Rate:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_cellinfo_label">All Cell Measurement Info:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gprs_service_label">Data Service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_roaming_label">Roaming:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_imei_label">IMEI:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, DO NOT TRANSLATE. -->
    <string name="radio_info_imsi_label">IMSI:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_redirect_label">Call Redirect:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_resets_label">Number of PPP Reset Since Boot:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_current_network_label">Current Network:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_received_label">Data Received:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gsm_service_label">Voice Service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_strength_label">Signal Strength:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_status_label">Voice Call Status:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_sent_label">Data Sent:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_message_waiting_label">Message Waiting:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_phone_number_label">Phone Number:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_voice_network_type_label">Voice Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_network_type_label">Data Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_override_network_type_label">Override Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_voice_raw_registration_state_label">Voice Raw Registration State:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_raw_registration_state_label">Data Raw Registration State:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_wlan_data_raw_registration_state_label">WLAN Data Raw Registration State:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="phone_index_label">Select phone index</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_set_perferred_label">Set Preferred Network Type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_hostname_v4">Ping Hostname(www.google.com) IPv4:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_hostname_v6">Ping Hostname(www.google.com) IPv6:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_http_client_test">HTTP Client Test:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="ping_test_label">Run Ping Test</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_label">SMSC:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_update_label">Update</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_refresh_label">Refresh</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_toggle_dns_check_label">Toggle DNS Check</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="oem_radio_info_label">OEM-specific Info/Settings</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_endc_available">EN-DC Available (NSA):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_dcnr_restricted">DCNR Restricted (NSA):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_nr_available">NR Available (NSA):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_nr_state">NR State (NSA):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_nr_frequency">NR Frequency:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_network_slicing_config" translatable="false">Network Slicing Config:</string>

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

    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label" product="tablet">Tablet info</string>
    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label" product="default">Phone info</string>

    <!-- Carrier Provisioning Info [CHAR LIMIT=NONE] -->
    <string name="carrier_provisioning">Carrier Provisioning Info</string>
    <!-- Trigger Carrier Provisioning [CHAR LIMIT=NONE] -->
    <string name="trigger_carrier_provisioning">Trigger Carrier Provisioning</string>

    <!-- details of the message popped up when there is
    bad call quality caused by bluetooth connection-->
    <string name="call_quality_notification_bluetooth_details">
        Your bluetooth signal is weak.  Try switching to speakerphone.</string>
    <!-- name of the notification that pops up during
    a phone call when there is bad call quality -->
    <string name="call_quality_notification_name">Call Quality Notification</string>
    <!-- Telephony notification channel name for a channel containing SIP accounts removed
     notificatios -->
    <string name="notification_channel_sip_account">Deprecated SIP accounts</string>

    <string name="send_from_work_profile_title">Can\'t message from a personal app</string>
    <string name="send_from_work_profile_description">Your organization only allows you to send messages from work apps</string>
    <string name="send_from_work_profile_cancel">Cancel</string>
    <string name="send_from_work_profile_action_str">Switch to work profile</string>
    <string name="install_messages_on_work_profile_action_str">Install a work messages app</string>

</resources>
