<?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</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">Pay phone</string>
    <!-- In-call screen: status label for a call that's on hold -->
    <string name="onHold">On hold</string>
    <!-- Possible error messages with outgoing calls --><skip/>
    <!-- In-call screen: call failure reason (busy) -->
    <string name="callFailed_userBusy">Line busy</string>
    <!-- In-call screen: call failure reason (network congestion) -->
    <string name="callFailed_congestion">Network busy</string>
    <!-- In-call screen: call failure reason (client timed out) -->
    <string name="callFailed_timedOut">No response, timed out</string>
    <!-- In-call screen: call failure reason (server unreachable) -->
    <string name="callFailed_server_unreachable">Server unreachable</string>
    <!-- In-call screen: call failure reason (peer unreachable) -->
    <string name="callFailed_number_unreachable">Number unreachable</string>
    <!-- In-call screen: call failure reason (incorrect username or password) -->
    <string name="callFailed_invalid_credentials">Incorrect username or password</string>
    <!-- In-call screen: call failure reason (calling from out of network is not allowed) -->
    <string name="callFailed_out_of_network">Called from out-of-network</string>
    <!-- In-call screen: call failure reason (server error) -->
    <string name="callFailed_server_error">Server error. Try again later.</string>
    <!-- In-call screen: call failure reason (no signal) -->
    <string name="callFailed_noSignal">No signal</string>
    <!-- In-call screen: call failure reason (GSM ACM limit exceeded) -->
    <string name="callFailed_limitExceeded">ACM limit exceeded</string>
    <!-- In-call screen: call failure reason (radio is off) -->
    <string name="callFailed_powerOff">Radio off</string>
    <!-- In-call screen: call failure reason (SIM error) -->
    <string name="callFailed_simError">No SIM or SIM error</string>
    <!-- In-call screen: call failure reason (out of service) -->
    <string name="callFailed_outOfService">Out of service area</string>
    <!-- In-call screen: call failure reason (call denied because of current FDN setting) -->
    <string name="callFailed_fdn_only">Outgoing calls are restricted by FDN.</string>
    <!-- In-call screen: call failure reason (call denied because call barring is on) -->
    <string name="callFailed_cb_enabled">You can\'t make outgoing calls while call barring is on.</string>
    <!-- In-call screen: call failure reason (call denied because domain specific access control is on) -->
    <string name="callFailed_dsac_restricted">All calls are restricted by access control.</string>
    <!-- In-call screen: call failure reason (Emergency call denied because domain specific access control is on)-->
    <string name="callFailed_dsac_restricted_emergency">Emergency calls are restricted by access control.</string>
    <!-- In-call screen: call failure reason (Normal call denied because domain specific access control is on)-->
    <string name="callFailed_dsac_restricted_normal">Normal calls are restricted by access control.</string>
    <!-- In-call screen: call failure reason (Dialed number doesn't exist) -->
    <string name="callFailed_unobtainable_number">Invalid number</string>
    <!-- In-call screen: status label for a conference call -->
    <string name="confCall">Conference call</string>
    <!-- In-call screen: call lost dialog text -->
    <string name="call_lost">Call has been lost.</string>

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

    <!-- MMI dialog strings -->
    <!-- Dialog label when an MMI code starts running -->
    <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>

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

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

    <!-- GSM Call settings screen, setting option name -->
    <string name="labelGSMMore">GSM call settings</string>
    <!-- CDM Call settings screen, setting option name -->
    <string name="labelCDMAMore">CDMA call settings</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>
    <!-- Call settings screen, setting option name -->
    <string name="voicemail">Voicemail</string>
    <!-- Call forwarding dialog box, voicemail number prefix -->
    <string name="voicemail_abbreviated">VM:</string>
    <!-- Mobile network settings screen, setting option name -->
    <string name="networks">Network operators</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-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 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">Disabled</string>

    <!-- Call forwarding settings screen, setting option name -->
    <string name="labelCFB">Forward 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">Disabled</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">Forward 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">Disabled</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">Forward 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">Disabled</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>

    <!-- Title of the progress dialog displayed while updating Call settings -->
    <string name="updating_title">Call settings</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 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">Enable</string>
    <!-- Button label used in several settings-related dialogs -->
    <string name="disable">Disable</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 - My Carrier -->
    <string name="voicemail_default">My carrier</string>

    <!-- networks setting strings --><skip/>
    <!-- Mobile network settings screen title -->
    <string name="mobile_networks">Mobile network settings</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, setting option name -->
    <string name="search_networks">Search networks</string>
    <!-- Available networks screen, toast when an error is encountered when searching for networks -->
    <string name="network_query_error">Error while searching for networks.</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>
    <!-- Mobile network settings screen setting option summary text -->
    <string name="sum_carrier_select">Choose a network operator</string>
    <!-- Available networks screen, setting summary text -->
    <string name="sum_search_networks">Search for all available networks</string>
    <!-- Available networks screen, setting option name -->
    <string name="select_automatically">Choose automatically</string>
    <!-- Available networks screen, setting summary text -->
    <string name="sum_select_automatically">Automatically choose preferred network</string>
    <string name="register_automatically">Automatic registration\u2026</string>
    <string name="preferred_network_mode_title">Network Mode</string>
    <string name="preferred_network_mode_summary">Change the network operating mode</string>
    <string name="preferred_network_mode_dialogtitle">Preferred network mode</string>
    <!-- Mobile network settings, summary for preferred network mode WCDMA preferred[CHAR LIMIT=100] -->
    <string name="preferred_network_mode_wcdma_perf_summary">Preferred network mode: WCDMA preferred</string>
    <!-- Mobile network settings, summary for preferred network mode GSM [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_gsm_only_summary">Preferred network mode: GSM only</string>
    <!-- Mobile network settings, summary for preferred network mode WCDMA only [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_wcdma_only_summary">Preferred network mode: WCDMA only</string>
    <!-- Mobile network settings, summary for preferred network mode GSM / UMTS [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_gsm_wcdma_summary">Preferred network mode: GSM / WCDMA</string>
    <!-- Mobile network settings, summary for preferred network mode CDMA [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_cdma_summary">Preferred network mode: CDMA</string>
    <!-- Mobile network settings, summary for preferred network mode CDMA / EvDo [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_cdma_evdo_summary">Preferred network mode: CDMA / EvDo</string>
    <!-- Mobile network settings, summary for preferred network mode CDMA only [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_cdma_only_summary">Preferred network mode: CDMA only</string>
    <!-- Mobile network settings, summary for preferred network mode EvDo only [CHAR LIMIT=100] -->
    <string name="preferred_network_mode_evdo_only_summary">Preferred network mode: EvDo only</string>
    <!-- Mobile network settings, summary for preferred network mode LTE / CDMA[CHAR LIMIT=100] -->
    <string name="preferred_network_mode_lte_cdma_summary">Preferred network mode: LTE / CDMA</string>

    <string-array name="preferred_network_mode_choices">
        <item>LTE/CDMA</item>
        <item>EvDo only</item>
        <item>CDMA w/o EvDo</item>
        <item>CDMA/EvDo auto</item>
        <item>GSM/WCDMA auto</item>
        <item>WCDMA only</item>
        <item>GSM only</item>
        <item>GSM/WCDMA preferred</item>
    </string-array>
    <string-array name="preferred_network_mode_values"  translatable="false">
        <item>"7"</item>
        <item>"6"</item>
        <item>"5"</item>
        <item>"4"</item>
        <item>"3"</item>
        <item>"2"</item>
        <item>"1"</item>
        <item>"0"</item>
    </string-array>
    <!-- Mobile network settings, network mode choices for a device supporting CDMA and LTE [CHAR LIMIT=25] -->
    <string-array name="preferred_network_mode_choices_lte">
        <item>LTE/CDMA</item>
        <item>CDMA</item>
    </string-array>
    <string-array name="preferred_network_mode_values_lte" translatable="false">
        <item>"7"</item>
        <item>"4"</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) -->
    <string name="data_enable_summary">Enable data access over Mobile network</string>
    <!-- Mobile network settings screen, setting check box name -->
    <string name="roaming">Data 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">You\'ve lost data connectivity because you left your home network with data roaming turned off.</string>
    <!-- Mobile network settings screen, dialog message when user selects the Data roaming check box -->
    <string name="roaming_warning">Allow data roaming? You may incur significant roaming charges!</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>

    <!-- Mobile network settings screen, setting option name -->
    <string name="prefer_2g">Use only 2G networks</string>
    <!-- Mobile network settings screen, setting summary text -->
    <string name="prefer_2g_summary">Saves battery</string>

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

    <!-- FDN settings strings -->
    <!-- Call settings screen, setting option name -->
    <string name="fdn">Fixed Dialing Numbers</string>
    <!-- Call settings screen, button label that takes you to
         the Fixed Dialing Number management screen -->
    <string name="manage_fdn_list">FDN list</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>

    <!-- 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 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 can\'t exceed 20 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>

    <!-- 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">To import contacts from the SIM card, first turn off Airplane mode.</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">Disable SIM PIN</string>
    <!-- Title of "Enable SIM PIN" screen -->
    <string name="enable_sim_pin">Enable SIM PIN</string>
    <!-- SIM PIN screen: progress message displayed while enabling -->
    <string name="enable_in_progress">Please wait\u2026</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="enable_pin_ok">SIM PIN enabled.</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="disable_pin_ok">SIM PIN disabled.</string>
    <!-- SIM PIN screen: error message displayed in a popup (toast) -->
    <string name="pin_failed">The PIN you typed was incorrect.</string>
    <!-- SIM PIN screen: status message displayed in a popup (toast) -->
    <string name="pin_changed">SIM PIN changed successfully.</string>
    <!-- SIM PIN screen: error message displayed in a dialog -->
    <string name="puk_requested">Password incorrect, SIM is locked! PUK2 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">The PUK2 you typed isn\'t correct. Try again. </string>
    <!-- SIM PIN2 screen: error message -->
    <string name="badPin2">The old PIN2 you typed isn\'t correct. Try again.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="mismatchPin2">The PIN2s you typed don\'t match. Try again.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="invalidPin2">Type a PIN2 that is 4 to 8 numbers.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="invalidPuk2">Type a PUK2 that is 8 numbers.</string>
    <!-- SIM PIN2 screen: status message displayed in a popup (toast) -->
    <string name="pin2_changed">PIN2 changed successfully.</string>
    <!-- SIM PIN2 screen: label for PUK2 entry widget -->
    <string name="label_puk2_code">Type PUK2 code</string>
    <!-- SIM PIN2 screen: error message displayed in a dialog -->
    <string name="fdn_enable_puk2_requested">Password incorrect. Change PIN2 and retry.</string>
    <!-- SIM PIN2 screen: error message displayed in a dialog -->
    <string name="puk2_requested">Password incorrect, SIM is locked. PUK2 requested.</string>

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

    <!-- In-call screen: status label for a conference call -->
    <string name="caller_manage_header">Conference call <xliff:g id="conf_call_time">%s</xliff:g></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">Retrying</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>
    <!-- In-call screen: special status label that shows your own phone
         number during emergency callback mode (ECM) [CHAR LIMIT=30] -->
    <string name="card_title_my_phone_number">My number is <xliff:g id="my_phone_number">%s</xliff:g></string>

    <!-- Notification strings -->
    <!-- The "label" of the in-call Notification for a dialing call, used
         as the format string for a Chronometer widget. [CHAR LIMIT=60] -->
    <string name="notification_dialing">Dialing</string>
    <!-- Missed call notification label, used when there's exactly one missed call -->
    <string name="notification_missedCallTitle">Missed call</string>
    <!-- Missed call notification label, used when there are two or more missed calls -->
    <string name="notification_missedCallsTitle">Missed calls</string>
    <!-- Missed call notification message used when there are multiple missed calls -->
    <string name="notification_missedCallsMsg"><xliff:g id="num_missed_calls">%s</xliff:g> missed calls</string>
    <!-- Missed call notification message used for a single missed call, including
         the caller-id info from the missed call -->
    <string name="notification_missedCallTicker">Missed call from <xliff:g id="missed_call_from">%s</xliff:g></string>
    <!-- The "label" of the in-call Notification for an ongoing call, used
         as the format string for a Chronometer widget. [CHAR LIMIT=60] -->
    <string name="notification_ongoing_call">Ongoing call</string>
    <!-- The "label" of the in-call Notification for a call that's on hold -->
    <string name="notification_on_hold">On hold</string>
    <!-- The "label" of the in-call Notification for an incoming ringing call -->
    <string name="notification_incoming_call">Incoming call</string>
    <!-- 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 -->
    <string name="notification_network_selection_text">Selected network (<xliff:g id="operator_name">%s</xliff:g>) unavailable</string>
    <!-- Message for "end call" Action.
         It is displayed in the "Ongoing call" notification, which is shown
         when the user is outside the in-call screen while the phone call is still
         active. [CHAR LIMIT=40] -->
    <string name="notification_action_end_call">Hang up</string>
    <!-- Message for "call back" Action, which is displayed in the missed call notificaiton.
         The user will be able to call back to the person or the phone number.
         [CHAR LIMIT=60] -->
    <string name="notification_missedCall_call_back">Call back</string>
    <!-- Message for "reply via sms" action, which is displayed in the missed call notification.
         The user will be able to send text messages using the phone number.
         [CHAR LIMIT=60] -->
    <string name="notification_missedCall_message">Message</string>

    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_power_off">To place a call, first turn off Airplane mode.</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_no_phone_number_supplied">Call not sent, no valid number entered.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_call_failed">Call not sent.</string>
    <!-- In-call screen: status message displayed in a dialog when starting an MMI -->
    <string name="incall_status_dialed_mmi">Starting MMI sequence\u2026</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_unknown">Unsupported service.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_switch">Unable to switch calls.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_separate">Unable to separate call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_transfer">Unable to transfer call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_conference">Unable to conference calls.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_reject">Unable to reject call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_hangup">Unable to release call(s).</string>

    <!-- In-call screen: "call type" indication for a SIP call [CHAR LIMIT=30]  -->
    <string name="incall_call_type_label_sip">Internet call</string>

    <!-- Dialog title for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_title">Emergency call</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">Out of service area, retrying\u2026</string>

    <!-- Dialer text on Emergency Dialer -->
    <!-- Emergency dialer: message displayed in an error dialog -->
    <string name="dial_emergency_error">Call not sent. <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">Call not sent. Dial an emergency number!</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>

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

    <!-- Hearing aid settings -->
    <string name="hac_mode_title">Hearing aids</string>
    <string name="hac_mode_summary">Turn on hearing aid compatibility</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_message">Network 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 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">Wait while your phone is being programmed.</string>
    <!-- String to display within the OTA Fail Notice dialog -->
    <string name="ota_failure">Programming unsuccessful</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>
    <plurals name="phone_in_ecm_notification_time">
        <!-- number of minutes is one -->
        <item quantity="one">No data connection for <xliff:g id="count">%s</xliff:g> minute</item>
        <!-- number of minutes is not equal to one -->
        <item quantity="other">No data connection for <xliff:g id="count">%s</xliff:g> minutes</item>
    </plurals>
    <!-- ECM: Dialog box message for exiting from the notifications screen -->
    <plurals name="alert_dialog_exit_ecm">
        <!-- number of minutes is one -->
        <item quantity="one">The phone will be in Emergency Callback mode for <xliff:g id="count">%s</xliff:g> minute. While in this mode no apps using a data connection can be used. Do you want to exit now?</item>
        <!-- number of minutes is not equal to one -->
        <item quantity="other">The phone will be in Emergency Callback mode for <xliff:g id="count">%s</xliff:g> minutes. While in this mode no applications using a data connection can be used. Do you want to exit now?</item>
    </plurals>
    <!-- ECM: Dialog box message for exiting from any other app -->
    <plurals name="alert_dialog_not_avaialble_in_ecm">
        <!-- number of minutes is one -->
        <item quantity="one">The selected action isn\'t available while in the Emergency Callback mode. The phone will be in this mode for <xliff:g id="count">%s</xliff:g> minute. Do you want to exit now?</item>
        <!-- number of minutes is not equal to one -->
        <item quantity="other">The selected action isn\'t available while in the Emergency Callback mode. The phone will be in this mode for <xliff:g id="count">%s</xliff:g> minutes. Do you want to exit now?</item>
    </plurals>
    <!-- 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>

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


    <!-- Start of SIP related strings defined from here. -->

    <!-- Title displayed SIP settings coming after other call settings in the call features screen. [CHAR LIMIT=NONE] -->
    <string name="sip_settings">Internet call settings</string>
    <!-- Title displayed SIP account settings in the sip settings category. [CHAR LIMIT=NONE] -->
    <string name="sip_accounts">Internet calling (SIP) accounts</string>
    <!-- Title displayed SIP account settings in the sip settings category. [CHAR LIMIT=NONE] -->
    <string name="sip_accounts_title">Accounts</string>
    <!-- Title displayed for the button of receiving incoming SIP calls flag. Enabled for receiving calls. [CHAR LIMIT=NONE] -->
    <string name="sip_receive_calls">Receive incoming calls</string>
    <!-- Help user to understand that it will require more battery usage if the 'receiving incoming call' is enabled. [CHAR LIMIT=NONE] -->
    <string name="sip_receive_calls_summary">Reduces battery life</string>
    <!-- Title for the dialog of selecting the way we handle an outgoing call. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_title">Use Internet calling</string>
    <!-- Title for the dialog of selecting the way we handle an outgoing call (Wi-Fi only). [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_wifi_only_title">Use Internet calling (Wi-Fi only)</string>

    <!-- Item of the Internet call option dialog: for routing all outgoing calls via SIP. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_entry_1">For all calls when data network is available</string>
    <!-- Item of the Internet call option dialog: for routing a outgoing call via SIP if the destination is a SIP URI. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_entry_2">Only for Internet calls</string>
    <!-- Item of the Internet call option dialog: for asking user to select the way for each outgoing call. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_entry_3">Ask for each call</string>
    <!-- Item of the Internet call (Wi-Fi only) option dialog: for routing all outgoing calls via SIP. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_wifi_only_entry_1">For all calls</string>

    <!-- Title of the dialog to select the phone type for the outgoing call. [CHAR LIMIT=NONE] -->
    <string name ="pick_outgoing_call_phone_type">Place call</string>

    <!-- Title of the dialog to select the phone among the list of phones for the outgoing call. [CHAR LIMIT=NONE] -->
    <string name ="pick_outgoing_sip_phone">Use Internet calling account:</string>

    <!-- Text of checkbox to remember the sip phone for all outbound calls. [CHAR LIMIT=NONE] -->
    <string name ="remember_my_choice">Always use to place Internet calls</string>

    <!-- Help text of checkbox to unset the default sip phone for all outbound calls. [CHAR LIMIT=NONE] -->
    <string name ="reset_my_choice_hint">You can change which Internet calling account to use by default from the Phone &gt; Settings &gt; Internet call settings &gt; Accounts screen.</string>

    <!-- Item of the dialog to select the phone type for outgoing call. [CHAR LIMIT=NONE] -->
    <string name ="pstn_phone">Cell phone call</string>

    <!-- Item of the dialog to select the phone type for outgoing call. [CHAR LIMIT=NONE] -->
    <string name ="internet_phone">Internet call</string>

    <!-- Title of the dialog to redirect the user to SIP settings. [CHAR LIMIT=NONE] -->
    <string name ="no_sip_account_found_title">No Internet calling account</string>
    <!-- Message of the dialog to redirect the user to SIP settings. [CHAR LIMIT=NONE] -->
    <string name ="no_sip_account_found">There are no Internet calling accounts on this phone. Do you want to add one now?</string>
    <!-- Menu item for no sip account found dialog -->
    <string name="sip_menu_add">Add</string>

    <!-- Title for the button to add a new sip account. [CHAR LIMIT=NONE] -->
    <string name="add_sip_account">Add account</string>
    <!-- Title for the button to remove a sip account. [CHAR LIMIT=NONE] -->
    <string name="remove_sip_account">Remove account</string>
    <!-- String of the category which lists all sip accounts. [CHAR LIMIT=NONE] -->
    <string name="sip_account_list">SIP accounts</string>
    <!-- Toast message to indicate that the system is saving the account. [CHAR LIMIT=NONE] -->
    <string name="saving_account">Saving the account\u2026</string>
    <!-- Toast message to indicate that the system is removing the account. [CHAR LIMIT=NONE] -->
    <string name="removing_account">Removing the account\u2026</string>

    <!-- Menu item when the menu button is pressed in the sip account editor. [CHAR LIMIT=NONE] -->
    <string name="sip_menu_save">Save</string>
    <!-- Menu item when the menu button is pressed in the sip account editor. [CHAR LIMIT=NONE] -->
    <string name="sip_menu_discard">Discard</string>

    <!-- Title of the alert dialog. [CHAR LIMIT=NONE] -->
    <string name="alert_dialog_close">Close the profile</string>
    <!-- Title of the button to show in a alert dialog. [CHAR LIMIT=NONE] -->
    <string name="alert_dialog_ok">OK</string>
    <!-- Title of the button to show in a alert dialog. [CHAR LIMIT=NONE] -->
    <string name="close_profile">Close</string>

    <!-- Summary of a SIP account in the list of SIP accounts, consists of primary account status and registration status. This string indicates that this SIP account is a primary account and the string placeholder is the registration status, which will be one of the strings with name starting with "registration_status_" below. [CHAR LIMIT=NONE] -->
    <string name="primary_account_summary_with">Primary account. <xliff:g id="registration_status" example="Registering...">%s</xliff:g></string>
    <!-- Text of Internet-call registration status, checking current registration status with SIP service [CHAR LIMIT=NONE] -->
    <string name="registration_status_checking_status">Checking status...</string>
    <!-- Text of Internet-call registration status, registering with SIP server in order to receive calls on this account [CHAR LIMIT=NONE] -->
    <string name="registration_status_registering">Registering\u2026</string>
    <!-- Text of Internet-call registration status, still trying to register with SIP server [CHAR LIMIT=NONE] -->
    <string name="registration_status_still_trying">Still trying\u2026</string>
    <!-- Text of Internet-call registration status, currently not receiving calls on this account [CHAR LIMIT=NONE] -->
    <string name="registration_status_not_receiving">Not receiving calls.</string>
    <!-- Text of Internet-call registration status, no data connection [CHAR LIMIT=NONE] -->
    <string name="registration_status_no_data">Account registration stopped because there is no Internet connection.</string>
    <!-- Text of Internet-call registration status, no Wi-Fi connection [CHAR LIMIT=NONE] -->
    <string name="registration_status_no_wifi_data">Account registration stopped because there is no Wi-Fi connection.</string>
    <!-- Text of Internet-call registration status, registration process is not running due to some error [CHAR LIMIT=NONE] -->
    <string name="registration_status_not_running">Account registration unsuccessful.</string>
    <!-- Text of Internet-call registration status, currently we can receive calls on this account [CHAR LIMIT=NONE] -->
    <string name="registration_status_done">Receiving calls.</string>
    <!-- Text of Internet-call registration status, registration failed with a reason; will try again later [CHAR LIMIT=NONE] -->
    <string name="registration_status_failed_try_later">Account registration unsuccessful: (<xliff:g id="registration_error_message" example="timed out">%s</xliff:g>); will try later</string>
    <!-- Text of Internet-call registration status, registration failed due to invalid credentials [CHAR LIMIT=NONE] -->
    <string name="registration_status_invalid_credentials">Account registration unsuccessful: Incorrect username or password.</string>
    <!-- Text of Internet-call registration status, registration failed due to unknown host exception [CHAR LIMIT=NONE] -->
    <string name="registration_status_server_unreachable">Account registration unsuccessful: Check the server name.</string>
    <!-- Text for describing the account's owner and status. For example, 'Active, in use by Google Talk', it means that the account managed by SIP service was registered by the application 'Google Talk' and the status is active. [CHAR LIMIT=NONE] -->
    <string name="third_party_account_summary">This account is currently in use by the <xliff:g id="account_owner" example="Google Talk">%s</xliff:g> app.</string>


    <!-- Title of the sip editor screen. [CHAR LIMIT=NONE] -->
    <string name="sip_edit_title">SIP account details</string>
    <!-- Title of the sip editor screen. [CHAR LIMIT=NONE] -->
    <string name="sip_edit_new_title">SIP account details</string>

    <!-- Text of the domain address preference. [CHAR LIMIT=NONE] -->
    <string name="domain_address_title">Server</string>
    <!-- Text of the username preference. [CHAR LIMIT=NONE] -->
    <string name="username_title">Username</string>
    <!-- Text of the password preference. [CHAR LIMIT=NONE] -->
    <string name="password_title">Password</string>
    <!-- Text of the display name preference. [CHAR LIMIT=NONE] -->
    <string name="display_name_title">Display name</string>
    <!-- Text of the outbound proxy address preference. [CHAR LIMIT=NONE] -->
    <string name="proxy_address_title">Outbound proxy address</string>
    <!-- Text of the sip server/proxy port number. [CHAR LIMIT=NONE] -->
    <string name="port_title">Port number</string>
    <!-- Text of the transport type preference. [CHAR LIMIT=NONE] -->
    <string name="transport_title">Transport type</string>
    <!-- Text of the keepalive preference. [CHAR LIMIT=NONE] -->
    <string name="send_keepalive_title">Send keep-alive</string>
    <!-- Text of the set-primary preference. Simplified from "Make this my primary account". [CHAR LIMIT=NONE] -->
    <string name="set_primary_title">Set as primary account</string>
    <!-- Text of the set-primary preference summary. [CHAR LIMIT=NONE] -->
    <string name="set_primary_summary">Used for outbound calls</string>
    <!-- Text of the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings">Optional settings</string>
    <!-- Text of the username used in authentication. [CHAR LIMIT=NONE] -->
    <string name="auth_username_title">Authentication username</string>
    <!-- Help text of the auth_username field. [CHAR LIMIT=NONE] -->
    <string name="auth_username_summary">Username used for authentication</string>

    <!-- Initial status of the preferences is '<Not set>'. [CHAR LIMIT=NONE] -->
    <string name="default_preference_summary">&lt;Not set&gt;</string>
    <!-- Default value for the display-name preference summary. [CHAR LIMIT=NONE] -->
    <string name="display_name_summary">&lt;Same as username&gt;</string>
    <!-- Default value for the outbound-proxy-address preference summary. [CHAR LIMIT=NONE] -->
    <string name="optional_summary">&lt;Optional&gt;</string>

    <!-- Default sip server/proxy port number. -->
    <string translatable="false" name="default_port">5060</string>
    <!-- Default sip server/proxy transport protocol. -->
    <string translatable="false" name="default_transport">UDP</string>


    <!-- Hint to show the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings_show">▷ Touch to show all</string>
    <!-- Hint to hide the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings_hide">▽ Touch to hide all</string>

    <!-- Text in an alert dialog telling the user that some input field (name of which is also part of the strings being translated above) is required and can not be left blank. [CHAR LIMIT=NONE] -->
    <string name="empty_alert"><xliff:g id="input_field_name" example="Username, Password...">%s</xliff:g> is required and can\'t be left blank.</string>
    <!-- Showing that port number is out of range in an alert dialog. [CHAR LIMIT=NONE] -->
    <string name="not_a_valid_port">Port number should be within 1000 and 65534.</string>

    <!-- Title of the alert dialog to notify user that there is no Internet connectivity. [CHAR LIMIT=40] -->
    <string name="no_internet_available_title">No Internet connection</string>
    <!-- Title of the alert dialog to notify user that there is no Wi-Fi connectivity. [CHAR LIMIT=40] -->
    <string name="no_wifi_available_title">No Wi-Fi connection</string>
    <!-- Message of the alert dialog to notify user that there is no Internet connectivity. [CHAR LIMIT=NONE] -->
    <string name="no_internet_available">To place an Internet call, check your Internet connection first.</string>
    <!-- Message of the alert dialog to notify user that there is no Wi-Fi connectivity. [CHAR LIMIT=NONE] -->
    <string name="no_wifi_available">You need to be connected to a Wi-Fi network for Internet calls (use the Wireless &amp; Network settings).</string>
    <!-- Title of the alert dialog to notify user that Internet call is not supported. [CHAR LIMIT=40] -->
    <string name="no_voip">Internet calling not supported</string>

    <!-- Option for whether the SIP service should send keepalive messages. [CHAR LIMIT=40] -->
    <string translatable="true" name="sip_system_decide">Automatic</string>
    <!-- Option for whether the SIP service should send keepalive messages. [CHAR LIMIT=40] -->
    <string translatable="true" name="sip_always_send_keepalive">Always send</string>

    <!-- Do not translate the following strings. Used for the Internet call options. Need to be in-sync with Settings.System.SIP_ strings. -->
    <string translatable="false" name="sip_always">SIP_ALWAYS</string>
    <string translatable="false" name="sip_address_only">SIP_ADDRESS_ONLY</string>
    <string translatable="false" name="sip_ask_me_each_time">SIP_ASK_ME_EACH_TIME</string>

    <!-- Do not translate the following strings. Used for the preference keys -->
    <string translatable="false" name="domain_address">SipDomain</string>
    <string translatable="false" name="username">UserName</string>
    <string translatable="false" name="password">Password</string>
    <string translatable="false" name="display_name">DisplayName</string>
    <string translatable="false" name="proxy_address">ProxyAddress</string>
    <string translatable="false" name="port">Port</string>
    <string translatable="false" name="transport">Protocol</string>
    <string translatable="false" name="send_keepalive">SendKeepAlive</string>
    <string translatable="false" name="set_primary">SetPrimary</string>
    <string translatable="false" name="advanced_settings_container">advanced settings container</string>
    <string translatable="false" name="auth_username">AuthUserName</string>
    <!-- End of SIP settings related strings -->

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

    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_1">Can\'t talk now. What\'s up?</string>
    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_2">I\'ll call you right back.</string>
    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_3">I\'ll call you later.</string>
    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_4">Can\'t talk now. Call me later?</string>
    <!-- "Respond via SMS" option that lets you compose a custom response. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_custom_message">Custom message</string>

    <!-- Title of settings screen for managing the "Respond via SMS" feature. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_setting_title">Quick responses</string>
    <!-- Slightly more verbose title of settings screen for managing the
         "Respond via SMS" feature. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_setting_title_2">Edit quick responses</string>
    <!-- Settings summary string for the "Respond via SMS" feature. [CHAR LIMIT=40] -->
    <string name="respond_via_sms_setting_summary"></string>
    <!-- Dialog title when changing a string for the "Respond via SMS" feature. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_edittext_dialog_title">Quick response</string>

    <!-- "Respond via SMS": Confirmation message shown after sending
         a text response. [CHAR LIMIT=40] -->
    <string name="respond_via_sms_confirmation_format">Message sent to <xliff:g id="phone_number">%s</xliff:g>.</string>

    <!-- String describing the image on ImageButton one

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_one">one</string>

    <!-- String describing the image on ImageButton two

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_two">two</string>

    <!-- String describing the image on ImageButton three

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_three">three</string>

    <!-- String describing the image on ImageButton four

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_four">four</string>

    <!-- String describing the image on ImageButton five

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_five">five</string>

    <!-- String describing the image on ImageButton six

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_six">six</string>

    <!-- String describing the image on ImageButton seven

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_seven">seven</string>

    <!-- String describing the image on ImageButton eight

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_eight">eight</string>

    <!-- String describing the image on ImageButton nine

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_nine">nine</string>

    <!-- String describing the image on ImageButton star

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_star">star</string>

    <!-- String describing the image on ImageButton zero

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_zero">zero</string>

    <!-- String describing the image on ImageButton pound

         Note: AccessibilityServices use this attribute to announce what the view represents.
               This is especially valuable for views without textual representation like ImageView.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_image_button_pound">pound</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 Delete/Backspace ImageButton

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

    <!-- Content description of the speakerphone enabled notification icon for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_speakerphone_enabled">Speakerphone enabled.</string>

    <!-- Content description of the call muted notification icon for accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_call_muted">Call muted.</string>

    <!-- Description of the answer target in the Slide unlock screen of Phone. [CHAR LIMIT=NONE] -->
    <string name="description_target_answer">Answer</string>
    <!-- Description of the send_sms target in the Slide unlock screen of Phone. [CHAR LIMIT=NONE] -->
    <string name="description_target_send_sms">Send SMS</string>
    <!-- Description of the decline on target in the Slide unlock screen. [CHAR LIMIT=NONE] -->
    <string name="description_target_decline">Decline</string>

    <!-- Dialog title for the vibration settings for voicemail notifications [CHAR LIMIT=40] -->
    <string name="voicemail_notification_vibrate_when_title" msgid="8731372580674292759">Vibrate</string>
    <!-- Dialog title for the vibration settings for voice mail notifications [CHAR LIMIT=40]-->
    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="8995274609647451109">Vibrate</string>

    <!-- Voicemail ringtone title [CHAR LIMIT=40] -->
    <string name="voicemail_notification_ringtone_title">Ringtone</string>

    <!-- The vibrate notification modes for voicemail notifications -->
    <string-array name="voicemail_notification_vibrate_when_entries">
        <!-- Always [CHAR LIMIT=40] -->
        <item msgid="2539376794936035639">Always</item>
        <!-- Only when the phone is in Silent mode [CHAR LIMIT=40] -->
        <item msgid="8091719131860840185">Only when silent</item>
        <!-- Never [CHAR LIMIT=40] -->
        <item msgid="4552962311897985633">Never</item>
    </string-array>

    <!-- The default value value for voicemail notification. -->
    <string name="voicemail_notification_vibrate_when_default" translatable="false">never</string>

    <!-- Actual values used in our code for voicemail notifications. DO NOT TRANSLATE -->
    <string-array name="voicemail_notification_vibrate_when_values" translatable="false">
        <item>always</item>
        <item>silent</item>
        <item>never</item>
    </string-array>

    <!-- Setting option name to pick ringtone (a list dialog comes up). [CHAR LIMIT=30] -->
    <string name="ringtone_title" msgid="5379026328015343686">Phone ringtone</string>

    <!-- Setting option name to enable or disable vibration when ringing
         the phone.
         [CHAR LIMIT=40] -->
    <string name="vibrate_on_ring_title">Vibrate when ringing</string>

    <!-- Setting option name to enable or disable DTMF tone sound
         [CHAR LIMIT=40] -->
    <string name="dtmf_tone_enable_title">Dial pad touch tones</string>

    <!-- Title for the category "ringtone", which is shown above ringote settings
         [CHAR LIMIT=40] -->
    <string name="preference_category_ringtone">Ringtone</string>
</resources>
