<?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">
    <!-- Strings for Dialog yes button -->
    <string name="yes">"Yes"</string>

    <!-- Strings for Dialog no button -->
    <string name="no">"No"</string>

    <!-- Device Info --> <skip />
    <!-- Device Info screen. Used for a status item's value when the proper value is not known -->
    <string name="device_info_default">Unknown</string>

    <!-- Phone info -->
    <!-- Phone Info screen. Button label to turn on the radio . Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="turn_on_radio">Turn on radio</string>
    <!-- Phone Info screen. Button label to turn off the radio . Only shown in diagnostic screen, so precise translation is not needed. -->
    <string name="turn_off_radio">Turn off radio</string>

    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewADN">View SIM address book</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewFDN">View Fixed Dialing Numbers</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_viewSDN">View Service Dialing Numbers</string>
    <!-- Phone Info screen. Menu item label.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radioInfo_menu_getPDP">Get PDP list</string>

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

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

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

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

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

    <!-- Used for diagnostic info screens, precise translation isn't needed. Unmounts the SD card from the phone, meaning it will become available for an attached computer  -->
    <string name="sdcard_unmount">Unmount SD card</string>

    <!-- Used for diagnostic info screens, precise translation isn't needed. Formats the SD card in the phone, meaning it will be erased and reformatted -->
    <string name="sdcard_format">Format SD card</string>

    <!-- choice for the font size spinner -->
    <string name="small_font">Small</string>
    <!-- choice for the font size spinner -->
    <string name="medium_font">Medium</string>
    <!-- choice for the font size spinner -->
    <string name="large_font">Large</string>

    <!-- Do not translate. label for font size preview.  Does not need to be translated. -->
    <string name="font_size_preview_text">Servez à ce monsieur une bière et des kiwis.</string>
    <!-- Button. Chosen when they want to save the chosen text size. -->
    <string name="font_size_save">OK</string>

    <!-- Title for a notification shown. -->
    <string name="sdcard_setting">SD card</string>


    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_label">Battery status:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_power_label">Power plug:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_scale_label">Battery scale:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_level_label">Battery level:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_label">Battery health:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_technology_label">Battery technology:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_voltage_label">Battery voltage:</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_voltage_units">mV</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_temperature_label">Battery temperature:</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_temperature_units">\u00B0 C</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_uptime">Time since boot:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_awake_battery">Awake time on battery:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_awake_plugged">Awake time when charging:</string>
    <!-- Battery Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_screen_on">Screen ON time:</string>


    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_unknown">Unknown</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_charging">Charging</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_charging_ac">(AC)</string>
    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_charging_usb">(USB)</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_discharging">Discharging</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_not_charging">Not charging</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_status_full">Full</string>

    <!-- Battery Info screen. Units shown after a value.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_power_unplugged">Unplugged</string>
    <string name="battery_info_power_ac">AC</string>
    <string name="battery_info_power_usb">USB</string>
    <string name="battery_info_power_ac_usb">AC+USB</string>
    <string name="battery_info_power_unknown">Unknown</string>

    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_unknown">Unknown</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_good">Good</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_overheat">Overheat</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_dead">Dead</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_over_voltage">Over voltage</string>
    <!-- Battery Info screen. Value for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="battery_info_health_unspecified_failure">Unknown error</string>

    <!-- Used as setting title (for checkbox) on second screen after selecting Bluetooth settings -->
    <string name="bluetooth">Bluetooth</string>
    <!-- Bluetooth settings screen, check box label when the Bluetooth device can be seen by others -->
    <string name="bluetooth_visibility">Discoverable</string>
    <!-- Bluetooth settings screen, summary after selecting Discoverable check box -->
    <string name="bluetooth_is_discoverable">Discoverable for <xliff:g id="discoverable_time_period">%1$s</xliff:g> seconds\u2026</string>
    <!-- Bluetooth settings screen, Discoverable checkbox summary text -->
    <string name="bluetooth_not_discoverable">Make device discoverable</string>
    <!-- Bluetooth settings screen, heading above the list of nearby bluetooth devices -->
    <!-- Bluetooth settings screen, check box label whether or not to allow
        bluetooth voice dialing when lock screen is up-->
    <string name="bluetooth_lock_voice_dialing">Lock voice dialing</string>
    <!-- Bluetooth settings screen, lock voice dialing checkbox summary text -->
    <string name="bluetooth_lock_voice_dialing_summary">
      Prevent use of the bluetooth dialer when the screen is locked
    </string>

    <string name="bluetooth_devices">Bluetooth devices</string>
    <!-- Bluetooth settings screen, title for the current bluetooth name setting -->
    <string name="bluetooth_device_name">Device name</string>
    <!-- Bluetooth settings screen, summary text when there isn't a name set (for the name setting) -->
    <string name="bluetooth_name_not_set">No name set, using account name</string>
    <!-- Bluetooth settings screen, menu item to scan for nearby bluetooth devices -->
    <string name="bluetooth_scan_for_devices">Scan for devices</string>
    <!-- Bluetooth settings.  Message for disconnecting from a bluetooth device -->
    <string name="bluetooth_disconnect_blank"><xliff:g id="device_name">%1$s</xliff:g> will be disconnected.</string>
    <!-- Bluetooth settings.  Message when cnonected to a device -->
    <string name="bluetooth_connected">Connected</string>
    <!-- Bluetooth settings.  Message when a device is disconnected -->
    <string name="bluetooth_disconnected">Disconnected</string>
    <!-- Bluetooth settings.  Message when disconnecting from a device -->
    <string name="bluetooth_disconnecting">Disconnecting\u2026</string>
    <!-- Bluetooth settings.  Message when connecting to a device -->
    <string name="bluetooth_connecting">Connecting\u2026</string>
    <!-- Bluetooth settings.  Message when the device state is unknown -->
    <string name="bluetooth_unknown"></string>
    <!--Bluetooth settings screen, summary text under individual Bluetooth devices when not paired yet -->
    <string name="bluetooth_not_connected">Pair with this device</string>
    <!--Bluetooth settings screen, summary text under individual Bluetooth devices when pairing -->
    <string name="bluetooth_pairing">Pairing\u2026</string>
    <!--Bluetooth settings screen, summary text under individual Bluetooth devices when paired with one -->
    <string name="bluetooth_paired">Paired but not connected</string>
    <!--Bluetooth settings screen, summary text under individual Bluetooth devices that are hands free or a headset -->
    <string name="bluetooth_device">handsfree/headset</string>
    <!--Bluetooth settings screen, text that appears in heading bar when scanning for devices -->
    <string name="progress_scanning">Scanning</string>
    <!-- Notification ticker text (shown in the status bar) when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_ticker">Bluetooth pairing request</string>
    <!-- Notification title when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_title">Pairing request</string>
    <!-- Notification message when a Bluetooth device wants to pair with us -->
    <string name="bluetooth_notif_message">Select to pair with\u0020</string>

    <!-- Strings for BluetoothDevicePicker -->
    <string name="device_picker">Bluetooth device picker</string>

    <!-- Strings for dialog title when asking to the user whether to allow an app to enable discovery mode -->
    <string name="bluetooth_permission_request">"Bluetooth permission request"</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth -->
    <string name="bluetooth_ask_enablement">"An application on your phone is requesting permission to turn on Bluetooth. Do you want to do this?"</string>

    <!-- Strings for asking to the user whether to allow an app to enable discovery mode -->
    <string name="bluetooth_ask_discovery">"An application on your phone is requesting permission to make your phone discoverable by other Bluetooth devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Do you want to do this?"</string>

    <!-- Strings for asking to the user whether to allow an app to enable bluetooth and discovery mode -->
    <string name="bluetooth_ask_enablement_and_discovery">"An application on your phone is requesting permission to turn on Bluetooth and to make your phone discoverable by other devices for <xliff:g id="timeout">%1$d</xliff:g> seconds. Do you want to do this?"</string>

    <!-- Strings for msg to display to user while bluetooth is turning on -->
    <string name="bluetooth_turning_on">"Turning on Bluetooth\u2026"</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="bluetooth_scan_text">Empty button\u2026</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="bluetooth_settings_text">Empty button\u2026</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="bluetooth_enable_text">Empty button\u2026</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="bluetooth_device_info_connectButton_text">Turn on Bluetooth</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="bluetooth_device_info_deviceInfo_text"></string>

    <!-- Date & time settings screen title -->
    <string name="date_and_time">Date &amp; time settings</string>
    <!-- Date/time settings.  Summary of the checkbox for choosing between 12 hour time or 24 hour time.  Sample of 12-hour time -->
    <string name="date_time_12_hour_sample">1:00 pm</string>
    <!-- Date/time settings.  Summary of the checkbox for choosing between 12 hour time or 24 hour time.  Sample of 24-hour time -->
    <string name="date_time_24_hour_sample">13:00</string>
    <!-- Title of the dialog for setting the time. -->
    <string name="date_time_changeTime_text">Change time</string>
    <!-- Title of the dialog for setting the date. -->
    <string name="date_time_changeDate_text">Date</string>
    <!-- The title of the activity to pick a time zone. -->
    <string name="choose_timezone">Select time zone</string>
    <!-- Do not translate. Used as the value for a setting. -->
    <string name="default_date_format"><xliff:g id="default_date_format">MM/dd/yyyy</xliff:g></string>

    <!-- The option in the date-format picker for using the normal format
         called for by the user's locale. -->
    <string name="normal_date_format">Normal (<xliff:g id="date" example="12-31-2009">%s</xliff:g>)</string>

    <!-- Label of preview text when tweaking font size -->
    <string name="display_preview_label">Preview:</string>
    <!-- Label for chosen font size -->
    <string name="display_font_size_label">Font size:</string>

    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_data_label"><xliff:g id="data">Data:</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_sendbroadcast_text">Send <xliff:g id="broadcast">broadcast</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_action_label"><xliff:g id="action">Action</xliff:g>:</string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_startactivity_text">Start <xliff:g id="activity">activity</xliff:g></string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_resource_label"><xliff:g id="resource">Resource</xliff:g>: </string>
    <!-- Used for diagnostic screens, precise translation is not necessary -->
    <string name="intent_sender_account_label">Account: </string>

    <!-- HTTP proxy settings. Button to clear the proxy box. -->
    <string name="proxy_clear_text">Clear</string>
    <!-- HTTP proxy settings. The port number label. -->
    <string name="proxy_port_label">Port</string>
    <!-- HTTP proxy settings. The button to restore the defaults. -->
    <string name="proxy_defaultView_text">Restore defaults</string>
    <!-- HTTP proxy settings. The button to save. -->
    <string name="proxy_action_text">Save</string>
    <!-- HTTP proxy settings. The text field for the hostname -->
    <string name="proxy_hostname_label">Hostname</string>
    <!-- HTTP proxy settings. Title if there is an error-->
    <string name="proxy_error">Attention</string>
    <!-- HTTP proxy settings. Button to get rid of error box-->
    <string name="proxy_error_dismiss">OK</string>
    <!-- HTTP proxy settings. The error if the hostname is not valid -->
    <string name="proxy_error_invalid_host">The hostname you typed is not valid.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_port">You must complete the port field.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_empty_host_set_port">The port field must be empty if the host field is empty.</string>
    <!-- HTTP proxy settings. Error msg -->
    <string name="proxy_error_invalid_port">The port you typed is not valid.</string>

    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_location_label">Location:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_neighboring_location_label">Neighboring CID:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_attempts_label">Data attempts:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->

    <string name="radio_info_gprs_service_label">GPRS service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_roaming_label">Roaming:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_imei_label">IMEI:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_redirect_label">Call redirect:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_resets_label">Number of PPP reset since boot:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gsm_disconnects_label">GSM disconnects:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_current_network_label">Current network:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_data_successes_label">Data successes:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_received_label">PPP received:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_gsm_service_label">GSM service:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_signal_strength_label">Signal strength:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_call_status_label">Call status:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ppp_sent_label">PPP sent:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_radio_resets_label">Radio resets:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_message_waiting_label">Message waiting:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_phone_number_label">Phone number:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_band_mode_label">Select radio band</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_network_type_label">Network type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_set_perferred_label">Set preferred network type:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_ipaddr">Ping IpAddr:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_ping_hostname">Ping Hostname(www.google.com):</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_http_client_test">HTTP Client test:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="ping_test_label">Run ping test</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_label">SMSC:</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_update_label">Update</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_smsc_refresh_label">Refresh</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="radio_info_toggle_dns_check_label">Toggle DNS check</string>
    <!-- Radio Info screen. Label for a status item.  Used for diagnostic info screens, precise translation isn't needed -->
    <string name="oem_radio_info_label">OEM-specific Info/Settings</string>

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

    <!-- Instructions after the user changes the mass storage settings -->
    <string name="sdcard_changes_instructions">Changes take effect when USB cable is reconnected</string>
    <!-- Enable USB mass storage mode checkbox title -->
    <string name="sdcard_settings_screen_mass_storage_text">Enable USB mass storage</string>
    <!-- The label for total bytes on SD card -->
    <string name="sdcard_settings_total_bytes_label">Total bytes:</string>
    <!-- Message when there is no SD card present -->
    <string name="sdcard_settings_not_present_status">No SD card</string>
    <!-- Th label for the available (free) sapce on the SD card -->
    <string name="sdcard_settings_available_bytes_label">Available bytes:</string>
    <!-- Message when the SD card is being used by the computer as mass storage -->
    <string name="sdcard_settings_mass_storage_status">SD card is being used as a mass storage device</string>
    <!-- Message when it is safe to remove the SD card -->
    <string name="sdcard_settings_unmounted_status">It is now safe to remove the SD card</string>
    <!-- Error message when the SD card was removed without properly unmounting -->
    <string name="sdcard_settings_bad_removal_status">SD card was removed while still in use!</string>
    <!-- Label for used bytes on the SD card -->
    <string name="sdcard_settings_used_bytes_label">Used bytes:</string>
    <!-- Message when it is scanning the SD card for new files -->
    <string name="sdcard_settings_scanning_status">Scanning SD card for media\u2026</string>
    <!-- Message when the SD card is mounted as read only -->
    <string name="sdcard_settings_read_only_status">SD card mounted read-only</string>

    <!-- SetupWizard strings used by DateTimeSettingsSetupWizard.  The button label for going to the next screen. -->
    <string name="next_label">Next</string>

    <!-- LocalePicker -->
    <!-- Title for the locale picker activity -->
    <string name="language_picker_title">Locale</string>
    <!-- Locale picker screen. Label for choosing the locale -->
    <string name="select_your_language">Select your language</string>

    <!-- The title of the dialog to pick an activity.  This is shown when there are multiple activities that can do a particular action.  For example, suppose you click on the "Share" menu item in the Browser.  Since you can share the webpage URL via many communication methods, this dialog would come up with choices like "Email", "IM", etc.  This is a generic message, and the previous example is a single possible scenario (so please don't assume it's for the browser or anything :) ). -->
    <string name="activity_picker_label">Select activity</string>
    <!-- Do not translate. -->
    <string name="debug_intent_sender_label">Debug intent sender</string>
    <!-- The title of the activity to see random device info. -->
    <string name="device_info_label">Device info</string>
    <!-- The title of the activity to see battery info. -->
    <string name="battery_info_label">Battery info</string>
    <!-- The title of the activity to see battery history. -->
    <string name="battery_history_label">Battery history</string>
    <!-- The title of the activity to adjust display settings -->
    <string name="display_label">Display</string>
    <!-- The title of the activity to see phone info -->
    <string name="phone_info_label">Phone info</string>
    <!-- The title of the activity to adjust SD card settings-->
    <string name="sd_card_settings_label">SD card</string>
    <!-- The title of the activity to adjust proxy settings -->
    <string name="proxy_settings_label">Proxy settings</string>

    <!-- ======================================================================================= -->
    <!-- NEW STUFF -->
    <!-- ======================================================================================= -->

    <!-- Button label for generic cancel action -->
    <string name="cancel">Cancel</string>

    <!-- Main Settings screen title -->
    <string name="settings_label">Settings</string>
    <!-- Label for option to select a settings panel as a shortcut -->
    <string name="settings_shortcut">Settings</string>
    <!-- Wireless controls settings screen, setting check box label -->
    <string name="airplane_mode">Airplane mode</string>
    <!-- Wireless controls settings screen, setting option summary text -->
    <string name="airplane_mode_summary">Disable all wireless connections</string>
    <!-- Wireless controls settings screen, setting option summary text as airplane mode is being enabled (so it is disabling all wireless connections)  -->
    <string name="airplane_mode_turning_on">Disabling wireless connections\u2026</string>
    <!-- Wireless controls settings screen, setting option summary text as airplane mode is being disabled (so it is re-enabling all the wireless conenctions) -->
    <string name="airplane_mode_turning_off">Enabling wireless connections\u2026</string>
    <!-- Main Settings screen settings title for things like Wi-Fi, bluetooth, airplane mode.  This will take you to another screen with those settings. -->
    <string name="radio_controls_title">Wireless &amp; networks</string>
    <!-- Wireless Settings screen title for things like Wi-Fi, bluetooth, airplane mode. -->
    <string name="wireless_networks_settings_title">Wireless &amp; network settings</string>
    <!-- Main Settings screen settings summary text for the "Wireless controls" setting -->
    <string name="radio_controls_summary">Manage Wi-Fi, Bluetooth, airplane mode, mobile networks, &amp; VPNs</string>


    <!-- mobile network settings screen, setting check box title -->
    <string name="roaming">Data roaming</string>
    <!-- mobile network settings screen, setting option summary text when check box is selected -->
    <string name="roaming_enable">Connect to data services when roaming</string>
    <!-- mobile network settings screen, setting option summary text when check box is clear -->
    <string name="roaming_disable">Connect to data services when roaming</string>
    <!-- mobile network settings screen, dialog message when you are roaming and clear the "Data roaming" check box -->
    <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, button on dialog box that appears when you are roaming and clear the "Data roaming" check box -->
    <string name="roaming_turn_it_on_button">Turn it on</string>
    <!-- mobile network settings screen, message in dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_warning">Allow data roaming? You may incur significant roaming charges!</string>
    <!-- mobile network settings screen, title of dialog box that appears when you select the "Data roaming" check box -->
    <string name="roaming_reenable_title">Attention</string>
    <!-- mobile network settings screen, setting option name -->
    <string name="networks">Operator selection</string>
    <!-- mobile network settings screen, setting option summary text -->
    <string name="sum_carrier_select">Select a network operator</string>

    <!-- Date and time settings -->
    <!-- Main Settings screen setting option name to go into the date and time settings-->
    <string name="date_and_time_settings_title">Date &amp; time</string>
    <!-- Main Settings screen setting option summary text for the item to go into the date and time settings. -->
    <string name="date_and_time_settings_summary">Set date, time, time zone &amp; formats</string>
    <!-- Date & time setting screen setting check box title if the date and time should be determined automatically -->
    <string name="date_time_auto">Automatic</string>
    <!-- Date & time setting screen setting option summary text when Automatic check box is selected (that is, when date and time should be determined automatically) -->
    <string name="date_time_auto_summaryOn">Use network-provided values</string>
    <!-- Date & time setting screen setting option summary text when Automatic check box is clear -->
    <string name="date_time_auto_summaryOff">Use network-provided values</string>
    <!-- Date & time setting screen setting check box title -->
    <string name="date_time_24hour">Use 24-hour format</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_time">Set time</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_timezone">Select time zone</string>
    <!-- Date & time setting screen setting option title -->
    <string name="date_time_set_date">Set date</string>
    <!-- Date & time setting screen setting option title.  This setting allows the user to choose how the date should be displayed in apps (what ordering for month and day, etc.) -->
    <string name="date_time_date_format">Select date format</string>
    <!-- Menu item on Select time zone screen -->
    <string name="zone_list_menu_sort_alphabetically">Sort alphabetically</string>
    <!-- Menu item on Select time zone screen -->
    <string name="zone_list_menu_sort_by_timezone">Sort by time zone</string>

    <!-- Security Settings --><skip />

    <!-- Main Settings screen setting option title for the item to take you the security and location screen -->
    <string name="security_settings_title">Location &amp; security</string>
    <!-- Location & security settings screen title -->
    <string name="location_security_settings_title">Location &amp; security settings</string>
    <!-- Main Settings screen setting option summary text for the item tot ake you to the security and location screen -->
    <string name="security_settings_summary">Set My Location, screen unlock, SIM card lock, credential storage lock</string>
    <!-- Main Settings screen setting option summary text for the item to take you to the CDMA security and location screen -->
    <string name="cdma_security_settings_summary">Set My Location, screen unlock, credential storage lock</string>
    <!-- In the security screen, the header title for settings related to  Passwords-->
    <string name="security_passwords_title">Passwords</string>

    <!-- Unlock Picker Settings --><skip />

    <!-- Security Picker --><skip />
    <!--  Title for security picker to choose the unlock method: None/Pattern/PIN/Password -->
    <string name="lock_settings_picker_title">Screen unlock security</string>

    <!--  Main Security lock settings --><skip />
    <!--  Title for PreferenceScreen to launch picker for security method when there is none -->
    <string name="unlock_set_unlock_launch_picker_title">Set up screen lock</string>

    <!--  Summary for PreferenceScreen to launch picker for security method when there is none -->
    <string name="unlock_set_unlock_launch_picker_summary">Lock screen with a pattern, PIN, or password</string>

    <!--  Title for PreferenceScreen to change security method: None/Pattern/PIN/Password  -->
    <string name="unlock_set_unlock_launch_picker_change_title">Change screen lock</string>

    <!--  Summary for PreferenceScreen to changeecurity method: None/Pattern/PIN/Password  -->
    <string name="unlock_set_unlock_launch_picker_change_summary">Change or disable pattern, PIN, or password security</string>


    <!-- Title for preference that disables unlock security -->
    <string name="unlock_set_unlock_none_title">None</string>
    <!-- Summary for preference that disables unlock security -->
    <string name="unlock_set_unlock_none_summary">Disable screen unlock security</string>

    <!-- Title for preference that guides the user through creating an unlock pattern -->
    <string name="unlock_set_unlock_pattern_title">Pattern</string>
    <!-- Summary for preference that guides the user through creating an unlock pattern -->
    <string name="unlock_set_unlock_pattern_summary">Draw pattern to unlock screen</string>

    <!-- Title for preference that guides the user through creating an unlock PIN (Personal Identification Number)  -->
    <string name="unlock_set_unlock_pin_title">PIN</string>
    <!-- Summary for preference that guides the user through creating an unlock PIN (Personal Identification Number)  -->
    <string name="unlock_set_unlock_pin_summary">Enter a numeric PIN to unlock screen</string>

    <!-- Title for preference that guides the user through creating an unlock password -->
    <string name="unlock_set_unlock_password_title">Password</string>
    <!-- Title for preference that guides the user through creating an unlock password -->
    <string name="unlock_set_unlock_password_summary">Enter a password to unlock screen</string>

    <!-- Summary for preference that has been disabled by DevicePolicyAdmin -->
    <string name="unlock_set_unlock_disabled_summary">Disabled by remote phone administrator</string>


    <!-- Title for option to turn of password/pin/pattern unlock. -->
    <string name="unlock_disable_lock_title">Turn off screen lock</string>

    <!-- Summary shown under unlock_disable_lock_title when pattern is in use and can be removed -->
    <string name="unlock_disable_lock_pattern_summary">Remove unlock pattern</string>
    <!-- Summary shown under unlock_disable_lock_title when PIN is in use and can be removed -->
    <string name="unlock_disable_lock_pin_summary">Remove unlock PIN</string>
    <!-- Summary shown under unlock_disable_lock_title when password is in use and can be removed -->
    <string name="unlock_disable_lock_password_summary">Remove unlock password</string>

    <!-- Title shown on security settings to allow the user to change their lockscreen pattern -->
    <string name="unlock_change_lock_pattern_title">Change unlock pattern</string>
    <!-- Title shown on security settings to allow the user to change their lockscreen PIN -->
    <string name="unlock_change_lock_pin_title">Change unlock PIN</string>
    <!-- Title shown on security settings to allow the user to change their lockscreen password -->
    <string name="unlock_change_lock_password_title">Change unlock password</string>

    <!-- Hint shown in dialog screen when password is too short -->
    <string name="lockpassword_password_too_short">Password must be at least %d characters</string>
    <!-- Hint shown in dialog screen when PIN is too short -->
    <string name="lockpassword_pin_too_short">PIN must be at least %d characters</string>

    <!-- Hint shown after minimum password criteria is met -->
    <string name="lockpassword_press_continue">Press Continue when done</string>

    <!-- Hint shown after minimum password criteria is met -->
    <string name="lockpassword_continue_label">Continue</string>

    <!-- Error shown in popup when password is too long -->
    <string name="lockpassword_password_too_long">PIN can be no longer than %d digits</string>
    <!-- Error shown in popup when PIN is too long -->
    <string name="lockpassword_pin_too_long">PIN can be no longer than %d digits</string>

    <!-- Error shown when in PIN mode and user enters a non-digit -->
    <string name="lockpassword_pin_contains_non_digits">PIN must contain only digits 0-9</string>

    <!-- Error shown when in PASSWORD mode and user enters an invalid character -->
    <string name="lockpassword_illegal_character">Password contains an illegal character</string>

    <!-- Error shown when in PASSWORD mode and password is all digits -->
    <string name="lockpassword_password_requires_alpha">Password must contain at least one letter</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain any digits -->
    <string name="lockpassword_password_requires_digit">Password must contain at least one digit</string>

    <!-- Error shown when in PASSWORD mode and password doesn't contain any symbols -->
    <string name="lockpassword_password_requires_symbol">Password must contain at least one symbol</string>

    <!-- Label for ChoosePassword/PIN OK button -->
    <string name="lockpassword_ok_label">OK</string>

    <!-- Label for ChoosePassword/PIN OK button -->
    <string name="lockpassword_cancel_label">Cancel</string>

    <!-- In the security screen, the header title for settings related to device admins -->
    <string name="device_admin_title">Device administration</string>

    <!-- Title of preference to manage device admins -->
    <string name="manage_device_admin">Select device administrators</string>

    <!-- Summary of preference to manage device policies -->
    <string name="manage_device_admin_summary">Add or remove device administrators</string>

    <!-- Bluetooth settings -->
    <!-- Bluetooth settings check box title on Main Settings screen -->
    <string name="bluetooth_quick_toggle_title">Bluetooth</string>
    <!-- Bluetooth settings check box summary for turning on bluetooth -->
    <string name="bluetooth_quick_toggle_summary">Turn on Bluetooth</string>
    <!--Used as title on second screen after selecting Bluetooth settings -->
    <string name="bluetooth_settings">Bluetooth settings</string>
    <!--Wireless controls screen, settings title for the item to take you to the bluetooth settings screen -->
    <string name="bluetooth_settings_title">Bluetooth settings</string>
    <!--Wireless controls screen, settings summary for the item tot ake you to the bluetooth settings screen -->
    <string name="bluetooth_settings_summary">Manage connections, set device name &amp; discoverability</string>

    <!-- Title for the dialog to enter PIN.  -->
    <string name="bluetooth_pairing_request">Bluetooth pairing request</string>
    <!-- Title for the bluetooth device info screen. -->
    <string name="bluetooth_device_info">Bluetooth device info</string>
    <!-- Message when bluetooth dialog for pin entry is showing -->
    <string name="bluetooth_enter_pin_msg">\nType PIN to pair with \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022. (Try 0000 or 1234.)</string>
    <!-- Message when bluetooth dialog for passkey entry is showing -->
    <string name="bluetooth_enter_passkey_msg">\nType passkey to pair with \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022.</string>
    <!-- Message when bluetooth dialog for confirmation of passkey is showing -->
    <string name="bluetooth_confirm_passkey_msg">To pair with \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022, confirm that it is showing the passkey: <xliff:g id="passkey">%2$s</xliff:g>.</string>
    <!-- Message when bluetooth incoming pairing request for (2.1 devices) dialog is showing -->
    <string name="bluetooth_incoming_pairing_msg"><xliff:g id="device_name">%1$s</xliff:g>\nwants to pair.</string>
    <!-- Message when bluetooth dialog when passkey needs to be displayed. -->
    <string name="bluetooth_display_passkey_msg">Enter <xliff:g id="passkey">%2$s</xliff:g> on \u0022<xliff:g id="device_name">%1$s</xliff:g>\u0022 to pair. </string>
    <!-- Button text for accepting an incoming pairing request -->
    <string name="bluetooth_pairing_accept">Pair</string>
    <!-- Button text for declining an incoming pairing request -->
    <string name="bluetooth_pairing_decline">Don\u0027t Pair</string>
    <!-- Generic string for remote Bluetooth device  -->
    <string name="bluetooth_remote_device">bluetooth device</string>

    <!-- Title for BT error dialogs. -->
    <string name="bluetooth_error_title">Attention</string>
    <!-- Message for the error dialog when BT pairing fails generically. -->
    <string name="bluetooth_pairing_error_message">There was a problem pairing with <xliff:g id="device_name">%1$s</xliff:g>.</string>
    <!-- Message for the error dialog when BT pairing fails because the PIN /
    Passkey entered is incorrect. -->
    <string name="bluetooth_pairing_pin_error_message">There was a problem pairing with <xliff:g id="device_name">%1$s</xliff:g> because the PIN or Passkey is incorrect.</string>
    <!-- Message for the error dialog when BT pairing fails because the other device is down. -->
    <string name="bluetooth_pairing_device_down_error_message">Cannot establish communication with <xliff:g id="device_name">%1$s</xliff:g>.</string>
    <!-- Message for the error dialog when BT pairing fails because the other device rejected the pairing. -->
    <string name="bluetooth_pairing_rejected_error_message">Pairing rejected by <xliff:g id="device_name">%1$s</xliff:g>.</string>

    <!-- Message for the error dialog when BT connecting operation fails generically. -->
    <string name="bluetooth_connecting_error_message">There was a problem connecting to <xliff:g id="device_name">%1$s</xliff:g>.</string>

    <!-- Do not translate -->
    <string name="bluetooth_device_info_alias">Device alias</string>
    <!-- Do not translate -->
    <string name="bluetooth_device_info_no_alias">Type alias here\u2026</string>
    <!-- Do not translate -->
    <string name="bluetooth_device_info_delete">Remove this device</string>
    <!-- Do not translate -->
    <string name="bluetooth_device_info_sdp">List supported services</string>

    <!-- Bluetooth settings: The title of the preference (list item) that initiates a scan for devices -->
    <string name="bluetooth_preference_scan_title">Scan for devices</string>

    <!-- Bluetooth settings.  Context menu item for a device.  Action will connect to all profiles on the device. -->
    <string name="bluetooth_device_context_connect">Connect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect from all profiles on the device. -->
    <string name="bluetooth_device_context_disconnect">Disconnect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will first pair, and then connect to all profiles on the device. -->
    <string name="bluetooth_device_context_pair_connect">Pair &amp; connect</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will remove pairing with the device. -->
    <string name="bluetooth_device_context_unpair">Unpair</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will disconnect and remove pairing with the device. -->
    <string name="bluetooth_device_context_disconnect_unpair">Disconnect &amp; unpair</string>
    <!-- Bluetooth settings.  Context menu item for a device.  Action will take the user to another screen where they can choose exactly which profiles to connect to. -->
    <string name="bluetooth_device_context_connect_advanced">Options\u2026</string>

    <!-- Bluetooth settings.  The title of the screen to pick which profiles to connect to on the device.  For example, headphones may have both A2DP and headset, this allows the user to choose which one he wants to connect to. -->
    <string name="bluetooth_connect_specific_profiles_title">Connect to\u2026</string>

    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the A2DP profile. -->
    <string name="bluetooth_profile_a2dp">Media</string>
    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the headset or handsfree profile. -->
    <string name="bluetooth_profile_headset">Phone</string>
    <!-- Bluetooth settings.  The user-visible string that is used whenever referring to the OPP profile. -->
    <string name="bluetooth_profile_opp">Transfer</string>

    <!-- Bluetooth settings.  The summary string when a device is connected to the A2DP profile. -->
    <string name="bluetooth_summary_connected_to_a2dp">Connected to media audio</string>
    <!-- Bluetooth settings.  The summary string when a device is connected to the headset profile. -->
    <string name="bluetooth_summary_connected_to_headset">Connected to phone audio</string>
    <!-- Bluetooth settings.  The summary string when a device is connected to the A2DP and headset profiles. -->
    <string name="bluetooth_summary_connected_to_a2dp_headset">Connected to phone and media audio</string>

    <!-- Bluetooth settings.  Connection options screen.  The title of the screen. -->
    <string name="bluetooth_device_advanced_title"><xliff:g id="device_name">%1$s</xliff:g> options</string>
    <!-- Bluetooth settings.  Connection options screen.  The title of the checkbox that controls whether the device is in "online" mode or "offline" mode.  This essentially is the checkbox that controls whether any checks / unchecks on a profile should be applied immediately, or next time the device is connected. -->
    <string name="bluetooth_device_advanced_online_mode_title">Connect</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary of the online mode checkbox.  This describes what the setting does in the context of the screen. -->
    <string name="bluetooth_device_advanced_online_mode_summary">Connect to Bluetooth device</string>
    <!-- Bluetooth settings.  Connection options screen.  The title of the header that is above all of the profiles. -->
    <string name="bluetooth_device_advanced_profile_header_title">Profiles</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the A2DP checkbox preference when A2DP is connected. -->
    <string name="bluetooth_a2dp_profile_summary_connected">Connected to media audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the headset checkbox preference when headset is connected. -->
    <string name="bluetooth_headset_profile_summary_connected">Connected to phone audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference when OPP is connected. -->
    <string name="bluetooth_opp_profile_summary_connected">Connected to file transfer server</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference when OPP is not connected. -->
    <string name="bluetooth_opp_profile_summary_not_connected">Not connected to file transfer server</string>

    <!-- Bluetooth settings.  Connection options screen.  The summary for the A2DP checkbox preference that describes how checking it will set the A2DP profile as preferred. -->
    <string name="bluetooth_a2dp_profile_summary_use_for">Use for media audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the headset checkbox preference that describes how checking it will set the headset profile as preferred. -->
    <string name="bluetooth_headset_profile_summary_use_for">Use for phone audio</string>
    <!-- Bluetooth settings.  Connection options screen.  The summary for the OPP checkbox preference that describes how checking it will set the OPP profile as preferred. -->
    <string name="bluetooth_opp_profile_summary_use_for">Use for file transfer</string>

    <!-- Bluetooth settings.  Dock Setting Title -->
    <string name="bluetooth_dock_settings">Dock Settings</string>
    <!-- Bluetooth settings.  Dock Setting Dialog Title -->
    <string name="bluetooth_dock_settings_title">Use dock for audio</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Checkbox selection 1: Use dock as speaker phone -->
    <string name="bluetooth_dock_settings_headset">As speaker phone</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Checkbox selection 2: Use dock for media audio -->
    <string name="bluetooth_dock_settings_a2dp">For music and media</string>
    <!-- Bluetooth settings.  Dock Setting Dialog - Remember setting and don't ask user again -->
    <string name="bluetooth_dock_settings_remember">Remember settings</string>

    <!-- Wi-Fi Settings --> <skip />
    <!-- Used in the 1st-level settings screen to turn on Wi-Fi -->
    <string name="wifi_quick_toggle_title">Wi-Fi</string>
    <!-- Used in the 1st-level settings screen as the turn-on summary -->
    <string name="wifi_quick_toggle_summary">Turn on Wi-Fi</string>
    <!-- Used in the 1st-level settings screen to go to the 2nd-level settings screen -->
    <string name="wifi_settings">Wi-Fi settings</string>
    <!-- Title of the Wi-fi settings screen -->
    <string name="wifi_settings_category">Wi-Fi settings</string>
    <!-- Summary text of the Wi-fi settings screen -->
    <string name="wifi_settings_summary">Set up &amp; manage wireless access points</string>
    <!-- Summary text when turning Wi-Fi or bluetooth on -->
    <string name="wifi_starting">Turning on\u2026</string>
    <!-- Summary text when turning Wi-Fi or bluetooth off -->
    <string name="wifi_stopping">Turning off\u2026</string>
    <!-- Summary text when Wi-Fi or bluetooth has error -->
    <string name="wifi_error">Error</string>
    <!-- Toast message when Wi-Fi or bluetooth is disallowed in airplane mode -->
    <string name="wifi_in_airplane_mode">In airplane mode</string>
    <!-- Toast message when Wi-Fi cannot scan for networks -->
    <string name="wifi_fail_to_scan">Unable to scan for networks</string>
    <!-- Checkbox title for option to notify user when open networks are nearby -->
    <string name="wifi_notify_open_networks">Network notification</string>
    <!-- Checkbox summary for option to notify user when open networks are nearby -->
    <string name="wifi_notify_open_networks_summary">Notify me when an open network is available</string>
    <!-- Action message to manually add a wifi network -->
    <string name="wifi_add_network">Add Wi-Fi network</string>
    <!-- Header for the list of wifi networks-->
    <string name="wifi_access_points">Wi-Fi networks</string>
    <!-- Menu option to scan Wi-Fi networks -->
    <string name="wifi_menu_scan">Scan</string>
    <!-- Menu option to Wi-Fi advanced settings -->
    <string name="wifi_menu_advanced">Advanced</string>
    <!-- Menu option to connect to a Wi-Fi network -->
    <string name="wifi_menu_connect">Connect to network</string>
    <!-- Menu option to delete a Wi-Fi network -->
    <string name="wifi_menu_forget">Forget network</string>
    <!-- Menu option to modify a Wi-Fi network configuration -->
    <string name="wifi_menu_modify">Modify network</string>

    <!-- Dialog for Access Points --> <skip />
    <!-- Label for the SSID of the network -->
    <string name="wifi_ssid">Network SSID</string>
    <!-- Label for the security of the connection -->
    <string name="wifi_security">Security</string>
    <!-- Label for the signal strength of the connection -->
    <string name="wifi_signal">Signal strength</string>
    <!-- Label for the status of the connection -->
    <string name="wifi_status">Status</string>
    <!-- Label for the link speed of the connection -->
    <string name="wifi_speed">Link speed</string>
    <!-- Label for the IP address of the connection -->
    <string name="wifi_ip_address">IP address</string>
    <!-- Label for the EAP method of the network -->
    <string name="wifi_eap_method">EAP method</string>
    <!-- Label for the phase2 -->
    <string name="please_select_phase2">Phase 2 authentication</string>
    <!-- Label for the EAP CA certificate of the network -->
    <string name="wifi_eap_ca_cert">CA certificate</string>
    <!-- Label for the EAP user certificate of the network -->
    <string name="wifi_eap_user_cert">User certificate</string>
    <!-- Label for the EAP identity of the network -->
    <string name="wifi_eap_identity">Identity</string>
    <!-- Label for the EAP anonymous identity of the network -->
    <string name="wifi_eap_anonymous">Anonymous identity</string>
    <!-- Label for the password of the secured network -->
    <string name="wifi_password">Password</string>
    <!-- Label for the check box to show password -->
    <string name="wifi_show_password">Show password.</string>
    <!-- Hint for unchanged fields -->
    <string name="wifi_unchanged">(unchanged)</string>
    <!-- Hint for unspecified fields -->
    <string name="wifi_unspecified">(unspecified)</string>
    <!-- Summary for the remembered network. -->
    <string name="wifi_remembered">Remembered</string>
    <!-- Summary for the disabled network. -->
    <string name="wifi_disabled">Disabled</string>
    <!-- Summary for the remembered network but currently not in range. -->
    <string name="wifi_not_in_range">Not in range</string>
    <!-- Summary for the secured network. -->
    <string name="wifi_secured">Secured with <xliff:g id="wifi_security">%1$s</xliff:g></string>
    <!-- Summary for the secured and remembered network. Status can be "Remembered", "Disabled" or "Not in range". -->
    <string name="wifi_secured_with_status"><xliff:g id="wifi_status">%2$s</xliff:g>, secured with <xliff:g id="wifi_security">%1$s</xliff:g></string>
    <!-- Button label to connect to a Wi-Fi network -->
    <string name="wifi_connect">Connect</string>
    <!-- Button label to delete a Wi-Fi network -->
    <string name="wifi_forget">Forget</string>
    <!-- Button label to save a Wi-Fi network configuration -->
    <string name="wifi_save">Save</string>
    <!-- Button label to dismiss the dialog -->
    <string name="wifi_cancel">Cancel</string>

    <!-- Wi-Fi Advanced Settings --> <skip />
    <!-- Wi-Fi settings screen, advanced, settings section.  This is a header shown above advanced wifi settings. -->
    <string name="wifi_advanced_titlebar">Advanced</string>
    <!-- Wi-Fi settings screen, setting title for choosing the number of channels to be used -->
    <string name="wifi_setting_num_channels_title">Regulatory domain</string>
    <!-- Wi-Fi settings screen, setting summary for choosing the number of channels to be used -->
    <string name="wifi_setting_num_channels_summary">Set the number of channels to use</string>
    <!-- Wi-Fi settings screen, generic error message when the regulatory domain could not be set. -->
    <string name="wifi_setting_num_channels_error">There was a problem setting the regulatory domain.</string>
    <!-- Wi-Fi settings screen, label to be appended to the count in displaying the list of valid channel counts -->
    <string name="wifi_setting_num_channels_channel_phrase"><xliff:g id="num_channels">%1$d</xliff:g> channels</string>
    <!-- Wi-Fi settings screen, setting title for setting the wifi sleep policy -->
    <string name="wifi_setting_sleep_policy_title">Wi-Fi sleep policy</string>
    <!-- Wi-Fi settings screen, setting summary for setting the wifi sleep policy -->
    <string name="wifi_setting_sleep_policy_summary">Specify when to switch from Wi-Fi to mobile data</string>
    <!-- Wi-Fi settings screen, generic error message when the sleep policy could not be set. -->
    <string name="wifi_setting_sleep_policy_error">There was a problem setting the sleep policy.</string>
    <!-- Wi-Fi settings screen, advanced, title of the item to show the Wi-Fi device's MAC address. -->
    <string name="wifi_advanced_mac_address_title">MAC address</string>
    <!-- Title of the screen to adjust IP settings -->
    <string name="wifi_ip_settings_titlebar">IP settings</string>
    <!-- Menu ietm to save the IP settings -->
    <string name="wifi_ip_settings_menu_save">Save</string>
    <!-- Menu ietm to cancel the IP settings -->
    <string name="wifi_ip_settings_menu_cancel">Cancel</string>
    <!-- Error message if the IP address is not valid -->
    <string name="wifi_ip_settings_invalid_ip">Please type a valid IP address.</string>
    <!-- Checkbox for whether to use a static IP address -->
    <string name="wifi_use_static_ip">Use static IP</string>
    <!-- Label for the DNS (first one) -->
    <string name="wifi_dns1">DNS 1</string>
    <!-- Label for the DNS (second one)-->
    <string name="wifi_dns2">DNS 2</string>
    <!-- Label for the gateway of the network -->
    <string name="wifi_gateway">Gateway</string>
    <!-- Label for the netmask of the network -->
    <string name="wifi_netmask">Netmask</string>

    <!-- Wifi AP settings-->
    <!-- Label for wifi tether checkbox. Toggles Access Point on/off -->
    <string name="wifi_tether_checkbox_text">Portable Wi-Fi hotspot</string>
    <!-- Subtext for wifi tether checkbox on success -->
    <string name="wifi_tether_enabled_subtext">Portable hotspot <xliff:g id="network_ssid">%1$s</xliff:g> active</string>
    <!-- Subtext for wifi tether checkbox on failure -->
    <string name="wifi_tether_failed_subtext">Portable Wi-Fi hotspot error</string>
    <!-- Label for Wi-fi tether settings preference -->
    <string name="wifi_tether_settings_text">Portable Wi-Fi hotspot settings</string>
    <!-- Subtext for Wi-fi tether settings preference -->
    <string name="wifi_tether_settings_subtext">Set up &amp; manage portable Wi-Fi hotspot</string>
    <!-- Title of the Wi-fi settings screen -->
    <string name="wifi_tether_settings_title">Portable Wi-Fi hotspot settings</string>
    <!-- Used to open the ssid and security dialog for Wifi Access Point -->
    <string name="wifi_tether_configure_ap_text">Configure Wi-Fi hotspot</string>
    <!-- Subtext on configuration preference to indicate SSID and security chosen -->
    <string name="wifi_tether_configure_subtext"><xliff:g id="network_ssid">%1$s</xliff:g> <xliff:g id="network_security">%2$s</xliff:g> portable Wi-Fi hotspot</string>
    <!-- Default access point SSID used for tethering -->
    <string name="wifi_tether_configure_ssid_default">AndroidHotspot</string>


    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Wi-Fi Testing on the diagnostic screen-->
    <string name="testing_wifi_info" translatable="false">Wifi information</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager disableNetwork API-->
    <string name="disableNetwork" translatable="false">disableNetwork</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager enableNetwork API-->
    <string name="enableNetwork" translatable="false">enableNetwork</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager disconnect API-->
    <string name="disconnect" translatable="false">disconnect</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager getConfiguredNetworks API-->
    <string name="getConfiguredNetworks" translatable="false">getConfiguredNetworks</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item for WifiManager getConnectionInfo API-->
    <string name="getConnectionInfo" translatable="false">getConnectionInfo</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_api_test" translatable="false">Wifi API</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_status_test" translatable="false">Wifi Status</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Button text on Wifi Status screen-->
    <string name="wifi_update" translatable="false">Refresh Stats</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="wifi_state_label" translatable="false">Wifi State :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="network_state_label" translatable="false">Network State :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
        Label on Wifi Status screen-->
    <string name="supplicant_state_label" translatable="false">Supplicant State :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="rssi_label" translatable="false">RSSI :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="bssid_label" translatable="false">BSSID :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="ssid_label" translatable="false">SSID :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="hidden_ssid_label" translatable="false">Hidden SSID :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="ipaddr_label" translatable="false">IPaddr :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="macaddr_label" translatable="false">MAC addr :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="networkid_label" translatable="false">Network ID :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="link_speed_label" translatable="false">Link Speed :</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Status screen-->
    <string name="scan_list_label" translatable="false">Scan results :</string>

    <!-- wifi state values-->
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_disabling" translatable="false">Disabling</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_disabled" translatable="false">Disabled</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_enabling" translatable="false">Enabling</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_enabled" translatable="false">Enabled</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary -->
    <string name="wifi_state_unknown" translatable="false">Unknown</string>

    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Menu item on Wifi information screen-->
    <string name="wifi_config_info" translatable="false">Wifi Config</string>
    <!-- Do not translate. Used for diagnostic screens, precise translation is not necessary
         Label on Wifi Configuration screen-->
    <string name="config_list_label" translatable="false">Configured Networks</string>

    <!-- Sound and alerts settings -->
    <!-- Main Settings screen setting option name to go into the sound settings screen -->
    <string name="sound_settings_title">Sound</string>
    <!-- Main Settings screen setting option name to go into the display settings screen -->
    <string name="display_settings_title">Display</string>
    <!-- Sound settings screen heading -->
    <string name="sound_settings">Sound settings</string>
    <!-- Sound settings screen, setting option name checkbox -->
    <string name="silent_mode_title">Silent mode</string>
    <!-- Sound settings screen, setting option summary text when going into silent mode.  Media and alarms sounds WILL NOT be silenced in silent mode. -->
    <string name="silent_mode_summary">Silence all sounds except media &amp; alarms</string>
    <!-- Sound settings screen, setting option summary text when going into silent mode.  Media WILL NOT be silenced in silent mode, but alarms WILL be silenced. -->
    <string name="silent_mode_incl_alarm_summary">All sounds except media are silenced</string>
    <!-- Sound settings screen, setting option name to pick ringtone (a list dialog comes up)-->
    <string name="ringtone_title">Phone ringtone</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="ringtone_summary">""</string>
    <!-- Sound settings screen, volume title -->
    <string name="all_volume_title">Volume</string>
    <!-- Sound settings screen, setting option name -->
    <string name="ring_volume_title">Ringer volume</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="ring_volume_summary">""</string>
    <!-- Sound settings screen, setting option name checkbox -->
    <string name="vibrate_in_silent_title">Vibrate when silent</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="vibrate_in_silent_summary">Allow vibration feedback in silent mode</string>
    <!-- Sound settings screen, setting option name checkbox -->
    <string name="vibrate_title">Vibrate</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="vibrate_summary">Vibration feedback for calls and notifications</string>
    <!-- Sound settings screen, setting option name -->
    <string name="notification_sound_title">Notification ringtone</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="notification_sound_summary">""</string>
    <!-- Sound settings screen, notification light repeat pulsing title -->
    <string name="notification_pulse_title">Pulse notification light</string>
    <!-- Sound settings screen, notification light repeat pulsing summary -->
    <string name="notification_pulse_summary">Pulse trackball light repeatedly for new notifications</string>
    <!-- Sound settings screen, the title of the volume bar to adjust the incoming call volume -->
    <string name="incoming_call_volume_title">Ringtone</string>
    <!-- Sound settings screen, the title of the volume bar to adjust the notification volume -->
    <string name="notification_volume_title">Notification</string>
    <!-- Sound settings screen, the caption of the checkbox for having the notification volume be
         the same as the incoming call volume. -->
    <string name="checkbox_notification_same_as_incoming_call">Use incoming call volume for notifications</string>
    <!-- Sound settings screen, setting option title-->
    <string name="notification_sound_dialog_title">Select notification ringtone</string>
    <!-- Sound settings screen, setting option name -->
    <string name="media_volume_title">Media</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="media_volume_summary">Set volume for music and videos</string>
    <!-- Sound settings screen, alarm volume slider title -->
    <string name="alarm_volume_title">Alarm</string>
    <!-- Sound settings screen, dock settings summary-->
    <string name="dock_settings_summary">Audio settings for the attached dock</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="dtmf_tone_enable_title">Audible touch tones</string>
    <!-- Sound settings screen, setting option summary text when check box is selected -->
    <string name="dtmf_tone_enable_summary_on">Play tones when using dial pad</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="dtmf_tone_enable_summary_off">Play tones when using dial pad</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="sound_effects_enable_title">Audible selection</string>
    <!-- Sound settings screen, setting option summary text when check box is selected -->
    <string name="sound_effects_enable_summary_on">Play sound when making screen selection</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="sound_effects_enable_summary_off">Play sound when making screen selection</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="lock_sounds_enable_title">Screen lock sounds</string>
    <!-- Sound settings screen, setting option summary text when check box is selected -->
    <string name="lock_sounds_enable_summary_on">Play sounds when locking and unlocking the screen</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="lock_sounds_enable_summary_off">Play sounds when locking and unlocking the screen</string>
    <!-- Sound settings screen, setting check box label -->
    <string name="haptic_feedback_enable_title">Haptic feedback</string>
    <!-- Sound settings screen, setting option summary text when check box is selected -->
    <string name="haptic_feedback_enable_summary_on">Vibrate when pressing soft keys and on certain UI interactions</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="haptic_feedback_enable_summary_off">Vibrate when pressing soft keys and on certain UI interactions</string>
    <!-- Sound settings screen, setting option name checkbox to enable/disable audio recording features that improve audio recording in noisy environments -->
    <string name="audio_record_proc_title">Noise cancellation</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="audio_record_proc_summary">Suppress background noise when speaking or recording.</string>

    <!-- Dock settings title, top level -->
    <string name="dock_settings">Dock</string>
    <!-- Dock settings title -->
    <string name="dock_settings_title">Dock settings</string>
    <!-- Dock audio settings -->
    <string name="dock_audio_settings_title">Audio</string>
    <!-- Dock audio summary for docked to desk dock -->
    <string name="dock_audio_summary_desk">Settings for the attached desktop dock</string>
    <!-- Dock audio summary for docked to car dock -->
    <string name="dock_audio_summary_car">Settings for the attached car dock</string>
    <!-- Dock audio summary for undocked -->
    <string name="dock_audio_summary_none">Phone not docked</string>
    <!-- Dock audio summary for docked to unknown -->
    <string name="dock_audio_summary_unknown">Settings for the attached dock</string>
    <!-- Dock not found dialog title -->
    <string name="dock_not_found_title">Dock not found</string>
    <!-- Dock not found dialog text -->
    <string name="dock_not_found_text">The phone must be docked to configure dock audio</string>
    <!-- Dock settings screen, dock events SFX setting check box label -->
    <string name="dock_sounds_enable_title">Dock insertion sound</string>
    <!-- Dock settings screen, setting option summary text when check box is selected -->
    <string name="dock_sounds_enable_summary_on">Play sound when inserting or removing phone from dock</string>
    <!-- Sound settings screen, setting option summary text when check box is clear -->
    <string name="dock_sounds_enable_summary_off">Don\'t play sound when inserting or removing phone from dock</string>

    <!-- Acounts & Sync settings screen setting option name to go into the screen for data sync settings-->
    <string name="sync_settings">Accounts &amp; sync</string>
    <!-- Main Settings screen setting option summary text for the itme to go into the screen with data sync settings-->
    <string name="sync_settings_summary">Add or remove accounts and change account settings</string>

    <!-- Main Settings screen, setting option name to go into search settings -->
    <string name="search_settings">Search</string>
    <!-- Main Settings screen, setting option summary to go into search settings -->
    <string name="search_settings_summary">Manage search settings and history</string>

    <!-- Display settings -->
    <!-- Sound & display settings screen, section header for settings related to display -->
    <string name="display_settings">Display settings</string>
    <!-- Sound & display settings screen, animations check box label -->
    <string name="animations_title">Animation</string>
    <!-- Sound & display settings screen, animations option summary text when check box is selected -->
    <string name="animations_summary_on">Show animation when opening &amp; closing windows</string>
    <!-- Sound & display settings screen, animations option summary text when check box is clear -->
    <string name="animations_summary_off">Show animation when opening &amp; closing windows</string>
    <!-- Sound & display settings screen, accelerometer-based rotation check box label -->
    <string name="accelerometer_title">Auto-rotate screen</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is selected -->
    <string name="accelerometer_summary_on">Switch orientation automatically when rotating phone</string>
    <!-- Sound & display settings screen, accelerometer-based rotation summary text when check box is clear -->
    <string name="accelerometer_summary_off">Switch orientation automatically when rotating phone</string>
    <!-- Sound & display settings screen, setting option name to change brightness -->
    <string name="brightness">Brightness</string>
    <!-- Sound & display settings screen, setting option summary to change brightness -->
    <string name="brightness_summary">Adjust the brightness of the screen</string>
    <!-- Sound & display settings screen, setting option name to change screen timeout -->
    <string name="screen_timeout">Screen timeout</string>
    <!-- Sound & display settings screen, setting option summary to change screen timeout -->
    <string name="screen_timeout_summary">Adjust the delay before the screen automatically turns off</string>
    <!-- Sound & display settings screen, setting option name to change whether the screen adjusts automatically based on lighting conditions -->
    <string name="automatic_brightness">Automatic brightness</string>

    <!-- SIM lock settings title -->
    <string name="sim_lock_settings">SIM card lock settings</string>
    <!-- Security & location settings screen, setting option name -->
    <string name="sim_lock_settings_category">Set up SIM card lock</string>
    <!-- Security & location settings screen, section heading for settings related to sim card locking -->
    <string name="sim_lock_settings_title">SIM card lock</string>
    <!-- SIM card lock settings screen, setting check box label -->
    <string name="sim_pin_toggle">Lock SIM card</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is selected -->
    <string name="sim_lock_on">Require PIN to use phone</string>
    <!-- SIM card lock settings screen, setting option summary text when SIM lock check box is clear -->
    <string name="sim_lock_off">Require PIN to use phone</string>
    <!-- SIM card lock settings screen, setting option name to change the SIM PIN -->
    <string name="sim_pin_change">Change SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enter_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enable_sim_lock">Lock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_disable_sim_lock">Unlock SIM card</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enter_old">Old SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_enter_new">New SIM PIN</string>
    <string name="sim_reenter_new">Re-type new PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message instruction -->
    <string name="sim_change_pin">SIM PIN</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when wrong PIN is entered -->
    <string name="sim_bad_pin">Incorrect PIN!</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when PINs don't match -->
    <string name="sim_pins_dont_match">PINs don\'t match!</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
    <string name="sim_change_failed">Unable to change PIN.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog message when the entered PIN is correct-->
    <string name="sim_change_succeeded">SIM PIN changed successfully</string>
    <!-- SIM card lock settings screen, toast after not entering correct SIM PIN -->
    <string name="sim_lock_failed">Unable to change SIM card lock state.\nPossibly incorrect PIN.</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
    <string name="sim_enter_ok">OK</string>
    <!-- SIM card lock settings screen, SIM PIN dialog button labels: -->
    <string name="sim_enter_cancel">Cancel</string>

    <!-- Advanced (used for diagnostics) device info activity title -->
    <string name="device_info_settings">Phone status</string>

    <!-- About phone screen, list item title.  Takes the user to the screen for seeing and installing system updates. -->
    <string name="system_update_settings_list_item_title">System updates</string>
    <!-- About phone screen, list item summary.  Takes the user to the screen for seeing and installing system updates. -->
    <string name="system_update_settings_list_item_summary">""</string>

    <!-- About phone screen, status item label -->
    <string name="firmware_version">Android version</string>
    <!-- About phone screen, status item label-->
    <string name="model_number">Model number</string>
    <!-- About phone screen,  setting option name-->
    <string name="baseband_version">Baseband version</string>
    <!-- About phone screen,  setting option name-->
    <string name="kernel_version">Kernel version</string>
    <!-- About phone screen,  setting option name-->
    <string name="build_number">Build number</string>

    <!-- About phone screen, show when a value of some status item is unavailable. -->
    <string name="device_info_not_available">Not available</string>
    <!-- About phone screen, phone status screen title -->
    <string name="device_status_activity_title">Status</string>
    <!-- About phone screen, title of the item to go into the Phone status screen -->
    <string name="device_status">Status</string>
    <!-- About phone screen, summary of the item to go into the phone status screen -->
    <string name="device_status_summary">Phone number, signal, etc.</string>
    <!-- Main settings screen item's title to go into the SD card and storage settings screen-->
    <string name="storage_settings">SD card &amp; phone storage</string>
    <!-- SD card and storage settings screen title -->
    <string name="storage_settings_title">SD card &amp; phone storage settings</string>
    <!-- Main settings screen item's summary for the SD card and storage settings -->
    <string name="storage_settings_summary">Unmount SD card, view available storage</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_imei">IMEI</string>
    <!-- Do not translate. About phone, status item title -->
    <string name="status_imei_sv">IMEI SV</string>
    <!-- About phone, status item title.  The phone number of the current device.-->
    <string name="status_number">My phone number</string>
    <!-- About phone, status item title.  The phone MIN number of the current device.-->
    <string name="status_min_number">MIN</string>
    <!-- About phone, status item title.  The phone PRL Version of the current device.-->
    <string name="status_prl_version">PRL Version</string>
    <!-- About phone, status item title.  The phone MEID number of the current device.-->
    <string name="status_meid_number">MEID</string>
    <!-- About phone, status item title for the type of data phone network we're connected to, for example 3G or Edge or GPRS -->
    <string name="status_network_type">Mobile network type</string>
    <!-- About phone, status item title. The status of data access.  For example, the value may be "Connected" -->
    <string name="status_data_state">Mobile network state</string>
    <!-- About phone, status item title. The status of whether we have service.  for example, the value may be "In service" -->
    <string name="status_service_state">Service state</string>
    <!-- About phone, status item title. The  current cell tower signal strength -->
    <string name="status_signal_strength">Signal strength</string>
    <!-- About phone, status item title, The status for roaming.  For example, the value might be "Not roaming" -->
    <string name="status_roaming">Roaming</string>
    <!-- About phone, status item title. The cell carrier that the user is connected to.  -->
    <string name="status_operator">Network</string>
    <!-- About phone, status item title.  The MAC address of the Wi-Fi network adapter. -->
    <string name="status_wifi_mac_address">Wi-Fi MAC address</string>
    <!-- About phone, status item title.  The bluetooth adapter's hardware address-->
    <string name="status_bt_address">Bluetooth address</string>
    <!-- About phone, status item value if the actual value is not available. -->
    <string name="status_unavailable">Unavailable</string>
    <!-- About phone, status item title.  How long the device has been running since its last reboot. -->
    <string name="status_up_time">Up time</string>
    <!-- About phone, status item title.  How much time the device has had its main CPU awake. -->
    <string name="status_awake_time">Awake time</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the phone's internal storage  -->
    <string name="internal_memory">Internal phone storage</string>
    <!-- SD card & phone storage settings screen heading. This is displayed above items that pertain to the SD card -->
    <string name="sd_memory">SD card</string>
    <!-- SD card & phone storage settings title. The amount of free space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section. -->
    <string name="memory_available">Available space</string>
    <!-- SD card & phone storage settings screen heading.  The total amount of storage space for some storage partition.  For example, this is listed under both the "Internal phone storage" section and the "SD card" section -->
    <string name="memory_size">Total space</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   -->
    <string name="sd_eject">Unmount SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.  This will be done before the user phyiscally removes the SD card from the phone.  Kind of like the "Safely remove" on some operating systems.   -->
    <string name="sd_eject_summary">Unmount the SD card for safe removal</string>


    <!-- SD card & phone storage settings item summary that is displayed when no SD card is inserted -->
    <string name="sd_insert_summary">Insert an SD card for mounting</string>
    <!-- SD card & phone storage settings item title that will result in the phone mounting the SD card. -->
    <string name="sd_mount">Mount SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone mounting the SD card. -->
    <string name="sd_mount_summary">Mount the SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone formatting the SD card.   -->
    <string name="sd_format">Format SD card</string>
    <!-- SD card & phone storage settings item title that will result in the phone unmounting the SD card.   -->
    <string name="sd_format_summary">Format (erase) the SD card</string>
    <!-- SD card status when it is not available status -->
    <string name="sd_unavailable">Unavailable</string>
    <!-- SD card status when it is mounted as read only  -->
    <string name="read_only">\u0020(Read-only)</string>
    <!-- SD card eject confirmation dialog title   -->
    <string name="dlg_confirm_unmount_title">Unmount SD card</string>
    <!-- SD card eject confirmation dialog  -->
    <string name="dlg_confirm_unmount_text">If you unmount the SD card, some applications you are using will stop and may be unavailable until you remount the SD card.</string>
    <!-- SD card eject error dialog title   -->
    <string name="dlg_error_unmount_title">Unmount SD card failed</string>
    <!-- SD card eject error dialog text   -->
    <string name="dlg_error_unmount_text">Cannot unmount SD card. Try again later.</string>
    <!-- SD card unmount informative text   -->
    <string name="unmount_inform_text">SD card will be unmounted. Check the notification area for status.</string>
    <!-- SD card eject progress title   -->
    <string name="sd_ejecting_title">Unmounting</string>
    <!-- SD card eject progress text   -->
    <string name="sd_ejecting_summary">Unmount in progress</string>

    <!-- Phone info screen, section titles: -->
    <string name="battery_status_title">Battery status</string>
    <!-- Phone info screen, section titles: -->
    <string name="battery_level_title">Battery level</string>

    <!-- APN Settings -->
    <!-- APN settings screen title -->
    <string name="apn_settings">APNs</string>
    <!-- Screen title after user selects APNs setting option -->
    <string name="apn_edit">Edit access point</string>
    <!-- Edit access point label summary text when no value has been set -->
    <string name="apn_not_set">&lt;Not set&gt;</string>
    <!-- Edit access point labels: A label the user can give to the APN to allow him to differentiate it from the others -->
    <string name="apn_name">Name</string>
    <!-- Edit access point labels: The actual access point name-->
    <string name="apn_apn">APN</string>
    <!-- Edit access point labels: The addess of the proxy to use for this APN -->
    <string name="apn_http_proxy">Proxy</string>
    <!-- Edit access point labels: The port number of the proxy to use for this APN -->
    <string name="apn_http_port">Port</string>
    <!-- Edit access point labels: The username that will be used when conencting to this APN-->
    <string name="apn_user">Username</string>
    <!-- Edit access point labels: The password that will be used when connecting to this APN -->
    <string name="apn_password">Password</string>
    <!-- Edit access point labels: The server address to conenct to for this APN -->
    <string name="apn_server">Server</string>
    <!-- Edit access point labels: -->
    <string name="apn_mmsc">MMSC</string>
    <!-- Edit access point labels: The proxy to use for MMS (multimedia messages)-->
    <string name="apn_mms_proxy">MMS proxy</string>
    <!-- Edit access point labels: The port on the proxy used for MMS-->
    <string name="apn_mms_port">MMS port</string>
    <!-- Edit access point labels: -->
    <string name="apn_mcc">MCC</string>
    <!-- Edit access point labels: -->
    <string name="apn_mnc">MNC</string>
    <!-- Edit acces  point labels: Authenticaton type-->
    <string name="apn_auth_type">Authentication type</string>
    <!-- Authentication Typs: None -->
    <string name="apn_auth_type_none">None</string>
    <!-- Authentication Typs: PAP -->
    <string name="apn_auth_type_pap">PAP</string>
    <!-- Authentication Typs: CHAP -->
    <string name="apn_auth_type_chap">CHAP</string>
    <!-- Authentication Typs: PAP or CHAP -->
    <string name="apn_auth_type_pap_chap">PAP or CHAP</string>
    <!-- Edit access point labels: The type of APN -->
    <string name="apn_type">APN type</string>
    <!-- Edit access point screen menu option to delete this APN -->
    <string name="menu_delete">Delete APN</string>
    <!-- APNs screen menu option to create a brand spanking new APN -->
    <string name="menu_new">New APN</string>
    <!-- Edit access point screen menu option to save the user's changes for this APN to the persistent storage -->
    <string name="menu_save">Save</string>
    <!-- Edit access point screen menu option to discard the user's changes for this APN -->
    <string name="menu_cancel">Discard</string>
    <!-- APN error dialog title -->
    <string name="error_title">Attention</string>
    <!-- APN error dialog messages: -->
    <string name="error_name_empty">The Name field cannot be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_apn_empty">The APN cannot be empty.</string>
    <!-- APN error dialog messages: -->
    <string name="error_mcc_not3">MCC field must be 3 digits.</string>
    <!-- APN error dialog messages: -->
    <string name="error_mnc_not23">MNC field must be 2 or 3 digits.</string>
    <!-- The message of dialog indicated restoring default APN settings in progress -->
    <string name="restore_default_apn">Restoring default APN settings</string>
    <!-- APNs screen menu option to reset default APN settings -->
    <string name="menu_restore">Reset to default</string>
    <!-- APNs screen toast message to inform reset default APN settings is completed -->
    <string name="restore_default_apn_completed">Reset default APN settings completed</string>

    <!-- Master Clear -->
    <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading -->
    <string name="master_clear_title">Factory data reset</string>
    <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
    <string name="master_clear_summary">Erases all data on phone</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset -->
    <string name="master_clear_desc">"This will erase all data from your phone, including:\n<li>Your Google account</li>\n<li>System and application data and settings</li>\n<li>Downloaded applications</li>\nIt will not erase:\n<li>Current system software and bundled applications</li>\n<li>SD card files, such as music or photos</li>"</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="master_clear_button_text">Reset phone</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Reset phone button -->
    <string name="master_clear_final_desc">Erase all of your personal information and any downloaded applications? It is impossible to reverse this action!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Reset phone button -->
    <string name="master_clear_final_button_text">Erase everything</string>
    <!-- Message to draw an unlock pattern before clearing the device -->
    <string name="master_clear_gesture_prompt">Draw your unlock pattern</string>
    <!-- Explanation of drawing unlockp attern to reset phone -->
    <string name="master_clear_gesture_explanation">You must draw your unlock pattern to confirm a phone reset.</string>
    <!-- Master clear failed message -->
    <string name="master_clear_failed">No reset was performed because the System Clear service is not available.</string>

    <!-- Media Format -->
    <!-- SD card & phone storage settings screen, setting option name under Internal phone storage heading -->
    <string name="media_format_title">Format SD card.</string>
    <!-- SD card & phone storage settings screen, setting option summary text under Internal phone storage heading -->
    <string name="media_format_summary">Erases all data on the SD card</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Factory data reset -->
    <string name="media_format_desc">This action will erase the SD card in the phone. You will lose ALL data on the card!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Factory data reset -->
    <string name="media_format_button_text">Format SD card</string>
    <!-- SD card & phone storage settings screen, message on screen after user selects Format media button -->
    <string name="media_format_final_desc">Format SD card, erasing all your media? Action cannot be reversed!</string>
    <!-- SD card & phone storage settings screen, button on screen after user selects Format media button -->
    <string name="media_format_final_button_text">Erase everything</string>
    <!-- Message to draw an unlock pattern before clearing the device -->
    <string name="media_format_gesture_prompt">Draw your unlock pattern</string>
    <!-- Explanation of drawing unlock pattern to format card -->
    <string name="media_format_gesture_explanation">You must draw your unlock pattern to confirm an SD card format.</string>

    <!-- Main settings screen, Call settings title for item to go into the call settings -->
    <string name="call_settings_title">Call settings</string>
    <!-- Main settings screen, Call settings summary for item to go into call settings -->
    <string name="call_settings_summary">Set up voicemail, call forwarding, call waiting, caller ID</string>

    <!-- Tethering controls, item title to go into the tethering settings -->
    <string name="tether_settings_title_usb">Tethering</string>
    <string name="tether_settings_title_wifi">Portable hotspot</string>
    <string name="tether_settings_title_both">Tethering &amp; portable hotspot</string>
    <!-- Tethering controls, the item summary for the user to go into the tethering settings -->
    <string name="tether_settings_summary_usb">Share your phone\'s mobile data connection via USB</string>
    <string name="tether_settings_summary_wifi">Share your phone\'s mobile connection as a portable Wi-Fi hotspot</string>
    <string name="tether_settings_summary_both">Share your phone\'s mobile data connection via USB or as a portable Wi-Fi hotspot</string>

    <!-- USB Tethering options -->
    <string name="usb_title">USB</string>
    <string name="usb_tethering_button_text">USB tethering</string>
    <!-- USB available subtext - shown when USB is connected but not currently being tethered -->
    <string name="usb_tethering_available_subtext">USB connected, check to tether</string>
    <!-- USB tethered subtext - shown when USB is connected and being tethered -->
    <string name="usb_tethering_active_subtext">Tethered</string>
    <!-- USB storage subtext - shown when tethering is disabled because USB storage is active -->
    <string name="usb_tethering_storage_active_subtext">Can\'t tether when USB storage in use</string>
    <!-- USB unavailable subtext - shown when USB is not connected -->
    <string name="usb_tethering_unavailable_subtext">USB not connected</string>
    <!-- USB errored subtext - shown when USB is broken for some reason -->
    <string name="usb_tethering_errored_subtext">USB tethering error</string>

    <!-- Thethering help button - calls up a web view with general tethering info -->
    <string name="tethering_help_button_text">Help</string>

    <!-- Wireless controls, item title to go into the network settings -->
    <string name="network_settings_title">Mobile networks</string>
    <!-- Wireless controls, the item summary for the user to go into the network settings -->
    <string name="network_settings_summary">Set options for roaming, networks, APNs</string>

    <!-- Security & location settings screen, section header for settings relating to location -->
    <string name="location_title">My Location</string>
    <!-- Security & location settings screen, setting check box label if the user wants to use wireless network-based positioning (cell ID, wifi, etc.) -->
    <string name="location_network_based">Use wireless networks</string>
    <!-- Security & location settings screen, setting summary when Use wireless networks check box is clear -->
    <string name="location_networks_disabled">See location in applications (such as Maps) using wireless networks</string>
    <!-- Security & location settings screen, setting summary when Use wireless networks check box is selected -->
    <string name="location_neighborhood_level">Location determined by Wi-Fi and/or mobile networks</string>
    <!-- Security & location settings screen, setting check box label if the GPS receiver should be enabled -->
    <string name="location_gps">Use GPS satellites</string>
    <!-- Security & location settings screen, setting summary when Use GPS satellites check box is selected -->
    <string name="location_street_level">When locating, accurate to street level (uncheck to conserve battery)</string>
    <!-- Security & location settings screen, setting summary when Use GPS satellites check box is clear -->
    <string name="location_gps_disabled">Locate to street-level (requires more battery plus view of sky)</string>
    <!-- Security & location settings screen, setting check box label if Assisted GPS should be enabled -->
    <string name="assisted_gps">Use assisted GPS</string>
    <!-- Security & location settings screen, setting summary when Assisted GPS check box is selected -->
    <string name="assisted_gps_enabled">Use server to assist GPS (uncheck to reduce network usage)</string>
    <!-- Security & location settings screen, setting summary when Assisted GPS check box is clear -->
    <string name="assisted_gps_disabled">Use server to assist GPS (uncheck to improve GPS performance)</string>

    <!-- About --> <skip />
    <!-- Main settings screen, setting title for the user to go into the About phone screen -->
    <string name="about_settings">About phone</string>
    <!-- Main settings screen, setting summary for the user to go into the About phone screen-->
    <string name="about_settings_summary">View legal info, phone status, software version</string>
    <!-- About phone settings screen, setting option name to go to dialog that shows legal info -->
    <string name="legal_information">Legal information</string>
    <!-- About phone settings screen, setting option name to see a list of contributors -->
    <string name="contributors_title">Contributors</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see copyright-related info -->
    <string name="copyright_title">Copyright</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see licensing info -->
    <string name="license_title">License</string>
    <!-- Note: this may be replaced by a more-specific title of the activity that will get launched --> <skip />
    <!-- About phone settings screen, setting option name to see terms and conditions -->
    <string name="terms_title">Terms and conditions</string>
    <!-- About phone settings screen, running the System Tutorial -->
    <string name="system_tutorial_list_item_title">System tutorial</string>
    <!-- About phone settings screen, summary of what System Tutorial does -->
    <string name="system_tutorial_list_item_summary">Learn how to use your phone</string>

    <!-- Title for actual Settings license activity. --> <skip />
    <!-- About phone settings, Legal information setting option name and title of dialog box holding license info -->
    <string name="settings_license_activity_title">Open source licenses</string>
    <!-- About phone settings screen, Open source license dialog message when licenses cannot be loaded -->
    <string name="settings_license_activity_unavailable">There is a problem loading the licenses.</string>
    <!-- About phone settings screen, Open source license dialog title until license is fully loaded -->
    <string name="settings_license_activity_loading">Loading\u2026</string>

    <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
    <string name="settings_safetylegal_title">Safety information</string>
    <!-- About phone settings, Safety Legal information setting option name and title of dialog box holding safety legal info -->
    <string name="settings_safetylegal_activity_title">Safety information</string>
    <!-- About phone settings screen, Safety legal dialog message when data network is not connected -->
    <string name="settings_safetylegal_activity_unreachable">Your phone is not connected to a data service. To view this information now, go to %s from any computer connected to the Internet.</string>
    <!-- About phone settings screen, Safety Legal dialog title until the link is fully loaded -->
    <string name="settings_safetylegal_activity_loading">Loading\u2026</string>

    <!-- Lock Pattern settings -->
    <!-- Header on first screen of choose password/PIN flow -->
    <string name="lockpassword_choose_your_password_header">Choose your password</string>
    <!-- Header on first screen of choose password/PIN flow -->
    <string name="lockpassword_choose_your_pin_header">Choose your PIN</string>
    <!-- Header on password confirm screen -->
    <string name="lockpassword_confirm_your_password_header">Confirm your password</string>
    <!-- Header on password confirm screen -->
    <string name="lockpassword_confirm_your_pin_header">Confirm your PIN</string>
    <!-- Header on password confirm screen if second password doesn't match the first. -->
    <string name="lockpassword_confirm_passwords_dont_match">Passwords don\'t match</string>
    <!-- Header on pin confirm screen if second pin doesn't match the first. -->
    <string name="lockpassword_confirm_pins_dont_match">PINs don\'t match</string>
    <!-- Toast shown if setting password was successful -->
    <string name="lockpassword_password_set_toast">Password has been set</string>
    <!-- Toast shown if setting PIN was successful -->
    <string name="lockpassword_pin_set_toast">PIN has been set</string>
    <!-- Toast shown if setting pattern was successful -->
    <string name="lockpassword_pattern_set_toast">Pattern has been set</string>

    <!-- Lock Pattern settings -->
    <!-- Security & location settings screen, header -->
    <string name="lock_settings_title">Screen unlock</string>
    <!-- Security & location settings screen, setting option name -->
    <string name="lockpattern_change_lock_pattern_label">Change unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction when the user chooses "Change unlock pattern".  We first ask the user toe nter the current pattern, and this is the message seen -->
    <string name="lockpattern_change_lock_pin_label">Change unlock PIN</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction when the user chooses "Change unlock pattern".  We first ask the user toe nter the current pattern, and this is the message seen -->
    <string name="lockpattern_need_to_unlock">Confirm saved pattern</string>
    <!-- Do not translate. -->
    <string name="lockpattern_need_to_unlock_footer"></string>
    <!-- Security & location settings screen, change unlock pattern screen instruction if user draws incorrect pattern -->
    <string name="lockpattern_need_to_unlock_wrong">Sorry, try again:</string>
    <!-- Do not translate. -->
    <string name="lockpattern_need_to_unlock_wrong_footer"></string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen.  This si when they are supposed to draw a new unlock pattern (for example, if they are changing their unlock patterns)..-->
    <string name="lockpattern_recording_intro_header">Draw an unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen hint on bottom of screen.  We are telling them to press the menu button to see more options or help. -->
    <string name="lockpattern_recording_intro_footer">Press Menu for help.</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen while drawing pattern -->
    <string name="lockpattern_recording_inprogress">Release finger when done.</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen if user doesn't connect enough dots -->
    <string name="lockpattern_recording_incorrect_too_short">Connect at least <xliff:g id="number">%d</xliff:g> dots. Try again:</string>
    <!-- Security & location settings screen, change unlock pattern screen message on top of screen after drawing pattern -->
    <string name="lockpattern_pattern_entered_header">Pattern recorded!</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen to confirm pattern -->
    <string name="lockpattern_need_to_confirm">Draw pattern again to confirm:</string>
    <string name="lockpattern_pattern_confirmed_header">Your new unlock pattern:</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen.  After they draw a pattern and release their finger, we display the pattern so they remember.  When they are ready to draw it once again to confirm it, they press this button. -->
    <string name="lockpattern_confirm_button_text">Confirm</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen.  After they draw a pattern and release their finger, we display the pattern so they remember.  If they are nto satisfied with this pattern, they click this button to redraw the pattern. -->
    <string name="lockpattern_restart_button_text">Redraw</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen. If they are supposed to enter their current pattern before being able to draw another one, and they screw up, they hit this button to try again -->
    <string name="lockpattern_retry_button_text">Retry</string>
    <!-- Security & location settings screen, change unlock pattern screen button, on bottom of screen. Once they draw a new pattern and confirm it by drawing it again, they press this button to exit -->
    <string name="lockpattern_continue_button_text">Continue</string>
    <!-- Security & location settings screen, unlock screen activity title -->
    <string name="lockpattern_settings_title">Unlock pattern</string>
    <!-- Security & location settings screen, setting check box title if the unlock pattern MUST be drawn everytime they turn on the screen -->
    <string name="lockpattern_settings_enable_title">Require pattern</string>
    <!-- Security & location settings screen, setting summary for the checkbox "Require pattern" -->
    <string name="lockpattern_settings_enable_summary">Must draw pattern to unlock screen</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether a visible green line is drawn as the user moves his finger around while drawing the unlock pattern.  If checked, this line is drawn.  If unchecked, there is nothing drawn so the user does not reveal his pattern while he unlocks the phone.-->
    <string name="lockpattern_settings_enable_visible_pattern_title">Use visible pattern</string>
    <!-- Security & location settings screen, setting check box title. This setting controls whether tactile feedback will be produced when the user draws the pattern.-->
    <string name="lockpattern_settings_enable_tactile_feedback_title">Use tactile feedback</string>
    <!-- Security & location settings screen, setting option name when user has never set an unlock pattern -->
    <string name="lockpattern_settings_choose_lock_pattern">Set unlock pattern</string>
    <!-- Security & location settings screen, setting option name when user has previously set an unlock pattern and wants to change to a new pattern -->
    <string name="lockpattern_settings_change_lock_pattern">Change unlock pattern</string>
    <!-- Security & location settings screen, the help instructions (an animation) caption -->
    <string name="lockpattern_settings_help_how_to_record">How to draw an unlock pattern</string>
    <!-- Security & location settings screen, change unlock pattern screen instruction on top of screen after too many incorrect attempts -->
    <string name="lockpattern_too_many_failed_confirmation_attempts_header">Too many incorrect attempts!</string>
    <!-- Security & location settings screen, change unlock pattern screen countdown hint on bottom of screen after too many incorrect attempts -->
    <string name="lockpattern_too_many_failed_confirmation_attempts_footer">Try again in <xliff:g id="number">%d</xliff:g> seconds.</string>

    <!-- ChooseLockPatternTutorial --> <skip />
    <!-- ChooseLockPatternTutorial, button labels: This is to cancel the tutorial -->
    <string name="skip_button_label">Cancel</string>
    <!-- ChooseLockPatternTutorial, button labels: Continue to the next page of the tutorial -->
    <string name="next_button_label">Next</string>
    <!-- ChooseLockPatternTutorial, tutorial screen title -->
    <string name="lock_title">Securing your phone</string>
    <!-- ChooseLockPatternTutorial, tutorial screen text -->
    <string name="lock_intro_message"><font size="17">Protect your phone from unauthorized use by creating a personal screen unlock pattern.
        \n<font height="17">\n</font><b>1</b>\u00A0 On the next screen, watch while an example pattern is drawn.
        \n<font height="17">\n</font><b>2</b>\u00A0 When ready, draw your own personal unlock pattern. Experiment with different patterns but connect at least four dots.
        \n<font height="17">\n</font><b>3</b>\u00A0 Redraw your pattern to confirm.
        \n<font height="17">\n</font><b>Ready to start? Touch \u201CNext\u201D</b>.
        \n<font height="3">\n</font>To leave your phone unprotected, touch \u201CCancel\u201D.</font>
    </string>

    <!-- ChooseLockPatternExample --> <skip />
    <!-- ChooseLockPatternExample, screen title that shows an example pattern -->
    <string name="lock_example_title">Example pattern</string>
    <!-- ChooseLockPatternExample, screen hint text at bottom of screen. These are instructions and rules for drawing a good patttern -->
    <string name="lock_example_message">Connect at least four dots.\n
        \nTouch \u201CNext\u201D when you\u2019re ready to draw your own pattern.
    </string>

    <!-- Applications Settings --> <skip />
    <!-- Applications settings screen, setting option name for the user to go to the screen to manage installed applications  -->
    <string name="manageapplications_settings_title">Manage applications</string>
    <!-- Applications settings screen, setting option summary for the user to go to the screen to manage installed applications  -->
    <string name="manageapplications_settings_summary">Manage and remove installed applications</string>
    <!-- Applications settings title, on main settings screen. If clicked, the user is taken to a settings screen full of application settings-->
    <string name="applications_settings">Applications</string>
    <!-- Applications settings summary, on main settings screen. The summary for the "Applications" item on the main settings screen. Describes what settings are accessible from the "Applications" screen. -->
    <string name="applications_settings_summary">Manage applications, set up quick launch shortcuts</string>
    <!-- Applications settings screen heading. The header for the Application settings screen. -->
    <string name="applications_settings_header">Application settings</string>
    <!-- Applications settings screen, setting check box title. If checked, the system allows installation of applications that are downloaded from random places, such as web sites.  -->
    <string name="install_applications">Unknown sources</string>
    <!-- Applications settings screen, setting check box summary.  This is the summary for "Unknown sources" checkbox  -->
    <string name="install_unknown_applications">Allow installation of non-Market applications</string>
    <!-- Applications settings screen, message text of alert that appears if user selects the "Unknown sources" check box -->
    <string name="install_all_warning">Your phone and personal data are more vulnerable to attack by applications
 from unknown sources. You agree that you are solely responsible for any
 damage to your phone or loss of data that may result from using
 these applications.</string>
    <!-- Manage applications, individual application info screen title. For example, if they click on "Browser" in "Manage applications", the title of the next screen will be this -->
    <string name="application_info_label">Application info</string>
    <!-- Manage applications, individual application info screen, section heading for stuff relating to an app's storage settings. -->
    <string name="storage_label">Storage</string>
    <!-- Manage applications, individual application info screen,  heading for settings related to controlling whether this app is the default for some actions -->
    <string name="auto_launch_label">Launch by default</string>
    <!-- Manage applications, individual application info screen, heading for settings related to the app's permissions. for example, it may list all the permissions the app has. -->
    <string name="permissions_label">Permissions</string>
    <!-- Manage applications, Header name used for cache information -->
    <string name="cache_header_label">Cache</string>
    <!-- Manage applications, text label for button -->
    <string name="clear_cache_btn_text">Clear cache</string>
    <!-- Manage applications, label that appears next to the cache size -->
    <string name="cache_size_label">Cache</string>
    <!-- Manage applications, Header name used for other controls -->
    <string name="controls_label">Controls</string>
    <!-- Manage applications, text label for button to kill / force stop an application -->
    <string name="force_stop">Force stop</string>
    <!-- Manage applications, individual application info screen,label under Storage heading.  The total storage space taken up by this app. -->
    <string name="total_size_label">Total</string>
    <!-- Manage applications, individual application info screen, label under Storage heading. The amount of space taken up by the application itself (for example, the java compield files and things like that) -->
    <string name="application_size_label">Application</string>
    <!-- Manage applications, individual application info screen, label under Storage heading.  The amount of sapce taken up by the app's data (for example, downloaded emails or something like that) -->
    <string name="data_size_label">Data</string>
    <!-- Manage applications, individual application info screen, button label under Storage heading. Button to remove the application from the system. -->
    <string name="uninstall_text">Uninstall</string>
    <!-- Manage applications, individual application info screen, button label under Storage heading. Button to clear all data associated with tis app (for exampel, remove all cached emails for an Email app) -->
    <string name="clear_user_data_text">Clear data</string>
    <!-- Manage applications, restore updated system application to factory version -->
    <string name="app_factory_reset">Uninstall updates</string>
    <!-- Manage applications, individual application info screen, screen, message text under Launch by default heading. This is present if the app is set as a default for some actions. -->
    <string name="auto_launch_enable_text">You have selected to launch this application by default for some actions.</string>
    <!-- Manage applications, individual application screen, text under Launch by default heading if the app is NOT a default for actions -->
    <string name="auto_launch_disable_text">No defaults set.</string>
    <!-- Manage applications, individual application screen, button label under Launch by default heading.  This is used to clear any default actions that may be assigned to this app.  -->
    <string name="clear_activities">Clear defaults</string>
    <!-- Manage apps, individual app screen, substituted for the application's label when the app's label CAN NOT be determined.-->
    <string name="unknown">Unknown</string>
    <!-- Manage applications screen, menu item.  Sorts all of the apps in the list alphabetically. -->
    <string name="sort_order_alpha">Sort</string>
    <!-- Manage applications screen, menu item. Sorts all of the apps in the list based on their file size.  This is used to uninstall when space is getting low. -->
    <string name="sort_order_size">Sort by size</string>
    <!-- Manage applications screen, individual app screen, button label when the user wants to manage the space taken up by an app. -->
    <string name="manage_space_text">Manage space</string>
    <!-- Text for menu option in ManageApps screen to present various menu options -->
    <string name="filter">Filter</string>
    <!-- Title of dialog for presenting filter options -->
    <string name="filter_dlg_title">Select filter options</string>
    <!-- Text for filter option in ManageApps screen to display all installed
    applications -->
    <string name="filter_apps_all">All</string>
    <!-- Text for filter option in ManageApps screen to display third party
    applications only -->
    <string name="filter_apps_third_party">Downloaded</string>
    <!-- Text for filter option in ManageApps screen to display list of running
    packages only. -->
    <string name="filter_apps_running">Running</string>
    <!-- Text for filter option in ManageApps screen to display list of
    packages installed on sdcard. -->
    <string name="filter_apps_onsdcard">On SD card</string>
    <string name="loading">Loading\u2026</string>
    <!-- Manage app screen, shown when the activity is busy recomputing the size of each app -->
    <string name="recompute_size">Recomputing size\u2026</string>
    <!-- Manage applications, individual application screen, confirmation dialog title. Displays when user selects to "Clear data". -->
    <string name="clear_data_dlg_title">Delete</string>
    <!-- Manage applications, individual application screen, confirmation dialog message. Displays when user selects to "Clear data". It warns the user of the consequences of clearing the data for an app. -->
    <string name="clear_data_dlg_text">All of this application\'s data will be deleted permanently. This includes all files, settings, accounts, databases and so on.</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". Goes through with the clearing of the data. -->
    <string name="dlg_ok">OK</string>
    <!-- Manage applications, individual application screen, confirmation dialog button. Displays when user selects to "Clear data". -->
    <string name="dlg_cancel">Cancel</string>
    <!-- Manage applications, individual application dialog box title. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
    <string name="app_not_found_dlg_title">Application not found</string>
    <!-- Manage applications, individual application dialog box message. Shown when the user somehow got into a state where it wants to manage some app that isn't found. -->
    <string name="app_not_found_dlg_text"> The application was not
