<?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">
    <!-- Launcher labels -->
    <!-- Tab title -->
    <string name="contactsIconLabel">Contacts</string>
    <!-- Tab title -->
    <string name="contactsFavoritesLabel">Favorites</string>
    <!-- Tab title -->
    <string name="dialerIconLabel">Dialer</string>
    <!-- Screen title for Emergency Dialer UI -->
    <string name="emergencyDialerIconLabel">Emergency Dialer</string>
    <!-- Application name on Home screen -->
    <string name="phoneIconLabel">Phone</string>
    <!-- Tab title -->
    <string name="recentCallsIconLabel">Call log</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>
    <!-- In-call screen: status label for the current active call -->
    <string name="ongoing">Current call</string>
    <!-- Possible error messages with outgoing calls -->
    <!-- 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 (peer unreachable) -->
    <string name="callFailed_unreachable">Number unreachable</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 cannot 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 (Phone is locked until next power cycle)-->
    <string name="callFailed_cdma_lockedUntilPowerCycle">CDMA: Phone locked until power cycle.</string>
    <!-- In-call screen: call failure reason (CDMA: call dropped)-->
    <string name="callFailed_cdma_drop">CDMA: Call dropped.</string>
    <!-- In-call screen: call failure reason (CDMA: call intercepted)-->
    <string name="callFailed_cdma_intercept">CDMA: Call intercepted.</string>
    <!-- In-call screen: call failure reason (CDMA reorder)-->
    <string name="callFailed_cdma_reorder">CDMA: reorder.</string>
    <!-- In-call screen: call failure reason (CDMA: Service Option Reject)-->
    <string name="callFailed_cdma_SO_reject">CDMA: Service Option Reject.</string>
    <!-- In-call screen: call failure reason (CDMA: retry order)-->
    <string name="callFailed_cdma_retryOrder">CDMA: retry order.</string>
    <!-- In-call screen: call failure reason (CDMA: Access failure)-->
    <string name="callFailed_cdma_accessFailure">CDMA: Access failure.</string>
    <!-- In-call screen: call failure reason (CDMA: Preempted)-->
    <string name="callFailed_cdma_preempted">CDMA: Preempted.</string>
    <!-- In-call screen: call failure reason (Only Emergency calls are possible)-->
    <string name="callFailed_cdma_notEmergency">Only Emergency calls are possible.</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>
    <!-- In-call screen: auto retry  -->
    <string name="retry">Retry</string>
    <!-- In-call screen: call lost title of dialog -->
    <string name="call_lost_title">Call Lost</string>

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

    <!-- In-call menu item labels -->
    <!-- Regular in-call menu items: -->
    <!-- In-call menu: Label for "speakerphone" menu item -->
    <string name="menu_speaker">Speaker</string>
    <!-- In-call menu: Label for "bluetooth" menu item -->
    <string name="menu_bluetooth">Bluetooth</string>
    <!-- In-call menu: Label for "mute" menu item -->
    <string name="menu_mute">Mute</string>
    <!-- In-call menu: Label for "hold" menu item -->
    <string name="menu_hold">Hold</string>
    <!-- In-call menu: Label for "end call" menu item -->
    <string name="menu_endCall">End call</string>
    <!-- In-call menu: Label for "swap calls" menu item -->
    <string name="menu_swapCalls">Swap calls</string>
    <!-- In-call menu: Label for "merge calls" menu item -->
    <string name="menu_mergeCalls">Merge calls</string>
    <!-- In-call menu: Label for "add call" menu item -->
    <string name="menu_addCall">Add call</string>
    <!-- In-call menu: Label for "manage conference call" menu item -->
    <string name="menu_manageConference">Manage conference call</string>
    <!-- In-call menu: Label for "show dialpad" menu item -->
    <string name="menu_showDialpad">Show dialpad</string>
    <!-- In-call menu: Label for "hide dialpad" menu item -->
    <string name="menu_hideDialpad">Hide dialpad</string>
    <!-- Incoming call menu items: -->
    <!-- Incoming call menu: Label for "Hold and answer" menu item -->
    <string name="menu_answerAndHold">Hold current call\n&amp; answer</string>
    <!-- Incoming call menu: Label for "End and answer" menu item -->
    <string name="menu_answerAndEnd">End current call\n&amp; answer</string>
    <!-- Other misc labels for the in-call UI -->
    <!-- Positive button label ("OK") used in several dialogs in the phone UI -->
    <string name="ok">OK</string>
    <!-- In-call screen, message just under call window when keyboard is closed -->
    <string name="menuButtonHint">Press Menu for call options.</string>
    <!-- In-call screen, message just under call window when keyboard is revealed -->
    <string name="menuButtonKeyboardDialHint">"Press Menu for call options  \u2022  Use keyboard to dial"</string>
    <!-- Incoming call menu: Label for "Answer" menu item -->
    <string name="menu_answer">Answer</string>
    <!-- Incoming call menu: Label for "Ignore" menu item -->
    <string name="menu_ignore">Ignore</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 the 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>

    <!-- Placeholder text displayed while loading a list of phone numbers
         into the dialer UI -->
    <string name="dialer_emptyListWorking">Loading\u2026</string>

    <!-- SIM PIN strings -->
    <!-- Instructional text on SIM PIN unlock panel -->
    <string name="enterPin">Type PIN code to unlock SIM card.</string>
    <!-- Success message displayed on SIM PIN unlock panel -->
    <string name="pinUnlocked">SIM unlocked</string>
    <!-- Label for PIN entry widget on SIM PIN unlock panel -->
    <string name="enterNewPin">New SIM PIN code</string>
    <!-- Label for PIN entry widget on SIM PIN unlock panel -->
    <string name="verifyNewPin">Type new SIM PIN code again to confirm</string>
    <!-- Error message displayed on SIM PIN unlock panel -->
    <string name="verifyFailed">The SIM PINs you typed do not match. Please try again.</string>
    <!-- Instructional text on SIM PIN unlock panel -->
    <string name="enterPuk">Type PUK code to unlock SIM card</string>
    <!-- Error message displayed on SIM PIN unlock panel -->
    <string name="badPuk">Incorrect PUK code!</string>
    <!-- Button label on SIM PIN unlock panel -->
    <string name="buttonTxtContinue">Continue</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>

    <!-- Title for the dialog used to display the user's IMEI number -->
    <string name="imei">IMEI</string>

    <!-- Title for the dialog used to display the user's MEID number on CDMA network -->
    <string name="meid">MEID</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 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 {0}</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 {0}</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 carrier does not 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 {0}</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 carrier does not 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 {0}</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 does not 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 -->
    <string name="fdn_only_error">Operations are only allowed on fixed dialing numbers.</string>
    <!-- Status message displayed in the "Call settings error" dialog -->
    <string name="radio_off_error">Please 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">
        <!-- 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 -->
    <!-- Call settings screen, Label used in "Save voicemail number" dialog -->
    <string name="vm_save_number">Save voicemail number</string>
    <!-- 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">Voicemail number change unsuccessful.\nPlease contact your carrier if this problem persists.</string>
    <!-- Call settings screen, displayed when vm provider supplied forwarding number change fails-->
    <string name="fw_change_failed">Forwarding number change unsuccessful.\nPlease contact your carrier if this problem persists.</string>
    <!-- Call settings screen, displayed when forwarding number read fails-->
    <string name="fw_get_in_vm_failed">Failed to retrieve and save current forwarding number settings.\nDo you want to switch 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 -->
    <!-- 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 does not allow a connection to this network.</string>
    <!-- Available networks screen, toast when unable to connect to a network temporarily -->
    <string name="connect_later">Unable to connect to this network at this time. Please 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">Select 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">Select automatically</string>
    <!-- Available networks screen, setting summary text -->
    <string name="sum_select_automatically">Automatically select preferred network</string>
    <string name="register_automatically">Automatic registration...</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>
    <string-array name="preferred_network_mode_choices">
        <item>Global</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">
        <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 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 have 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>
    <!-- Title for the data usage settings screen -->
    <string name="throttle_settings_title">Carrier data policy</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>

    <!-- Cell broadcast SMS strings -->
    <string name="cdma_cell_broadcast_sms">Cell Broadcast SMS</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>

    <!-- GSM/UMTS Options strings -->
    <string name="gsm_umts_network_preferences_title">GSM/UMTS Network Preferences</string>
    <string name="gsm_umts_network_preferneces_summary">Not implemented yet! </string>
    <string name="gsm_umts_network_preferences_dialogtitle">GSM/UMTS network preferences</string>
    <string-array name="gsm_umts_network_preferences_choices">
        <item>GSM/WCDMA (auto mode)</item>
        <item>WCDMA only</item>
        <item>GSM only</item>
        <item>GSM/WCDA (WCDMA preferred)</item>
    </string-array>
    <string-array name="gsm_umts_network_preferences_values">
        <item>"0"</item>
        <item>"1"</item>
        <item>"2"</item>
        <item>"3"</item>
    </string-array>

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

    <!-- CDMA Options strings -->
    <string name="cdma_roaming_mode_title">CDMA Roaming Mode</string>
    <string name="cdma_roaming_mode_summary">Change the cdma roaming mode</string>
    <string name="cdma_roaming_mode_dialogtitle">CDMA roaming mode</string>
    <string-array name="cdma_roaming_mode_choices">
        <item>Home Networks only</item>
        <item>Affiliated Networks</item>
        <item>Any Network</item>
    </string-array>
    <string-array name="cdma_roaming_mode_values">
        <item>"0"</item>
        <item>"1"</item>
        <item>"2"</item>
    </string-array>
    <string name="cdma_network_preferences_title">CDMA Network Preferences</string>
    <string name="cdma_network_preferneces_summary">Not implemented yet! </string>
    <string name="cdma_network_preferences_dialogtitle">CDMA network preferences</string>
    <string-array name="cdma_network_preferences_choices">
        <item>CDMA/EvDo</item>
        <item>CDMA only</item>
        <item>EvDo only</item>
    </string-array>
    <string-array name="cdma_network_preferences_values">
        <item>"0"</item>
        <item>"1"</item>
        <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>

    <!-- 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>
    <string name="voice_privacy">Voice Privacy</string>
    <string name="voice_privacy_summary">Enable enhanced privacy mode</string>
    <string name="tty_mode_title">TTY mode</string>
    <string name="tty_mode_summary">Enable TTY 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">Enter 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 not updated: you entered an incorrect PIN.</string>
    <!-- FDN settings: error message displayed in a popup (toast) -->
    <string name="fdn_invalid_number">FDN not updated: number cannot exceed 20 digits.</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>

    <!-- 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 is not correct. Please try again.</string>
    <!-- SIM PIN screen: error message -->
    <string name="mismatchPin">The PINs you entered do not match. Please 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 is not correct. Please try again. </string>
    <!-- SIM PIN2 screen: error message -->
    <string name="badPin2">The old PIN2 you typed is not correct. Please try again.</string>
    <!-- SIM PIN2 screen: error message -->
    <string name="mismatchPin2">The PIN2s you entered do not match. Please 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, please 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>
    <!-- In-call screen: Button label on "Manage conference" panel -->
    <string name="caller_manage_manage_done_text">Back to call</string>

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

    <!-- Button label on "SIM Missing" screen -->
    <string name="sim_missing_continueView_text">Continue without SIM card</string>
    <!-- Message displayed on "SIM Missing" screen -->
    <string name="sim_missing_msg_text">No SIM card found. Please insert a SIM card into the phone.</string>

    <!-- Button label on "SIM Unlock" screen -->
    <string name="sim_unlock_dismiss_text">Dismiss</string>
    <!-- Button label on "SIM Unlock" screen -->
    <string name="sim_unlock_unlock_text">Unlock</string>
    <!-- Progress message displayed on "SIM Unlock" screen -->
    <string name="sim_unlock_status_text">Authenticating PIN\u2026</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 call in progress -->
    <string name="card_title_in_progress">Current call</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 for an cdma call waiting -->
    <string name="card_title_cdma_call_waiting">Cdma callwaiting </string>
    <!-- In-call screen: status label displayed briefly after a call ends -->
    <string name="card_title_call_ended">Call ended</string>
    <!-- In-call screen: status label for call that's on hold -->
    <string name="card_title_on_hold">On hold</string>
    <!-- In-call screen: status label for a call that's in the process of hanging up -->
    <string name="card_title_hanging_up">Hanging up</string>
    <!-- In-call screen: status label for a call that's in CDMA flash mode -->
    <string name="card_title_in_call">In call</string>

    <!-- Notification strings -->
    <!-- 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. -->
    <string name="notification_ongoing_call_format">Current call (<xliff:g id="duration">%s</xliff:g>)</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>

    <!-- 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: status message displayed in a dialog when starting a feature code -->
    <string name="incall_status_dialed_fc">Starting feature code 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, please 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>

    <!-- Hint text displayed in the "digits" field at the top of the
         in-call DTMF dialpad.  (This hint reminds the user that the
         dialpad is there to generate tones, not to add a new call.) -->
    <string name="dtmfDialpadHintText">Touch tone keypad</string>

    <!-- Text displayed in the "sliding drawer handle" that you use to
         open the in-call DTMF dialpad. -->
    <string name="dtmfDialpadHandleLabel">Dialpad</string>

    <!-- Text displayed on the in-call screen's "touch lock" overlay,
         instructing the user that they need to double-tap to unlock the
         screen. -->
    <string name="touchLockText">Double-tap\nto unlock</string>

    <!-- Text for the onscreen "Answer" button, instructing the user that
         they need to double-tap to answer the incoming call. -->
    <string name="onscreenAnswerText">Double-tap\nto answer</string>
    <!-- Text for the onscreen "Decline" button -->
    <string name="onscreenRejectText">Double-tap\nto decline</string>
    <!-- Text for the onscreen "Hold" button -->
    <string name="onscreenHoldText">Hold</string>
    <!-- Text for the onscreen "Hold" button in the "Unhold" state -->
    <string name="onscreenUnholdText">Unhold</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 "Hide Dialpad" button -->
    <string name="onscreenHideDialpadText">Hide</string>
    <!-- Text for the onscreen "Speaker" button -->
    <string name="onscreenSpeakerText">Speaker</string>
    <!-- Text for the onscreen "Mute" button -->
    <string name="onscreenMuteText">Mute</string>
    <!-- Text for the onscreen "Bluetooth" button -->
    <string name="onscreenBluetoothText">Bluetooth</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 -->
    <string name="onscreenManageConferenceText">Manage</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>

    <!-- Label for ERI text widget, shown in list of all gadgets -->
    <string name="eri_text_label">ERI text</string>

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

    <!-- Message displayed on the OTA activation screen -->
    <string name="ota_touch_activate_new">Touch \u201CActivate\u201D to place a special call that activates your phone on your carrier\'s mobile network, so you can place calls and connect to mobile data networks.</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>
    <!-- Label shown on dialog button that continues with activation -->
    <string name="ota_skip_activation_dialog_continue_label">Activate</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 listen screen. This message should be short to ensure the dialer fits. -->
    <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_dialpad">Keypad</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">Please 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 did not 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>
    <!-- Button label shown on OTA screens to go back to the previous screen -->
    <string name="ota_back">Back</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 applications using a data connection can be used. Would you like 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. Would you like 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 is not available while in the emergency callback mode. The phone will be in this mode for <xliff:g id="count">%s</xliff:g> minute. Would you like to exit now?</item>
        <!-- number of minutes is not equal to one -->
        <item quantity="other">The selected action is not available while in the emergency callback mode. The phone will be in this mode for <xliff:g id="count">%s</xliff:g> minutes. Would you like to exit now?</item>
    </plurals>
    <!-- ECM: Dialog box message while in emergency call -->
    <string name="alert_dialog_in_ecm_call">The selected action is not 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 name="absent_num">ABSENT NUMBER</string>

    <!-- Voicemail dialog title -->
    <string name="voicemail_settings">Voicemail settings</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>

    <!-- Voicemail service pref title -->
    <string name="voicemail_provider">Voicemail service</string>

    <!-- Prefix on the voicemail settings preference. The full string will be Settings for <provider name> -->
    <string name="voicemail_settings_for">Settings for <xliff:g id="provider_name">%s</xliff:g></string>

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

    <!-- Label for onscreen "Dial" button used in the EmergencyDialer -->
    <string name="dial_button_label">Dial</string>

    <!-- Title displayed in the overlay when a call is placed using a 3rd party provider.
         ^1 is the localized name of the provider obtained from the package manager.
         ^2 is a phone number.
         E.g: "Calling via Google Voice\n 1-800-666-1234"
    -->
    <string name="calling_via_template">Calling via ^1\n<b>^2</b></string>

    <!-- Onscreen hints used for various states of the SlidingTab
         widget used for incoming calls. -->
    <eat-comment />
    <!-- Incoming call hint: drag the tab right to answer -->
    <string name="slide_to_answer">Drag right to answer</string>
    <!-- Incoming call hint: drag the tab left to silence ringer -->
    <string name="slide_to_silence">Drag left to silence ringer</string>
    <!-- Incoming call hint: drag the tab left to decline the incoming call -->
    <string name="slide_to_decline">Drag left to decline</string>
    <!-- Incoming call hint: drag the tab right to answer and hold the active call -->
    <string name="slide_to_answer_and_hold">Drag right to answer and\nhold active call</string>
    <!-- Incoming call hint: drag the tab right to answer and end the active call -->
    <string name="slide_to_answer_and_end_active">Drag right to answer and\nend active call</string>
    <!-- Incoming call hint: drag the tab right to answer and end the call on hold -->
    <string name="slide_to_answer_and_end_onhold">Drag right to answer and\nend call on hold</string>

    <!-- Incoming call hint shown on tab (must be kept very short): answer incoming call -->
    <string name="slide_to_answer_hint">Answer</string>
    <!-- Incoming call hint shown on tab (must be kept very short): decline incoming call -->
    <string name="slide_to_decline_hint">Decline</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">Manage Accounts</string>
    <!-- The Sip Account Settings's summary. [CHAR LIMIT=NONE] -->
    <string name="sip_accounts_summary">Manage SIP accounts and status</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">Requires more battery usage</string>
    <!-- Title for the button of configuring the way we handle an outgoing call. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options">Configure call options</string>
    <!-- Title for the dialog of selecting the way we handle an outgoing call. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_title">SIP calling options</string>

    <!-- Title for enabling the auto registration for all sip accounts.  [CHAR LIMIT=NONE] -->
    <string name="auto_reg">Auto Registration</string>
    <!-- Title for enabling the routing all outgoing calls via SIP. [CHAR LIMIT=NONE] -->
    <string name="call_priority">Outgoing Call via SIP</string>

    <!-- Title of the dialog to select the phone type for the outgoing call. [CHAR LIMIT=NONE] -->
    <string name ="pick_outgoing_call_phone_type">Call out via</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">"Select a SIP account to dial <xliff:g id="call_number" example="1-800-4664-411">%1$s</xliff:g></string>

    <!-- Text of checkbox to remember the sip phone for all outbound calls. [CHAR LIMIT=NONE] -->
    <string name ="remember_my_choice">"Use by default for all outbound 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">Clean default(primary) in Home Settings > Call settings > Manage accounts</string>

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

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

    <!-- Title of the dialog to redirect the user to SIP settings. [CHAR LIMIT=NONE] -->
    <string name ="no_sip_account_found_title">No SIP account found</string>
    <!-- Message of the dialog to redirect the user to SIP settings. [CHAR LIMIT=NONE] -->
    <string name ="no_sip_account_found">Need a SIP account to dial <xliff:g id="call_number" example="1-800-4664-411">%1$s</xliff:g>. Create one now?</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>

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

    <!-- Text of the account type. 'Primary' means the account is the one for sending all outgoing calls through. [CHAR LIMIT=NONE] -->
    <string name="primary_account">Primary</string>
    <!-- Title of the account type checkbox. Once the box is checked, the account will be the only 'primary' one among the accounts. [CHAR LIMIT=NONE] -->
    <string name="primary_account_title">Make this my primary account</string>
    <!-- Summary text of the account type checkbox. [CHAR LIMIT=NONE] -->
    <string name="primary_account_summary">Used for outbound calls.</string>
    <!-- Title of the advanced settings button. The button will show the advanced settings of a SIP account in the SIP editor [CHAR LIMIT=NONE] -->
    <string name="advanced_settings_title">Advanced settings</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...</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...</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, 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">Registration failed (<xliff:g id="registration_error_message" example="timed out">%s</xliff:g>); will try later</string>
    <!-- Text of Internet-call registration status, registration failed with a reason [CHAR LIMIT=NONE] -->
    <string name="registration_status_failed">Registration failed (<xliff:g id="registration_error_message" example="timed out">%s</xliff:g>)</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">Active, in use by <xliff:g id="account_owner" example="Google Talk">%s</xliff:g></string>


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

    <!-- Text of the domain address preference. [CHAR LIMIT=NONE] -->
    <string name="domain_address_title">Domain</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 keepalive preference summary. [CHAR LIMIT=NONE] -->
    <string name="send_keepalive_summary">Send SIP keep-alive messages</string>
    <!-- Text of the auto registration preference. [CHAR LIMIT=NONE] -->
    <string name="auto_registration_title">Auto. Registration</string>
    <!-- Text of the auto registration preference summary. [CHAR LIMIT=NONE] -->
    <string name="auto_registration_summary">Register the profile automatically</string>
    <!-- Text of the set-primary preference. Simplified from "Make this my primary account". [CHAR LIMIT=NONE] -->
    <string name="set_primary_title">Make this primary</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>

    <!-- 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">▷ Select to show all</string>
    <!-- Hint to hide the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings_hide">▽ Select 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, cannot 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 connectiviy</string>
    <!-- Title of the alert dialog to notify user that there is no WIFI connectivity. [CHAR LIMIT=40] -->
    <string name="no_wifi_available_title">No WIFI connectiviy</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 connectiviy first.</string>
    <!-- Message of the alert dialog to notify user that there is no WIFI connectivity. [CHAR LIMIT=NONE] -->
    <string name="no_wifi_available">Internet call is only available on WIFI. Enable your WIFI connectiviy in Settings > Wireless &amp; network settings.</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 SIP send-keepalive option values -->
    <string translatable="false" name="sip_system_decide">Let system decide</string>
    <string translatable="false" name="sip_always_send_keepalive">Always send</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="auto_registration">AutoRegistration</string>
    <string translatable="false" name="set_primary">SetPrimary</string>
    <string translatable="false" name="advanced_settings_container">advanced settings container</string>
    <!-- End of SIP settings related strings -->
</resources>
