<?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 (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: status label for a conference call -->
    <string name="confCall">Conference call</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>

    <!-- ECBM strings -->
    <string name="ecbm_mode_text">Emergency Call Back</string>
    <string name="ecbm_exit_text">EXIT</string>
    <string name="ecbm_ok_text">  OK  </string>
    <string name="ecbm_emergency_number">Dial 911</string>
    <string name="ecbm_instruction_text">Press button for emergency call</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>

    <!-- 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: button label on the "wait" prompt dialog -->
    <string name="send_button">Send</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>

    <!-- 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 GSM call 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, 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>
    
    <!-- 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>
    
    <!-- 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>
    <!-- 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>
    <!-- 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 -->
    <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.</string>
    <!-- Call settings screen, Set voicemail number dialog text -->
    <string name="no_change">No changes were made.</string>
    <!-- Call settings screen, "Voicemail" setting summary text -->
    <string name="sum_voicemail">Set voicemail number</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 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, 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>
    
    <!-- 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>
 
    <!-- 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="subscription_title">CDMA Subscription TEST</string>
    <string name="subscription_summary">Change between RUIM/SIM and NV</string>
    <string name="subscription_dialogtitle">subscription</string>
    <string-array name="subscription_choices">
        <item>RUIM/SIM</item>
        <item>NV</item>
    </string-array>
    <string-array name="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>

    <!-- 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 contact</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="adding_fdn_contact">Adding fixed dialing contact\u2026</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="fdn_contact_added">Fixed dialing contact added.</string>
    <!-- Title of "Edit FDN Contact" screen when editing an already-existing contact -->
    <string name="edit_fdn_contact">Edit fixed dialing contact</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="updating_fdn_contact">Updating fixed dialing contact\u2026</string>
    <!-- "Edit FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="fdn_contact_updated">Fixed dialing contact updated.</string>
    <!-- Title of "Delete FDN Contact" screen -->
    <string name="delete_fdn_contact">Delete fixed dialing contact</string>
    <!-- "Delete FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="deleting_fdn_contact">Deleting fixed dialing contact\u2026</string>
    <!-- "Delete FDN Contact" screen: status message displayed in a popup (toast) -->
    <string name="fdn_contact_deleted">Fixed dialing contact deleted.</string>
    <!-- FDN settings: error message displayed in a popup (toast) -->
    <string name="pin2_invalid">PIN2 invalid!</string>
    <!-- FDN settings: error message displayed in a popup (toast) -->
    <string name="fdn_invalid_number">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 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>

    <!-- 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>
    <!-- Label for the "Voicemail" notification item, when expanded. -->
    <string name="notification_voicemail_title">New voicemail</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>

    <!-- 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: Error message displayed in a  dialog when trying to dial without a SIM card. -->
    <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_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>

    <!-- 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">Tap twice\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">Tap twice\nto answer</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>

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

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

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

</resources>