found in the list of installed applications.</string>
    <!-- Manage applications, individual application dialog box message. Shown when there was an error trying to clear the data. -->
    <string name="clear_data_failed">Unable to clear application data.</string>
    <!-- Manage applications, factory reset dialog title for system applications. -->
    <string name="app_factory_reset_dlg_title">Uninstall updates</string>
    <!-- Manage applications, factory reset option dialog text for system applications. -->
    <string name="app_factory_reset_dlg_text">Do you want to uninstall all updates to this Android system application?</string>
    <!-- Manage applications, title for dialog if clear data fails-->
    <string name="clear_failed_dlg_title">Clear data</string>
    <!-- Manage applications, text for dialog if clear data fails-->
    <string name="clear_failed_dlg_text">Failed clearing data for application</string>
    <!-- Manage applications, individual application info screen, text that appears under the "Permissions" heading. This describes the permissions that the application has. -->
    <string name="security_settings_desc">This application can access the following on your phone:</string>
    <string name="computing_size">Computing\u2026</string>
    <string name="invalid_size_value">Unable to compute package size</string>
    <!-- String displayed when list is empty -->
    <string name="empty_list_msg">You do not have any third-party applications installed.</string>
    <!-- Manage applications, version string displayed in app snippet -->
    <string name="version_text">version <xliff:g id="version_num">%1$s</xliff:g></string>
    <!-- Manage applications, text for Move button -->
    <string name="move_app">Move</string>
    <!-- Manage applications, text for Move button to move app to internal storage -->
    <string name="move_app_to_internal">Move to phone</string>
    <!-- Manage applications, text for Move button  to move app to sdcard -->
    <string name="move_app_to_sdcard">Move to SD card</string>
    <!-- Manage applications, title for dialog when killing persistent apps-->
    <!-- Manage applications, text for Move button when move is in progress -->
    <string name="moving">Moving</string>

    <!-- Manage applications, text for move error messages -->
    <string name="insufficient_storage">There is not enough storage left.</string>
    <string name="does_not_exist">The application does not exist.</string>
    <string name="app_forward_locked">The application is copy-protected.</string>
    <string name="invalid_location">The specified install location is not valid.</string>
    <string name="system_package">System updates cannot be installed on external media.</string>

    <string name="force_stop_dlg_title">Force stop</string>
    <!-- Manage applications, text for dialog when killing persistent apps-->
    <string name="force_stop_dlg_text">This application will be restarted right way. Are you sure you want to force stop?</string>
    <!-- Manage applications, text for dialog when moving an app -->
    <string name="move_app_failed_dlg_title">Move application</string>
    <!-- Manage applications, text for dialog moving an app -->
    <string name="move_app_failed_dlg_text">Failed to move application. <xliff:g id="reason">%1$s</xliff:g></string>
    <!-- Manage applications, application installation location title -->
    <string name="app_install_location_title">Preferred install location</string>
    <!-- Manage applications. application installation location summary -->
    <string name="app_install_location_summary">Change the preferred installation location for new applications.</string>

    <!-- Services settings screen, setting option name for the user to go to the screen to view running services -->
    <string name="runningservices_settings_title">Running services</string>
    <!-- Services settings screen, setting option summary for the user to go to the screen to view running services  -->
    <string name="runningservices_settings_summary">View and control currently running services</string>
    <!-- Label for a service item when it is restarting -->
    <string name="service_restarting">Restarting</string>
    <!-- Running services, body text when there are no services to show -->
    <string name="no_running_services">No running services</string>
    <!-- Running services, title of dialog to stop a service -->
    <string name="confirm_stop_service">Stop service?</string>
    <!-- Running services, message of dialog to stop a service -->
    <string name="confirm_stop_service_msg">The service will no longer run until
            started again.  This may have undesirable
            consequences on the application
            <xliff:g id="application">%1$s</xliff:g>.</string>
    <!-- Running services, button to stop a service -->
    <string name="confirm_stop_stop">Stop</string>
    <!-- Running services, button to cancel stopping of a service -->
    <string name="confirm_stop_cancel">Cancel</string>
    <!-- Running services, description for a service in the started state -->
    <string name="service_started_by_app">Started by application: touch to stop</string>
    <!-- Running services, description for a service in the started state -->
    <string name="service_client_name"><xliff:g id="client_name">%1$s</xliff:g>: touch to manage</string>
    <!-- Running services, summary of background processes -->
    <string name="service_background_processes">Avail: <xliff:g id="free">%2$s</xliff:g>+<xliff:g id="memory">%3$s</xliff:g> in <xliff:g id="count">%1$d</xliff:g></string>
    <!-- Running services, summary of foreground processes -->
    <string name="service_foreground_processes">Other: <xliff:g id="memory">%2$s</xliff:g> in <xliff:g id="count">%1$d</xliff:g></string>
    <!-- Text to label a process entry with the process name. -->
    <string name="service_process_name">Process: <xliff:g id="process">%1$s</xliff:g></string>

    <!-- Language Settings --> <skip />
    <!-- Title of setting on main settings screen.  This item will take the user to the screen to tweak settings realted to locale and text -->
    <string name="language_settings">Language &amp; keyboard</string>
    <!-- Title of Language and keyboard settings screen -->
    <string name="language_keyboard_settings_title">Language &amp; keyboard settings</string>
    <!-- Summary of setting on main settings screen.  This item will take the user to the screen to tweak settings realted to locale and text -->
    <string name="language_settings_summary">Set locale (language and region), text input and auto-correction options</string>
    <!-- On Text & language settings screen, heading. Inside the "Locale & text" screen, this is the header for settings that are for locale changes. -->
    <string name="language_category">Locale setting</string>
    <!-- On Text & language settings screen, heading. Inside the "Locale & text" screen, this is the header for settings that relate to text (autotext, autoreplace, autocapitalization). -->
    <string name="text_category">Text settings</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to take the user to a screen to select the locale. -->
    <string name="phone_language">Select language</string>
    <!-- On Text & language settings screen, setting option name. summary of the setting to take the user to a screen to select the locale. -->
    <string name="phone_language_summary">""</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to enable autoreplace of entered text. auto replace is a feature that will automatically correct mistyped words. -->
    <string name="auto_replace">Auto-replace</string>
    <!-- On Text & language settings screen, setting summary.  This is the summary for the "Auto-replace" setting. -->
    <string name="auto_replace_summary">Correct mistyped words</string>
    <!-- On Text & language settings screen, setting option name.  title of the setting to enable autocapitalization of entered text.  for example, after the user finishes a sentence, the next letter he types will automatically be capitalizated. -->
    <string name="auto_caps">Auto-cap</string>
    <!-- On Text & language settings screen, setting summary. Summary for the Auto-cap setting. -->
    <string name="auto_caps_summary">Capitalize first letter in sentences</string>
    <!-- On Text & language settings screen, setting option name. title of the setting to enable automatic punctuation of entered text.  for example, it will change an entered "youre" to "you're". -->
    <string name="auto_punctuate">Auto-punctuate</string>
    <!-- On Text & language settings screen, category for physical keyboard text entry options. -->
    <string name="hardkeyboard_category">Physical keyboard settings</string>
    <!-- On Text & language settings screen, setting summary for the Auto-punctuate setting. -->
    <string name="auto_punctuate_summary">Press Space key twice to insert \u0022.\u0022</string>
    <!-- On Security & location settings screen, setting check box name. Title of the checkbox to set whether password edit fields will show the most recent character typed and then hide it, or just hide it right away.  By hide, I mean mask it out. -->
    <string name="show_password">Visible passwords</string>
    <!-- On Security & location settings screen, setting check box summary. Summary for the visible passwords setting. -->
    <string name="show_password_summary">Show password as you type</string>
    <!-- Warning message about security implications of enabling an input method, displayed as a dialog
         message when the user selects to enable an IME. -->
    <string name="ime_security_warning">This input method may be able to collect
    all the text you type, including personal data like passwords and credit
    card numbers.  It comes from the application
    <xliff:g id="ime_application_name">%1$s</xliff:g>.
    Use this input method?</string>

    <!-- User dictionary settings --><skip />
    <!-- User dictionary settings, The titlebar text of the User dictionary settings screen. -->
    <string name="user_dict_settings_titlebar">User dictionary</string>
    <!-- User dictionary settings, The title of the list item to go into the User dictionary settings screen. -->
    <string name="user_dict_settings_title">User dictionary</string>
    <!-- User dictionary settings.  The summary of the listem item to go into the User dictionary settings screen. -->
    <string name="user_dict_settings_summary">""</string>
    <!-- User dictionary settings. The title of the menu item to add a new word to the user dictionary. -->
    <string name="user_dict_settings_add_menu_title">Add</string>
    <!-- User dictionary settings. The title of the dialog to add a new word to the user dictionary. -->
    <string name="user_dict_settings_add_dialog_title">Add to dictionary</string>
    <!-- User dictionary settings. The title of the dialog to edit an existing word in the user dictionary. -->
    <string name="user_dict_settings_edit_dialog_title">Edit word</string>
    <!-- User dictionary settings. The title of the context menu item to edit the current word -->
    <string name="user_dict_settings_context_menu_edit_title">Edit</string>
    <!-- User dictionary settings. The title of the context menu item to delete the current word -->
    <string name="user_dict_settings_context_menu_delete_title">Delete</string>
    <!-- User dictionary settings. The text to show when there are no user-defined words in the dictionary -->
    <string name="user_dict_settings_empty_text">You do not have any words in the user dictionary. You can add a word through the menu.</string>

    <!-- This is for diagnostics screen. The title of a screen with various items realted to launching screens that will giev the user info. For example, it contains "Phone information" and "Battery information" -->
    <string name="testing">Testing</string>
    <!-- In the Testing screen.  The item title of the activity that shows a bunch of phone-related information.  -->
    <string name="testing_phone_info">Phone information</string>
    <!-- In the Testing screen. The item title of the activity that shows a bunch of battery-related information.  -->
    <string name="testing_battery_info">Battery information</string>
    <!-- In the Testing screen. The item title of the activity that shows a bunch of historical battery-related information.  -->
    <string name="testing_battery_history">Battery history</string>
    <!-- Do not translate. In the Testing screen. The item title of the activity that shows a bunch of SIM-related operations.  -->
    <string name="testing_sim_toolkit">SIM toolkit</string>

    <!-- The title of the item to go into the Quick launch settings. -->
    <string name="quick_launch_title">Quick launch</string>
    <!-- The summary of the item to go into the Quick launch settings. This is a description of what Quick launch offers. -->
    <string name="quick_launch_summary">Set keyboard shortcuts to launch applications</string>
    <!-- On the Quick launch settings screen, title of the item for shortcut letters that are not assigned to an application yet. Quick launch is assigning a global shortcut to launch a specific app. -->
    <string name="quick_launch_assign_application">Assign application</string>
    <!-- On the Quick launch settings screen, summary text for the item of letters that are not assigned. See the quick launch "Assign application" for a description of quick launch -->
    <string name="quick_launch_no_shortcut">No shortcut</string>
    <!-- On the Quick launch settings screen, summary text under the item for each assigned letter.  -->
    <string name="quick_launch_shortcut">Search + <xliff:g id="shortcut_letter">%1$s</xliff:g></string>
    <!-- On the Quick launch settings screen, title of "Clear shortcut" confirmation dialog. This is reached by longpressing an item for a shortcut letter.  This allows the user to clear the assigned application for that shortcut letter. -->
    <string name="quick_launch_clear_dialog_title">Clear</string>
    <!-- On the Quick launch settings screen, message in the "Clear shortcut" confirmation dialog.  See the title for this dialog for more info. -->
    <string name="quick_launch_clear_dialog_message">Your shortcut for <xliff:g id="shortcut_letter">%1$s</xliff:g> (<xliff:g id="application_name">%2$s</xliff:g>) will be cleared.</string>
    <!-- Clear dialog for quick launch setting box button labels: -->
    <string name="quick_launch_clear_ok_button">OK</string>
    <!-- Clear dialog for quick launch setting box button labels: -->
    <string name="quick_launch_clear_cancel_button">Cancel</string>
    <!-- Quick launch screen, when assigning an app to a shortcut, this menu item to show a list of all applications.  -->
    <string name="quick_launch_display_mode_applications">Applications</string>
    <!-- Quick launch screen, when assigning an app to a shortcut, this menu item to show a list of all shortcutable applications -->
    <string name="quick_launch_display_mode_shortcuts">Shortcuts</string>

    <!-- Input methods Settings -->
    <string name="input_methods_settings_title">Text input</string>
    <string name="input_methods_settings_summary">Manage text input options</string>
    <!-- Input Methods Settings localized format string for generating the appropriate "Foo settings" menu label for the Input Method named "Foo" -->
    <string name="input_methods_settings_label_format"><xliff:g id="ime_name">%1$s</xliff:g> settings</string>
    <!-- Summary for on-screen keyboard settings -->
    <string name="onscreen_keyboard_settings_summary">Onscreen keyboard settings</string>
    <!-- Title for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_title">Device keyboard</string>
    <!-- Summary for built-in keyboard settings -->
    <string name="builtin_keyboard_settings_summary">Built-in keyboard settings</string>

    <!-- Development Settings.  the title for the item to take the user to Development settings.  Development settings are settings meant for application developers.  -->
    <string name="development_settings_title">Development</string>
    <!-- Development Settings summary.  The summary of the item to take the user to Development settings.  Development settings are settings meant for application developers. -->
    <string name="development_settings_summary">Set options for application development</string>
    <!-- Setting checkbox title for Whether to enable USB debugging support on the phone. -->
    <string name="enable_adb">USB debugging</string>
    <!-- Setting checkbox summary for Whether to enable USB debugging support on the phone -->
    <string name="enable_adb_summary">Debug mode when USB is connected</string>
    <!-- Setting Checkbox title whether to keep the screen on when plugged in to a power source -->
    <string name="keep_screen_on">Stay awake</string>
    <!-- setting Checkbox summary whether to keep the screen on when plugged in  -->
    <string name="keep_screen_on_summary">Screen will never sleep while charging</string>
    <!-- Setting Checkbox title whether to allow mock locations -->
    <string name="allow_mock_location">Allow mock locations</string>
    <!-- setting Checkbox summary whether to allow mock locations  -->
    <string name="allow_mock_location_summary">Allow mock locations</string>
    <!-- Title of warning dialog about the implications of enabling USB debugging -->
    <string name="adb_warning_title">Allow USB debugging?</string>
    <!-- Warning text to user about the implications of enabling USB debugging -->
    <string name="adb_warning_message">USB debugging is intended for development purposes only. It can be used to copy data between your computer and your device, install applications on your device without notification, and read log data.</string>

    <!-- Title for the screen that lets the user choose a gadget to add to the home screen
         (or other screens that can host gadgets).  Note to translators: we're still determining
         the final name for Gadgets/Widgets, so please translate both for now. -->
    <string name="gadget_picker_title">Choose gadget</string>

    <!-- Title for the screen that lets the user choose a widget to add to the home screen
         (or other screens that can host widgets).  Note to translators: we're still determining
         the final name for Gadgets/Widgets, so please translate both for now. -->
    <string name="widget_picker_title">Choose widget</string>

    <!-- Used to display "Details for UID 1234" in BatteryHistory -->
    <string name="battery_history_details_for">Details for UID <xliff:g id="number" example="1234">%d</xliff:g></string>

    <!-- Used to name a set of apps that share a user id in BatteryHistory -->
    <string name="battery_history_uid">UID <xliff:g id="user_id">%1$d</xliff:g></string>

    <!-- Used as a title for the network usage details screen in BatteryHistory -->
    <string name="battery_history_network_usage">Network usage details for <xliff:g id="app_name">%1$s</xliff:g>:</string>

    <!-- Used to show the number of bytes received by an app over the network in BatteryHistory -->
    <string name="battery_history_bytes_received">Bytes received: <xliff:g id="bytes">%1$d</xliff:g></string>

    <!-- Used to show the number of bytes sent by an app over the network in BatteryHistory -->
    <string name="battery_history_bytes_sent">Bytes sent: <xliff:g id="bytes">%1$d</xliff:g></string>

    <!-- Used to show the number of bytes sent and received by an app over the network in BatteryHistory -->
    <string name="battery_history_bytes_total">Total bytes: <xliff:g id="bytes">%1$d</xliff:g></string>

    <!-- Used as a title for the cpu usage details screen in BatteryHistory -->
    <string name="battery_history_cpu_usage">CPU usage details for <xliff:g id="app_name">%1$s</xliff:g>:</string>

    <!-- Used to show the time spent in user code for a given app in BatteryHistory -->
    <string name="battery_history_user_time">User time: </string>

    <!-- Used to show the time spent in system code for a given app in BatteryHistory -->
    <string name="battery_history_system_time">System time: </string>

    <!-- Used to show the time spent in user or system code for a given app in BatteryHistory -->
    <string name="battery_history_total_time">Total time: </string>

    <!-- Used to show the number of times an app has been started in BatteryHistory -->
    <string name="battery_history_starts">Starts: <xliff:g id="starts">%1$d</xliff:g></string>

    <!-- Used to show an amount of time in the form "d days, h hours, m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_days"><xliff:g id="days">%1$d</xliff:g>d <xliff:g id="hours">%2$d</xliff:g>h <xliff:g id="minutes">%3$d</xliff:g>m <xliff:g id="seconds">%4$d</xliff:g>s</string>

    <!-- Used to show an amount of time in the form "h hours, m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_hours"><xliff:g id="hours">%1$d</xliff:g>h <xliff:g id="minutes">%2$d</xliff:g>m <xliff:g id="seconds">%3$d</xliff:g>s</string>

    <!-- Used to show an amount of time in the form "m minutes, s seconds" in BatteryHistory -->
    <string name="battery_history_minutes"><xliff:g id="minutes">%1$d</xliff:g>m <xliff:g id="seconds">%2$d</xliff:g>s</string>

    <!-- Used to show an amount of time in the form "s seconds" in BatteryHistory -->
    <string name="battery_history_seconds"><xliff:g id="seconds">%1$d</xliff:g>s</string>

    <!-- Used to head a list of packages that share a given user id BatteryHistory -->
    <string name="battery_history_packages_sharing_this_uid">Packages sharing this UID:</string>

    <!-- Used when no battery data available in BatteryHistory -->
    <string name="battery_history_no_data">No battery usage data available</string>

    <!-- Used for Sensor detail screen in BatteryHistory -->
    <string name="battery_history_sensor">Sensor:</string>

    <!-- Used for Wakelock detail screen in BatteryHistory -->
    <string name="battery_history_wakelock">Partial Wakelock:</string>

    <!-- Used for Sensor detail screen in BatteryHistory -->
    <string name="battery_history_used_by_packages">Sensor used by packages:</string>

    <!-- Used for Sensor detail screen in BatteryHistory -->
    <string name="battery_history_sensor_usage">Used <xliff:g id="count">%1$d</xliff:g> times by <xliff:g id="package">%2$s</xliff:g></string>

    <!-- Used for Sensor detail screen in BatteryHistory -->
    <string name="battery_history_sensor_usage_multi">Used <xliff:g id="count">%1$d</xliff:g> times by one of:</string>

    <!-- Used for label of awake bar in BatteryHistory -->
    <string name="battery_history_awake_label">Running</string>

    <!-- Used for label of screen on bar in BatteryHistory -->
    <string name="battery_history_screen_on_label">Screen on</string>

    <!-- Used for label of phone on bar in BatteryHistory -->
    <string name="battery_history_phone_on_label">Phone on</string>

    <!-- Used for awake time message in BatteryHistory -->
    <string name="battery_history_awake">Time spent without sleeping:</string>

    <!-- Used for Screen on time message in BatteryHistory -->
    <string name="battery_history_screen_on">Time spent with screen on:</string>

    <!-- Used for Phone on time message in BatteryHistory -->
    <string name="battery_history_phone_on">Time spent with phone on:</string>

    <!-- Used for Screen on time message in BatteryHistory -->
    <string name="battery_history_screen_on_battery">On battery:</string>

    <!-- XXX remove? Used for Screen on time message in BatteryHistory -->
    <string name="battery_history_screen_on_plugged">Plugged in:</string>

    <!-- XXX remove? Strings used for displaying usage statistics -->
    <string name="usage_stats_label">Usage statistics</string>

    <!-- In the Testing screen. The item title of the activity that shows usage statistics.  -->
    <string name="testing_usage_stats">Usage statistics</string>
    <!-- label for text to indicate sort options -->
    <string name="display_order_text">Sort by:</string>
    <!-- label for application name -->
    <string name="app_name_label">Application</string>
    <!-- label for launch count -->
    <string name="launch_count_label">Count</string>
    <!-- label for usage time -->
    <string name="usage_time_label">Usage time</string>

    <!-- Accessibility settings -->
    <skip/>

    <!-- Settings title in main settings screen for accessibility settings -->
    <string name="accessibility_settings">Accessibility</string>
    <!-- Settings title for accessibility settings screen -->
    <string name="accessibility_settings_title">Accessibility settings</string>
    <!-- Settings summary for accessibility settings -->
    <string name="accessibility_settings_summary">Manage accessibility options</string>
    <!-- Setting Checkbox title for enabling accessibility -->
    <string name="toggle_accessibility_title">Accessibility</string>
    <!-- Setting accessibility services category -->
    <string name="accessibility_services_category">Accessibility services</string>
    <!-- Message for announcing the lack of installed accessibility services. -->
    <string name="no_accessibility_services_summary">No installed accessibility services.</string>
    <!-- Warning message about security implications of enabling an accessibility service,
         displayed as a dialog message when the user selects to enable an accessibility service. -->
    <string name="accessibility_service_security_warning">This accessibility service may be able to collect
        all the text you type, including personal data credit card numbers except passwords.
        It may also log your user interface interactions. It comes from the application
        <xliff:g id="accessibility_service_name">%1$s</xliff:g>. Use this accessibility service?</string>
    <!-- Warning about disabling accessibility displayed as a dialog message when the user
         selects to disable accessibility. This avoids accidental disabling. -->
    <string name="accessibility_service_disable_warning">Disable accessibility?</string>
    <!-- Title for the prompt that lets users know that they have no accessibility related apps
         installed and that they can install TalkBack from Market. -->
    <string name="accessibility_service_no_apps_title">No accessibility related applications found
        </string>
    <!-- Message for the prompt that lets users know that they have no accessibility related apps
         installed and that they can install TalkBack from Market. -->
    <string name="accessibility_service_no_apps_message">You do not have any accessibility related
        applications installed.\n\nYou can download a screen reader for your device from Android
        Market.\n\nClick "OK" to install the screen reader.</string>

    <!-- Accessibility settings: Power button category -->
    <string name="accessibility_power_button_category">Power button</string>
    <!-- Accessibility settings: checkbox title for power button behavior -->
    <string name="accessibility_power_button_ends_call">Power button ends call</string>
    <!-- Accessibility settings: power button behavior summary text -->
    <string name="accessibility_power_button_ends_call_summary">During a call, pressing Power ends call instead of turning off screen</string>

    <!-- App Fuel Gauge strings -->
    <skip/>

    <!-- Activity title for App Fuel Gauge summary -->
    <string name="power_usage_summary_title">Battery use</string>
    <!-- Activity title summary for App Fuel Gauge summary -->
    <string name="power_usage_summary">What has been using the battery</string>
    <!-- Battery usage since unplugged -->
    <string name="battery_since_unplugged">Battery use since unplugged</string>
    <!-- Battery usage since user reset the stats -->
    <string name="battery_since_reset">Battery use since reset</string>
    <!-- Battery usage duration -->
    <string name="battery_stats_duration"><xliff:g id="time">%1$s</xliff:g> since unplugged</string>
    <!-- Battery usage during last unplugged period -->
    <string name="battery_stats_last_duration">@string/menu_stats_last_unplugged</string>
    <!-- CPU awake time title -->
    <string name="awake">Device awake time</string>
    <!-- Wifi on time -->
    <string name="wifi_on_time">WiFi on time</string>
    <!-- Bluetooth on time -->
    <string name="bluetooth_on_time">WiFi on time</string>
    <!-- Application name and battery usage percentage -->
    <string name="usage_name_percent"><xliff:g id="name">%1$s</xliff:g>" - "
            <xliff:g id="number" example="30">%2$s</xliff:g><xliff:g id="percent" example="%">%%</xliff:g></string>

    <!-- Activity title for battery usage details for an app. or power consumer -->
    <string name="details_title">Battery use details</string>
    <!-- Subtitle for application/subsystem details -->
    <string name="details_subtitle">Use details</string>
    <!-- Subtitle for possible options -->
    <string name="controls_subtitle">Adjust power use</string>
    <!-- Subtitle for list of packages -->
    <string name="packages_subtitle">Included packages</string>

    <!-- Label for power consumed by the screen -->
    <string name="power_screen">Display</string>
    <!-- Label for power consumed by WiFi -->
    <string name="power_wifi">Wi-Fi</string>
    <!-- Label for power consumed by Bluetooth -->
    <string name="power_bluetooth">Bluetooth</string>
    <!-- Label for power consumed by Cell idle -->
    <string name="power_cell">Cell standby</string>
    <!-- Label for power consumed by Calling -->
    <string name="power_phone">Voice calls</string>
    <!-- Label for power consumed when Idle -->
    <string name="power_idle">Phone idle</string>

    <!-- Label for CPU usage time -->
    <string name="usage_type_cpu">CPU total</string>
    <!-- Label for CPU usage in foreground -->
    <string name="usage_type_cpu_foreground">CPU foreground</string>
    <!-- Label for GPU usage time -->
    <string name="usage_type_gps">GPS</string>
    <!-- Label for Phone usage time -->
    <string name="usage_type_phone">Phone</string>
    <!-- Label for Data sent -->
    <string name="usage_type_data_send">Data sent</string>
    <!-- Label for Data received -->
    <string name="usage_type_data_recv">Data received</string>
    <!-- Label for Audio usage time -->
    <string name="usage_type_audio">Audio</string>
    <!-- Label for Video usage time -->
    <string name="usage_type_video">Video</string>
    <!-- Label for time that a feature has been on -->
    <string name="usage_type_on_time">Time on</string>
    <!-- Label for time that there was no cell coverage -->
    <string name="usage_type_no_coverage">Time without a signal</string>
    <!-- Label for force stop action -->
    <string name="battery_action_stop">Force stop</string>
    <!-- Label for app details action -->
    <string name="battery_action_app_details">Application info</string>
    <!-- Label for app settings action -->
    <string name="battery_action_app_settings">Application settings</string>
    <!-- Label for display settings -->
    <string name="battery_action_display">Display settings</string>
    <!-- Label for wifi settings -->
    <string name="battery_action_wifi">WiFi settings</string>
    <!-- Label for bluetooth settings -->
    <string name="battery_action_bluetooth">Bluetooth settings</string>

    <!-- Description for voice call detail -->
    <string name="battery_desc_voice">Battery used by voice calls</string>

    <!-- Description for standby detail -->
    <string name="battery_desc_standby">Battery used when phone is idle</string>

    <!-- Description for cell radio detail -->
    <string name="battery_desc_radio">Battery used by cell radio</string>
    <!-- Suggestion to switch to airplane mode to save power -->
    <string name="battery_sugg_radio">Switch to airplane mode to save power in areas with no cell coverage</string>

    <!-- Description for power consumed by display -->
    <string name="battery_desc_display">Battery used by the display and backlight</string>
    <!-- Suggestion for reducing display power -->
    <string name="battery_sugg_display">Reduce the screen brightness and/or screen timeout</string>

    <!-- Description for wifi connectivity -->
    <string name="battery_desc_wifi">Battery used by Wi-Fi</string>
    <!-- Suggestion for wifi connectivity power drain -->
    <string name="battery_sugg_wifi">Turn off Wi-Fi when not using it or where it is not available</string>

    <!-- Description for bluetooth power consumption detail -->
    <string name="battery_desc_bluetooth">Battery used by bluetooth</string>
    <!-- Suggestion for bluetooth -->
    <string name="battery_sugg_bluetooth_basic">Turn off bluetooth when you aren\'t using it</string>
    <!-- Suggestion for bluetooth headset -->
    <string name="battery_sugg_bluetooth_headset">Try connecting to a different bluetooth device</string>

    <!-- Description for power consumed by applications -->
    <string name="battery_desc_apps">Battery used by applications when running</string>
    <!-- Suggestion for exploring application info to stop or uninstall -->
    <string name="battery_sugg_apps_info">Stop or uninstall the application</string>
    <!-- Suggestion for getting apps to consume less power due to GPS-->
    <string name="battery_sugg_apps_gps">"Turn off GPS when you're not using it"</string>
    <!-- Suggestion for getting apps to consume less power -->
    <string name="battery_sugg_apps_settings">The application may offer settings to reduce battery use</string>

    <!-- Menu label for viewing battery usage since unplugged -->
    <string name="menu_stats_unplugged"><xliff:g id="unplugged">%1$s</xliff:g> since unplugged</string>
    <!-- Menu label for viewing battery usage since unplugged -->
    <string name="menu_stats_last_unplugged">While last unplugged for <xliff:g id="unplugged">%1$s</xliff:g></string>
    <!-- Menu label for viewing battery usage total -->
    <string name="menu_stats_total">Usage totals</string>
    <!-- Menu label for refreshing with latest usage numbers -->
    <string name="menu_stats_refresh">Refresh</string>

    <!-- Label for kernel threads -->
    <string name="process_kernel_label">Android OS</string>
    <!-- Label for mediaserver process -->
    <string name="process_mediaserver_label">Mediaserver</string>

    <!-- Voice input/output settings --><skip />
    <!-- Title of setting on main settings screen. This item will take the user to the screen to tweak settings related to speech functionality -->
    <string name="voice_input_output_settings">Voice input &amp; output</string>
    <!-- Main voice input/output settings screen title -->
    <string name="voice_input_output_settings_title">Voice input &amp; output settings</string>
    <!-- Title of voice search settings list item within voice input/output settings -->
    <string name="voice_search_settings_title">Voice search</string>
    <!-- Title of keyboard settings list item within voice input/output settings -->
    <string name="keyboard_settings_title">Android keyboard</string>
    <!-- Title for the 'voice input' category of voice input/output settings -->
    <string name="voice_input_category">Voice input</string>
    <!-- Title for the 'voice output' category of voice input/output settings -->
    <string name="voice_output_category">Voice output</string>
    <!-- Title for the voice recognizer setting in voice input/output settings -->
    <string name="recognizer_title">Voice recognizer</string>
    <!-- Title for the link to settings for the chosen voice recognizer in voice input/output settings -->
    <string name="recognizer_settings_title">Voice recognizer settings</string>
    <!-- Summary for the link to settings for the chosen voice recognizer in voice input/output settings.
         Would say something like, e.g., "Settings for 'Google'". -->
    <string name="recognizer_settings_summary">Settings for \'<xliff:g id="recognizer_name">%s</xliff:g>\'</string>

    <!-- Text-To-Speech (TTS) settings --><skip />
    <!-- Title of setting on main settings screen.  This item will take the user to the screen to tweak settings related to the text-to-speech functionality -->
    <string name="tts_settings">Text-to-speech settings</string>
    <!-- Main TTS Settings screen title -->
    <string name="tts_settings_title">Text-to-speech settings</string>
    <!-- On main TTS Settings screen, title for toggle used to force use of default TTS settings -->
    <string name="use_default_tts_settings_title">Always use my settings</string>
    <!-- On main TTS Settings screen, summary for toggle used to force use of default TTS settings -->
    <string name="use_default_tts_settings_summary">Default settings below override application settings</string>
    <!-- On main TTS Settings screen, section header for default TTS settings -->
    <string name="tts_default_settings_section">Default settings</string>
    <!-- On main TTS Settings screen, in default settings section, setting default synthesis engine for synthesized voice -->
    <string name="tts_default_synth_title">Default Engine</string>
    <!-- On main TTS Settings screen, summary for default synthesis engine for synthesized voice -->
    <string name="tts_default_synth_summary">Sets the speech synthesis engine to be used for spoken text</string>
    <!-- On main TTS Settings screen, in default settings section, setting default speech rate for synthesized voice -->
    <string name="tts_default_rate_title">Speech rate</string>
    <!-- On main TTS Settings screen, summary for default speech rate for synthesized voice -->
    <string name="tts_default_rate_summary">Speed at which the text is spoken</string>
    <!-- On main TTS Settings screen, in default settings section, setting default pitch for synthesized voice -->
    <string name="tts_default_pitch_title">Pitch</string>
    <!-- On main TTS Settings screen, summary for default pitch for synthesized voice -->
    <string name="tts_default_pitch_summary">Affects the tone of the spoken text</string>
    <!-- On main TTS Settings screen, in default settings section, setting default language for synthesized voice -->
    <string name="tts_default_lang_title">Language</string>
    <!-- On main TTS Settings screen, summary for default language for synthesized voice -->
    <string name="tts_default_lang_summary">Sets the language-specific voice for the spoken text</string>
    <!-- On main TTS Settings screen, triggers playback of an example of speech synthesis -->
    <string name="tts_play_example_title">Listen to an example</string>
    <!-- On main TTS Settings screen, summary for triggering playback of an example of speech synthesis -->
    <string name="tts_play_example_summary">Play a short demonstration of speech synthesis</string>
    <!-- On main TTS Settings screen, click to install required speech synthesis data -->
    <string name="tts_install_data_title">Install voice data</string>
    <!-- On main TTS Settings screen, summary for click to install required speech synthesis data -->
    <string name="tts_install_data_summary">Install the voice data required for speech synthesis</string>
    <!-- On main TTS Settings screen, summary for when required speech synthesis data alrady installed on SD card -->
    <string name="tts_data_installed_summary">Voices required for speech synthesis already properly installed</string>
    <!-- Text spoken by the TTS engine for demonstration purposes -->
    <string name="tts_demo">This is an example of speech synthesis.</string>
    <!-- Text spoken by the TTS engine when TTS settings (other than language) have been changed -->
    <string name="tts_settings_changed_demo">Your settings have changed. This is an example of how they sound.</string>
    <!-- Error screen when a selected TTS engine can't run because it's missing components -->
    <string name="tts_engine_error">The engine you selected is unable to run</string>
    <!-- Button text for error screen when a selected TTS engine can't run because it's missing components -->
    <string name="tts_engine_error_config">Configure</string>
    <!-- Button text for error screen when a selected TTS engine can't run because it's missing components -->
    <string name="tts_engine_error_reselect">Select another engine</string>
    <!-- Warning message about security implications of enabling a TTS engine, displayed as a dialog
         message when the user selects to enable an engine. -->
    <string name="tts_engine_security_warning">This speech synthesis engine may be able to collect
    all the text that will be spoken, including personal data like passwords and credit
    card numbers.  It comes from the <xliff:g id="tts_plugin_engine_name">%s</xliff:g> engine.
    Enable the use of this speech synthesis engine?</string>
    <!-- On main TTS Settings screen, text for divider under which all TTS engines are listed -->
    <string name="tts_engines_section">Engines</string>
    <!-- On main TTS Settings screen, text preceded by the TTS engine name, clicking this button will launch the engine settings -->
    <string name="tts_engine_name_settings"><xliff:g id="tts_plugin_engine_name">%s</xliff:g> settings</string>
    <!-- On main TTS Settings screen, text preceded by the TTS engine name to indicate the engine can be used by the user -->
    <string name="tts_engine_name_is_enabled_summary"><xliff:g id="tts_plugin_engine_name">%s</xliff:g> is enabled</string>
    <!-- On main TTS Settings screen, text preceded by the TTS engine name to indicate the engine cannot be used by the user -->
    <string name="tts_engine_name_is_disabled_summary"><xliff:g id="tts_plugin_engine_name">%s</xliff:g> is disabled</string>
    <!-- On Pico TTS Settings screen, text to mark the section for the various languages and voices that are available -->
    <string name="pico_languages_and_voices">Languages and voices</string>
    <!-- On Pico TTS Settings screen, text to mark a voice as installed -->
    <string name="pico_installed">Installed</string>
    <!-- On Pico TTS Settings screen, text to mark a voice as not installed -->
    <string name="pico_not_installed">Not installed</string>
    <!-- On Pico TTS Settings screen, summary text to indicate that a voice is female -->
    <string name="pico_voice_summary_female">Female</string>
    <!-- On Pico TTS Settings screen, summary text to indicate that a voice is male -->
    <string name="pico_voice_summary_male">Male</string>

    <!-- Power Control Widget -->
    <string name="gadget_title">Power Control</string>
    <string name="gadget_toggle_wifi">Updating Wi-Fi setting</string>
    <string name="gadget_toggle_bluetooth">Updating Bluetooth setting</string>

    <string name="vpn_settings_activity_title">VPN settings</string>

    <!-- Title of VPN connect dialog -->
    <string name="vpn_connect_to">Connect to <xliff:g id="name" example="Work Network">%s</xliff:g></string>
    <!-- In VPN connect dialog, for inputing username and password -->
    <string name="vpn_username_colon">Username:</string>
    <string name="vpn_password_colon">Password:</string>
    <string name="vpn_a_username">a username</string>
    <string name="vpn_a_password">a password</string>

    <!-- In VPN connect dialog where user may check to remember the username entered -->
    <string name="vpn_save_username">Remember username</string>

    <string name="vpn_connect_button">Connect</string>
    <string name="vpn_yes_button">Yes</string>
    <string name="vpn_no_button">No</string>
    <string name="vpn_back_button">Back</string>
    <string name="vpn_mistake_button">No</string>

    <string name="vpn_menu_done">Save</string>
    <string name="vpn_menu_cancel">Cancel</string>
    <string name="vpn_menu_revert">Revert</string>
    <string name="vpn_menu_connect">Connect to network</string>
    <string name="vpn_menu_disconnect">Disconnect from network</string>
    <string name="vpn_menu_edit">Edit network</string>
    <string name="vpn_menu_delete">Delete network</string>

    <!-- VPN error dialog messages -->
    <string name="vpn_error_miss_entering">You must enter <xliff:g id="code">%s</xliff:g>.</string>
    <string name="vpn_error_miss_selecting">You must select <xliff:g id="option">%s</xliff:g>.</string>
    <string name="vpn_error_duplicate_name">The VPN name \'<xliff:g id="name" example="Home Network">%s</xliff:g>\' already exists. Find another name.</string>
    <string name="vpn_confirm_profile_deletion">Are you sure you want to delete this VPN?</string>
    <string name="vpn_confirm_add_profile_cancellation">Are you sure you don\'t want to create this profile?</string>
    <string name="vpn_confirm_edit_profile_cancellation">Are you sure you want to discard the changes made to this profile?</string>
    <string name="vpn_confirm_reconnect">Unable to connect to the network. Do you want to try again?</string>
    <string name="vpn_reconnect_from_lost">Connection lost. Do you want to connect again?</string>
    <string name="vpn_unknown_server_dialog_msg">Server name cannot be resolved. Do you want to check your server name setting?</string>
    <string name="vpn_challenge_error_dialog_msg">Challenge error. Do you want to check your secret setting?</string>
    <string name="vpn_secret_not_set_dialog_msg">One or more secrets are missing in this VPN configuration. Do you want to check your secret setting?</string>
    <string name="vpn_auth_error_dialog_msg">The username or password you entered is incorrect. Do you want to try again?</string>
    <string name="vpn_remote_hung_up_error_dialog_msg">Server hung up. The username or password you entered could be incorrect. Do you want to try again?</string>
    <string name="vpn_remote_ppp_hung_up_error_dialog_msg">Server hung up. It is possible that you are behind a firewall that prevents you from connecting to the server. Do you want to try again?</string>
    <string name="vpn_ppp_negotiation_failed_dialog_msg">Server negotiation failed. The server may not agree with your encryption option. Do you want to check your encryption setting?</string>

    <!-- VPN type selection activity title -->
    <string name="vpn_type_title">Add VPN</string>
    <!-- "Add VPN" preference title -->
    <string name="vpn_add_new_vpn">Add VPN</string>
    <!-- VPN profile editor title when adding a new profile -->
    <string name="vpn_edit_title_add">Add <xliff:g id="name">%s</xliff:g> VPN</string>
    <!-- VPN profile editor title when editing an existing profile -->
    <string name="vpn_edit_title_edit"><xliff:g id="name">%s</xliff:g> details</string>
    <!-- Preference group title for a list of VPN profiles -->
    <string name="vpns">VPNs</string>
    <!-- Preference summary text when VPN is connecting -->
    <string name="vpn_connecting">Connecting...</string>
    <!-- Preference summary text when VPN is disconnecting -->
    <string name="vpn_disconnecting">Disconnecting...</string>
    <!-- Preference summary text when VPN is connected -->
    <string name="vpn_connected">Connected</string>
    <!-- Preference summary text when VPN is not connected -->
    <string name="vpn_connect_hint">Connect to network</string>

    <!-- Name of a VPN profile -->
    <string name="vpn_name">VPN name</string>
    <string name="vpn_a_name">a VPN name</string>

    <!-- Toast message shown when a profile is added -->
    <string name="vpn_profile_added">\'<xliff:g id="name">%s</xliff:g>\' is added</string>
    <!-- Toast message shown when changes of a profile is saved -->
    <string name="vpn_profile_replaced">Changes are made to \'<xliff:g id="name">%s</xliff:g>\'</string>

    <!-- Preference title -->
    <string name="vpn_user_certificate_title">Set user certificate</string>
    <!-- Complete term -->
    <string name="vpn_user_certificate">User certificate</string>
    <string name="vpn_a_user_certificate">a user certificate</string>

    <!-- Preference title -->
    <string name="vpn_ca_certificate_title">Set CA certificate</string>
    <!-- Complete term -->
    <string name="vpn_ca_certificate">Certificate authority (CA) certificate</string>
    <string name="vpn_a_ca_certificate">a CA certificate</string>
    <!-- Preference title -->
    <string name="vpn_l2tp_secret_string_title">Set L2TP secret</string>
    <!-- Complete term -->
    <string name="vpn_l2tp_secret">L2TP secret</string>
    <string name="vpn_a_l2tp_secret">an L2TP secret</string>
    <string name="vpn_pptp_encryption_title">encryption</string>
    <string name="vpn_pptp_encryption">PPTP encryption</string>

    <!-- Preference title -->
    <string name="vpn_ipsec_presharedkey_title">Set IPSec pre-shared key</string>
    <!-- Complete term -->
    <string name="vpn_ipsec_presharedkey">IPSec pre-shared key</string>
    <string name="vpn_a_ipsec_presharedkey">an IPSec pre-shared key</string>

    <!-- Preference title -->
    <string name="vpn_vpn_server_title">Set VPN server</string>
    <!-- Complete term -->
    <string name="vpn_vpn_server">VPN server</string>
    <string name="vpn_a_vpn_server">a VPN server</string>
    <!-- Dialog title for setting VPN server name -->
    <string name="vpn_vpn_server_dialog_title">VPN server name</string>

    <!-- Preference title -->
    <string name="vpn_dns_search_list_title">DNS search domains</string>
    <!-- Complete term -->
    <string name="vpn_dns_search_list">DNS search domains</string>

    <!-- Summary text to hint that the value is set -->
    <string name="vpn_field_is_set"><xliff:g id="value">%s</xliff:g> is set</string>
    <!-- Summary text to hint that the value is not set -->
    <string name="vpn_field_not_set"><xliff:g id="value">%s</xliff:g> not set</string>
    <!-- Summary text to hint that the value is not set but it's not required-->
    <string name="vpn_field_not_set_optional"><xliff:g id="value">%s</xliff:g> not set (optional)</string>

    <!-- CheckBoxPreference title to enable something -->
    <string name="vpn_enable_field">Enable <xliff:g id="option">%s</xliff:g></string>
    <!-- CheckBoxPreference title to disable something -->
    <string name="vpn_disable_field">Disable <xliff:g id="option">%s</xliff:g></string>

    <!-- CheckBoxPreference summary to hint that something is enabled -->
    <string name="vpn_is_enabled"><xliff:g id="option">%s</xliff:g> is enabled</string>
    <!-- CheckBoxPreference summary to hint that something is disabled -->
    <string name="vpn_is_disabled"><xliff:g id="option">%s</xliff:g> is disabled</string>

    <!-- Title of preference to enter the VPN settings activity -->
    <string name="vpn_settings_title">VPN settings</string>
    <!-- Summary of preference to enter the VPN settings activity -->
    <string name="vpn_settings_summary">Set up &amp; manage Virtual Private Networks (VPNs)</string>
    <!-- A secret edit field's grayed out value when it has not been modified -->
    <string name="vpn_secret_unchanged">(unchanged)</string>
    <!-- A secret edit field's grayed out value when it has not been set -->
    <string name="vpn_secret_not_set">(not set)</string>

    <!-- Title of preference group for credential storage settings -->
    <string name="credentials_category">Credential storage</string>
    <!-- Title of preference to enable/dislable access to credential storage -->
    <string name="credentials_access">Use secure credentials</string>
    <!-- Summary of preference to enable/dislable access to credential storage -->
    <string name="credentials_access_summary">Allow applications to access secure certificates and other credentials</string>
    <!-- Title of dialog to enable/dislable access to credential storage -->
    <string name="credentials_unlock">Enter password</string>
    <!-- Description of dialog to enable/dislable access to credential storage -->
    <string name="credentials_unlock_hint">Enter the credential storage password.</string>
    <!-- Title of preference to install certificates from SD card -->
    <string name="credentials_install_certificates">Install from SD card</string>
    <!-- Summary of preference to install certificates from SD card -->
    <string name="credentials_install_certificates_summary">Install encrypted certificates from SD card</string>
    <!-- Title of preference to set storage password -->
    <string name="credentials_set_password">Set password</string>
    <!-- Summary of preference to set storage password -->
    <string name="credentials_set_password_summary">Set or change the credential storage password</string>
    <!-- Title of preference to reset credential storage -->
    <string name="credentials_reset">Clear storage</string>
    <!-- Summary of preference to reset credential storage -->
    <string name="credentials_reset_summary">Clear credential storage of all contents and reset its password</string>
    <!-- Description of dialog to reset the credential storage -->
    <string name="credentials_reset_hint">Are you sure you want to delete all credentials and reset the credential storage password?</string>
    <!-- Description for the old-password input box -->
    <string name="credentials_old_password">Current password:</string>
    <!-- Description for the new-password input box -->
    <string name="credentials_new_password">New password:</string>
    <!-- Description for the confirm-new-password input box -->
    <string name="credentials_confirm_password">Confirm new password:</string>
    <!-- Description when user set up the storage for the very first time -->
    <string name="credentials_first_time_hint">Set a password for the credential storage (at least 8 characters).</string>
    <string name="credentials_wrong_password">Please enter the correct password.</string>
    <string name="credentials_reset_warning">Please enter the correct password. You have one more try to enter the correct password before the credential storage is erased.</string>
    <string name="credentials_reset_warning_plural">Please enter the correct password. You have <xliff:g id="number" example="5">%1$d</xliff:g> more tries to enter the correct password before the credential storage is erased.</string>
    <string name="credentials_passwords_mismatch">Passwords do not match.</string>
    <string name="credentials_passwords_empty">You must enter and confirm a password.</string>
    <string name="credentials_password_empty">Please enter the password.</string>
    <string name="credentials_password_too_short">The password must have at least 8 characters.</string>
    <!-- toast message -->
    <string name="credentials_erased">The credential storage is erased.</string>
    <!-- toast message -->
    <string name="credentials_enabled">Credential storage is enabled.</string>
    <!-- toast message -->
    <string name="credentials_disabled">Credential storage is disabled.</string>

    <!-- Sound settings screen, setting check box label -->
    <string name="emergency_tone_title">Emergency tone</string>
    <!-- Sound settings screen, setting option summary text -->
    <string name="emergency_tone_summary">Set behavior when an emergency call is placed</string>

    <!-- Privacy Settings screen --><skip/>
    <!-- Privacy settings menu title -->
    <string name="privacy_settings">Privacy</string>
    <!-- Privacy settings activity title -->
    <string name="privacy_settings_title">Privacy settings</string>
    <!-- Backup section title -->
    <string name="backup_section_title">Backup and restore</string>
    <!-- Personal data section title -->
    <string name="personal_data_section_title">Personal data</string>
    <!-- Backup data menu title -->
    <string name="backup_data_title">Back up my data</string>
    <!-- Summary text of the "back up data" setting -->
    <string name="backup_data_summary">Back up my settings and other application data.</string>
    <!-- Auto-restore menu title -->
    <string name="auto_restore_title">Automatic restore</string>
    <!-- Summary text of the "automatic restore" setting -->
    <string name="auto_restore_summary">If I reinstall an application, restore backed up settings or other data.</string>
    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_title">Backup</string>
    <!-- Dialog title for confirmation to erase backup data from server -->
    <string name="backup_erase_dialog_message">Are you sure you want to stop backing up your settings and application data and erase all copies on Google servers?</string>

    <!-- Device admin settings screen --><skip/>
    <!-- Device admin settings activity title -->
    <string name="device_admin_settings_title">Device administration settings</string>
    <!-- Label for screen showing the active device policy -->
    <string name="active_device_admin_msg">Device administrator</string>
    <!-- Label for button to remove the active device admin -->
    <string name="remove_device_admin">Deactivate</string>
    <!-- Label for screen showing to select device policy -->
    <string name="select_device_admin_msg">Device administrators</string>
    <!-- Message when there are no available device admins to display -->
    <string name="no_device_admins">No available device administrators</string>

    <!-- Label for screen showing to add device policy -->
    <string name="add_device_admin_msg">Activate device administrator?</string>
    <!-- Label for button to set the active device admin -->
    <string name="add_device_admin">Activate</string>
    <!-- Device admin add activity title -->
    <string name="device_admin_add_title">Device administrator</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_warning">Activating this administrator will allow
        the application <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>
    <!-- Device admin warning message about policies an admin can use -->
    <string name="device_admin_status">This administrator is active and allows
        the application <xliff:g id="app_name">%1$s</xliff:g> to perform the
        following operations:</string>

    <!-- Name to assign to a Network Access Point that was saved without a name -->
    <string name="untitled_apn">Untitled</string>

    <string name="sound_category_sound_title">General</string>
    <string name="sound_category_calls_title">Incoming calls</string>
    <string name="sound_category_notification_title">Notifications</string>
    <string name="sound_category_feedback_title">Feedback</string>
</resources>
