<?xml version="1.0" encoding="utf-8"?>
<!--
/*
**
** Copyright 2008, 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">
    <!-- Application name for opensource Android keyboard. AOSP(Android Open Source Project) should not be translated. -->
    <string name="aosp_android_keyboard_ime_name">Android Keyboard (AOSP)</string>

    <!-- Title for Android Keyboard settings screen. AOSP(Android Open Source Project) should not be translated. -->
    <string name="aosp_android_keyboard_ime_settings">Android Keyboard Settings (AOSP)</string>

    <!-- Name of Android spell checker service. AOSP(Android Open Source Project) should not be translated. -->
    <string name="aosp_spell_checker_service_name">Android Spell Checker (AOSP)</string>

    <!-- Title for the spell checking service settings screen. AOSP(Android Open Source Project) should not be translated. -->
    <string name="aosp_android_spell_checker_service_settings">Android Spell Checker Settings (AOSP)</string>

    <!-- Title for Latin keyboard input options dialog [CHAR LIMIT=25] -->
    <string name="english_ime_input_options">Input options</string>

    <!-- Title for Latin keyboard research log dialog, which contains special commands for users that contribute data for research. [CHAR LIMIT=33] -->
    <string name="english_ime_research_log">Research Log Commands</string>

    <!-- Title for the spell checker option to turn on/off contact names lookup [CHAR LIMIT=25] -->
    <string name="use_contacts_for_spellchecking_option_title">Look up contact names</string>

    <!-- Description for the spell checker option to turn on/off contact names lookup. [CHAR LIMIT=65] -->
    <string name="use_contacts_for_spellchecking_option_summary">Spell checker uses entries from your contact list</string>

    <!-- Option to provide vibrate/haptic feedback on keypress -->
    <string name="vibrate_on_keypress">Vibrate on keypress</string>

    <!-- Option to play back sound on keypress in soft keyboard -->
    <string name="sound_on_keypress">Sound on keypress</string>

    <!-- Option to control whether or not to show a popup with a larger font on each key press. -->
    <string name="popup_on_keypress">Popup on keypress</string>

    <!-- Category title for general settings for Android keyboard -->
    <string name="general_category">General</string>

    <!-- Category title for text prediction -->
    <string name="correction_category">Text correction</string>

    <!-- Category title for gesture typing -->
    <string name="gesture_typing_category">Gesture typing</string>

    <!-- Category title for misc options  -->
    <string name="misc_category">Other options</string>

    <!-- Option name for advanced settings screen [CHAR LIMIT=25] -->
    <string name="advanced_settings">Advanced settings</string>
    <!-- Option summary for advanced settings screen [CHAR LIMIT=65 (two lines) or 30 (fits on one line, preferable)] -->
    <string name="advanced_settings_summary">Options for experts</string>

    <!-- Option name for including other IMEs in the language switch list [CHAR LIMIT=30] -->
    <string name="include_other_imes_in_language_switch_list">Switch to other input methods</string>
    <!-- Option summary for including other IMEs in the language switch list [CHAR LIMIT=65] -->
    <string name="include_other_imes_in_language_switch_list_summary">Language switch key covers other input methods too</string>
    <!-- Option to show language switch key [CHAR LIMIT=30] -->
    <string name="show_language_switch_key">Language switch key</string>
    <!-- Option summary for showing language switch key [CHAR LIMIT=65] -->
    <string name="show_language_switch_key_summary">Show when multiple input languages are enabled</string>

    <!-- Option to enable sliding key input indicator. The user can see a rubber band-like effect during sliding key input. [CHAR LIMIT=30]-->
    <string name="sliding_key_input_preview">Show slide indicator</string>
    <!-- Option summary to enable sliding key input indicator. The user can see a rubber band-like effect during sliding key input. [CHAR LIMIT=66]-->
    <string name="sliding_key_input_preview_summary">Display visual cue while sliding from Shift or Symbol keys</string>

    <!-- Option for the dismiss delay of the key popup [CHAR LIMIT=25] -->
    <string name="key_preview_popup_dismiss_delay">Key popup dismiss delay</string>
    <!-- Description for delay for dismissing a popup on keypress: no delay [CHAR LIMIT=15] -->
    <string name="key_preview_popup_dismiss_no_delay">No delay</string>
    <!-- Description for delay for dismissing a popup on screen: default value of the delay [CHAR LIMIT=15] -->
    <string name="key_preview_popup_dismiss_default_delay">Default</string>

    <!-- Units abbreviation for the duration (milliseconds) [CHAR LIMIT=10] -->
    <string name="abbreviation_unit_milliseconds"><xliff:g id="milliseconds">%s</xliff:g>ms</string>

    <!-- Option name for enabling or disabling the use of names of people in Contacts for suggestion and correction [CHAR LIMIT=25] -->
    <string name="use_contacts_dict">Suggest Contact names</string>
    <!-- Description for option enabling or disabling the use of names of people in Contacts for suggestion and correction [CHAR LIMIT=65] -->
    <string name="use_contacts_dict_summary">Use names from Contacts for suggestions and corrections</string>

    <!-- Option name for enabling or disabling the double-space period feature that lets double tap on spacebar insert a period followed by a space [CHAR LIMIT=30] -->
    <string name="use_double_space_period">Double-space period</string>
    <!-- Description for option enabling or disabling the double-space period feature that lets double tap on spacebar insert a period followed by a space [CHAR LIMIT=65] -->
    <string name="use_double_space_period_summary">Double tap on spacebar inserts a period followed by a space</string>

    <!-- Option to enable auto capitalization of sentences -->
    <string name="auto_cap">Auto-capitalization</string>
    <!-- Description for option to enable auto capitalization of sentences -->
    <string name="auto_cap_summary">Capitalize the first word of each sentence</string>

    <!-- Option to configure dictionaries -->
    <string name="configure_dictionaries_title">Add-on dictionaries</string>
    <!-- Name of the main dictionary, as opposed to auxiliary dictionaries (medical/entertainment/sports...) -->
    <string name="main_dictionary">Main dictionary</string>

    <!-- Option to enable showing suggestions -->
    <string name="prefs_show_suggestions">Show correction suggestions</string>
    <!-- Description for show suggestions -->
    <string name="prefs_show_suggestions_summary">Display suggested words while typing</string>
    <string name="prefs_suggestion_visibility_show_name">Always show</string>
    <string name="prefs_suggestion_visibility_show_only_portrait_name">Show in portrait mode</string>
    <string name="prefs_suggestion_visibility_hide_name">Always hide</string>

    <!-- Option to decide the auto correction threshold score -->
    <!-- Option to enable auto correction [CHAR LIMIT=20]-->
    <string name="auto_correction">Auto-correction</string>
    <!-- Description for auto correction [CHAR LIMIT=65 (two lines) or 30 (fits on one line, preferable)] -->
    <string name="auto_correction_summary">Spacebar and punctuation automatically correct mistyped words</string>
    <!-- Option to disable auto correction. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_off">Off</string>
    <!-- Option to suggest auto correction suggestions modestly. Auto-corrects only to a word which has small edit distance from typed word. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_modest">Modest</string>
    <!-- Option to suggest auto correction suggestions aggressively. Auto-corrects to a word which has even large edit distance from typed word. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_aggeressive">Aggressive</string>
    <!-- Option to suggest auto correction suggestions very aggressively. Auto-corrects to a word which has even large edit distance from typed word. [CHAR LIMIT=20] -->
    <string name="auto_correction_threshold_mode_very_aggeressive">Very aggressive</string>

    <!-- Option to enable using next word suggestions. After the user types a space, with this option on, the keyboard will try to predict the next word. -->
    <string name="bigram_prediction">Next-word suggestions</string>
    <!-- Description for "next word suggestion" option. This displays suggestions even when there is no input, based on the previous word. -->
    <string name="bigram_prediction_summary">Use the previous word in making suggestions</string>

    <!-- Option to enable gesture input. The user can input a word by tracing the letters of a word without releasing the finger from the screen. [CHAR LIMIT=30]-->
    <string name="gesture_input">Enable gesture typing</string>
    <!-- Description for "gesture_input" option. The user can input a word by tracing the letters of a word without releasing the finger from the screen. [CHAR LIMIT=65]-->
    <string name="gesture_input_summary">Input a word by sliding through the letters</string>
    <!-- Option to enable gesture trail preview. The user can see a trail of the gesture during gesture input. [CHAR LIMIT=30]-->
    <string name="gesture_preview_trail">Show gesture trail</string>
    <!-- Option to enable gesture floating text preview. The user can see a suggested word floating under the moving finger during a gesture input. [CHAR LIMIT=30]-->
    <string name="gesture_floating_preview_text">Dynamic floating preview</string>
    <!-- Description for "gesture_floating_preview_text" option. The user can see a suggested word floating under the moving finger during a gesture input. [CHAR LIMIT=65]-->
    <string name="gesture_floating_preview_text_summary">See the suggested word while gesturing</string>

    <!-- Indicates that a word has been added to the dictionary -->
    <string name="added_word"><xliff:g id="word">%s</xliff:g> : Saved</string>

    <!-- Label for soft enter key when it performs GO action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_go_key">Go</string>
    <!-- Label for soft enter key when it performs NEXT action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_next_key">Next</string>
    <!-- Label for soft enter key when it performs PREVIOUS action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_previous_key">Prev</string>
    <!-- Label for soft enter key when it performs DONE action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_done_key">Done</string>
    <!-- Label for soft enter key when it performs SEND action.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_send_key">Send</string>
    <!-- Label for "Pause" key of phone number keyboard.  Must be short to fit on key! [CHAR LIMIT=5] -->
    <string name="label_pause_key">Pause</string>
    <!-- Label for "Wait" key of phone number keyboard.  Must be short to fit on key! [CHAR LIMIT=5]-->
    <string name="label_wait_key">Wait</string>

    <!-- Spoken description to let the user know that when typing in a password, they can plug in a headset in to hear spoken descriptions of the keys they type. [CHAR LIMIT=NONE] -->
    <string name="spoken_use_headphones">Plug in a headset to hear password keys spoken aloud.</string>

    <!-- Spoken description for the currently entered text -->
    <string name="spoken_current_text_is">Current text is "%s"</string>
    <!-- Spoken description when there is no text entered -->
    <string name="spoken_no_text_entered">No text entered</string>

    <!-- Spoken description for unknown keyboard keys. -->
    <string name="spoken_description_unknown">Key code %d</string>
    <!-- Spoken description for the "Shift" keyboard key when "Shift" is off. -->
    <string name="spoken_description_shift">Shift</string>
    <!-- Spoken description for the "Shift" keyboard key when "Shift" is on. -->
    <string name="spoken_description_shift_shifted">Shift on (tap to disable)</string>
    <!-- Spoken description for the "Shift" keyboard key when "Caps lock" is on. -->
    <string name="spoken_description_caps_lock">Caps lock on (tap to disable)</string>
    <!-- Spoken description for the "Delete" keyboard key. -->
    <string name="spoken_description_delete">Delete</string>
    <!-- Spoken description for the "To Symbol" keyboard key. -->
    <string name="spoken_description_to_symbol">Symbols</string>
    <!-- Spoken description for the "To Alpha" keyboard key. -->
    <string name="spoken_description_to_alpha">Letters</string>
    <!-- Spoken description for the "To Numbers" keyboard key. -->
    <string name="spoken_description_to_numeric">Numbers</string>
    <!-- Spoken description for the "Settings" keyboard key. -->
    <string name="spoken_description_settings">Settings</string>
    <!-- Spoken description for the "Tab" keyboard key. -->
    <string name="spoken_description_tab">Tab</string>
    <!-- Spoken description for the "Space" keyboard key. -->
    <string name="spoken_description_space">Space</string>
    <!-- Spoken description for the "Mic" keyboard key. -->
    <string name="spoken_description_mic">Voice input</string>
    <!-- Spoken description for the "Smiley" keyboard key. -->
    <string name="spoken_description_smiley">Smiley face</string>
    <!-- Spoken description for the "Return" keyboard key. -->
    <string name="spoken_description_return">Return</string>
    <!-- Spoken description for the "Search" keyboard key. -->
    <string name="spoken_description_search">Search</string>
    <!-- Spoken description for the "U+2022" (BULLET) keyboard key. -->
    <string name="spoken_description_dot">Dot</string>
    <!-- Spoken description for the "Switch language" keyboard key. -->
    <string name="spoken_description_language_switch">Switch language</string>
    <!-- Spoken description for the "Next" action keyboard key. -->
    <string name="spoken_description_action_next">Next</string>
    <!-- Spoken description for the "Previous" action keyboard key. -->
    <string name="spoken_description_action_previous">Previous</string>

    <!-- Spoken feedback after turning "Shift" mode on. -->
    <string name="spoken_description_shiftmode_on">Shift enabled</string>
    <!-- Spoken feedback after turning "Caps lock" mode on. -->
    <string name="spoken_description_shiftmode_locked">Caps lock enabled</string>
    <!-- Spoken feedback after turning "Shift" mode off. -->
    <string name="spoken_description_shiftmode_off">Shift disabled</string>

    <!-- Spoken feedback after changing to the symbols keyboard. -->
    <string name="spoken_description_mode_symbol">Symbols mode</string>
    <!-- Spoken feedback after changing to the alphanumeric keyboard. -->
    <string name="spoken_description_mode_alpha">Letters mode</string>
    <!-- Spoken feedback after changing to the phone dialer keyboard. -->
    <string name="spoken_description_mode_phone">Phone mode</string>
    <!-- Spoken feedback after changing to the shifted phone dialer (symbols) keyboard. -->
    <string name="spoken_description_mode_phone_shift">Phone symbols mode</string>

    <!-- Spoken feedback when the keyboard is hidden. -->
    <string name="announce_keyboard_hidden">Keyboard hidden</string>
    <!-- Spoken feedback when the keyboard mode changes. -->
    <string name="announce_keyboard_mode">Showing <xliff:g id="mode" example="email">%s</xliff:g> keyboard</string>
    <!-- Description of the keyboard mode for entering dates. -->
    <string name="keyboard_mode_date">date</string>
    <!-- Description of the keyboard mode for entering dates and times. -->
    <string name="keyboard_mode_date_time">date and time</string>
    <!-- Description of the keyboard mode for entering email addresses. -->
    <string name="keyboard_mode_email">email</string>
    <!-- Description of the keyboard mode for entering text messages. -->
    <string name="keyboard_mode_im">messaging</string>
    <!-- Description of the keyboard mode for entering numbers. -->
    <string name="keyboard_mode_number">number</string>
    <!-- Description of the keyboard mode for entering phone numbers. -->
    <string name="keyboard_mode_phone">phone</string>
    <!-- Description of the keyboard mode for entering generic text. -->
    <string name="keyboard_mode_text">text</string>
    <!-- Description of the keyboard mode for entering times. -->
    <string name="keyboard_mode_time">time</string>
    <!-- Description of the keyboard mode for entering URLs. -->
    <string name="keyboard_mode_url">URL</string>

    <!-- Preferences item for enabling speech input -->
    <string name="voice_input">Voice input key</string>

    <!-- Voice Input modes -->
    <!-- On settings screen, voice input pop-up menu option to show voice key on main keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_main_keyboard">On main keyboard</string>
    <!-- On settings screen, voice input pop-up menu option to show voice key on symbols keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_symbols_keyboard">On symbols keyboard</string>
    <!-- On settings screen, voice input pop-up menu option to never show voice key [CHAR LIMIT=20] -->
    <string name="voice_input_modes_off">Off</string>
    <!-- Voice Input modes summary -->
    <!-- On settings screen, voice input pop-up menu summary text to show voice key on main keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_summary_main_keyboard">Mic on main keyboard</string>
    <!-- On settings screen, voice input pop-up menu summary text to show voice key on symbols keyboard [CHAR LIMIT=20] -->
    <string name="voice_input_modes_summary_symbols_keyboard">Mic on symbols keyboard</string>
    <!-- On settings screen, voice input pop-up menu summary text to never show voice key [CHAR LIMIT=20] -->
    <string name="voice_input_modes_summary_off">Voice input is disabled</string>

    <!-- Title for configuring input method settings [CHAR LIMIT=35] -->
    <string name="configure_input_method">Configure input methods</string>

    <!-- Title for input language selection screen -->
    <string name="language_selection_title">Input languages</string>

    <!-- Title for dialog option to let users cancel logging and delete log for this session [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_do_not_log_this_session" translatable="false">Suspend logging</string>
    <!-- Title for dialog option to let users reenable logging [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_enable_session_logging" translatable="false">Enable logging</string>
    <!-- Toast notification that the system is processing the request to delete the log for this session [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_notify_session_log_deleting" translatable="false">Deleting session log</string>
    <!-- Toast notification that the system has successfully deleted the log for this session [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_notify_logging_suspended" translatable="false">Logging temporarily suspended.  To disable permanently, go to Android Keyboard Settings</string>
    <!-- Toast notification that the system has failed to delete the log for this session [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_notify_session_log_not_deleted" translatable="false">Session log NOT deleted</string>
    <!-- Toast notification that the system is enabling logging [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_notify_session_logging_enabled" translatable="false">Session logging enabled</string>

    <!-- Text for checkbox option to include user data in feedback for research purposes [CHAR LIMIT=50] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_include_history_label" translatable="false">Include session history</string>
    <!-- Text for checkbox option to include user account name in feedback for research purposes [CHAR LIMIT=50] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_include_account_name_label" translatable="false">Include account name</string>
    <!-- Text for checkbox option to include a recording in feedback for research purposes [CHAR LIMIT=50] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_include_recording_label" translatable="false">Include recorded demonstration</string>
    <!-- Dialog button choice to send research feedback [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_send" translatable="false">Send</string>
    <!-- Dialog button choice to cancel sending research feedback [CHAR LIMIT=35] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_cancel" translatable="false">Cancel</string>
    <!-- Temporary notification to provide user with instructions about stopping a recording
      - operation[CHAR LIMIT=100] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_demonstration_instructions" translatable="false">Please demonstrate the issue you are writing about.\n\nWhen finished, select the \"Bug?\" button again."</string>
    <!-- Title of a preference to send feedback. [CHAR LIMIT=30]-->
    <string name="send_feedback">Send feedback</string>
    <!-- Temporary notification of recording failure [CHAR LIMIT=100] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_feedback_recording_failure" translatable="false">Recording cancelled due to timeout</string>
    <!-- Toast notification to ask user to quit the research feedback dialog to perform this operation [CHAR LIMIT=100] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_please_exit_feedback_form" translatable="false">Please exit the feedback dialog to access the research log menu</string>

    <!-- Title of dialog shown at start informing users about contributing research usage data-->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_splash_title" translatable="false">Warning</string>

    <!-- Toast message informing users that logging has been disabled -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_logging_disabled" translatable="false">Logging Disabled</string>

    <!-- Name for the research uploading service to be displayed to users.  [CHAR LIMIT=50] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_log_uploader_name" translatable="false">Research Uploader Service</string>

    <!-- Name for the research replaying service to be displayed to users.  [CHAR LIMIT=50] -->
    <!-- TODO: remove translatable=false attribute once text is stable -->
    <string name="research_log_replayer_name" translatable="false">Research Replayer Service</string>

    <!-- Preference for input language selection -->
    <string name="select_language">Input languages</string>

    <!-- Add to dictionary hint -->
    <string name="hint_add_to_dictionary">Touch again to save</string>

    <!-- Inform the user that a particular language has an available dictionary -->
    <string name="has_dictionary">Dictionary available</string>

    <!-- Preferences item for enabling to send user statistics for development only diagnostics -->
    <string name="prefs_enable_log">Enable user feedback</string>
    <!-- Description for enabling to send user statistics for development only diagnostics -->
    <string name="prefs_description_log">Help improve this input method editor by automatically sending usage statistics and crash reports</string>

    <!-- Title of the item to change the keyboard theme [CHAR LIMIT=20]-->
    <string name="keyboard_layout">Keyboard theme</string>

    <!-- Description for English (United Kingdom) keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_en_GB">English (UK)</string>
    <!-- Description for English (United States) keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_en_US">English (US)</string>
    <!-- Description for Spanish (United States) keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_es_US">Spanish (US)</string>
    <!-- Description for English (United Kingdom) keyboard subtype with explicit keyboard layout [CHAR LIMIT=25]
         This should be identical to subtype_en_GB aside from the trailing (%s). -->
    <string name="subtype_with_layout_en_GB">English (UK) (<xliff:g id="layout">%s</xliff:g>)</string>
    <!-- Description for English (United States) keyboard subtype with explicit keyboard layout [CHAR LIMIT=25]
         This should be identical to subtype_en_US aside from the trailing (%s). -->
    <string name="subtype_with_layout_en_US">English (US) (<xliff:g id="layout">%s</xliff:g>)</string>
    <!-- Description for Spanish (United States) keyboard subtype with explicit keyboard layout [CHAR LIMIT=25]
         This should be identical to subtype_es_US aside from the trailing (%s). -->
    <string name="subtype_with_layout_es_US">Spanish (US) (<xliff:g id="layout">%s</xliff:g>)</string>
    <!-- TODO: Uncomment once we can handle IETF language tag with script name specified.
         Description for Serbian Cyrillic keyboard subtype [CHAR LIMIT=25]
    <string name="subtype_serbian_cyrillic">Serbian (Cyrillic)</string>
         Description for Serbian Latin keyboard subtype [CHAR LIMIT=25]
    <string name="subtype_serbian_latin">Serbian (Latin)</string>
         Description for Serbian Latin keyboard subtype with explicit keyboard layout [CHAR LIMIT=25]
         This should be identical to subtype_serbian_latin aside from the trailing (%s).
    <string name="subtype_with_layout_sr-Latn">Serbian (Latin) (<xliff:g id="layout">%s</xliff:g>)</string>
    -->
    <!-- Description for language agnostic keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language">No language</string>
    <!-- Description for language agnostic QWERTY keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_qwerty">No language (QWERTY)</string>
    <!-- Description for language agnostic QWERTZ keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_qwertz">No language (QWERTZ)</string>
    <!-- Description for language agnostic AZERTY keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_azerty">No language (AZERTY)</string>
    <!-- Description for language agnostic Dvorak keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_dvorak">No language (Dvorak)</string>
    <!-- Description for language agnostic Colemak keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_colemak">No language (Colemak)</string>
    <!-- Description for language agnostic PC QWERTY keyboard subtype [CHAR LIMIT=25] -->
    <string name="subtype_no_language_pcqwerty">No language (PC)</string>

    <!-- Title of the preference settings for custom input styles (language and keyboard layout pairs) [CHAR LIMIT=35]-->
    <string name="custom_input_styles_title">Custom input styles</string>
    <!-- Title of the option menu to add a new style entry in the preference settings [CHAR LIMIT=16] -->
    <string name="add_style">Add style</string>
    <!-- Title of the button to add custom style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="add">Add</string>
    <!-- Title of the button to remove a custom style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="remove">Remove</string>
    <!-- Title of the button to save a custom style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="save">Save</string>
    <!-- Title of the spinner for choosing a language of custom style in the settings dialog [CHAR LIMIT=15] -->
    <string name="subtype_locale">Language</string>
    <!-- Title of the spinner for choosing a keyboard layout of custom style in the settings dialog [CHAR LIMIT=15] -->
    <string name="keyboard_layout_set">Layout</string>
    <!-- The message of the dialog to note that a custom input style needs to be enabled. [CHAR LIMIT=130] -->
    <string name="custom_input_style_note_message">"Your custom input style needs to be enabled before you start using it. Do you want to enable it now?"</string>
    <!-- Title of the button to enable a custom input style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="enable">Enable</string>
    <!-- Title of the button to postpone enabling a custom input style entry in the settings dialog [CHAR LIMIT=15] -->
    <string name="not_now">Not now</string>
    <!-- Toast text to describe the same input style already exists [CHAR LIMIT=64]-->
    <string name="custom_input_style_already_exists">"The same input style already exists: <xliff:g id="input_style_name">%s</xliff:g>"</string>

    <!-- Title of an option for usability study mode -->
    <string name="prefs_usability_study_mode">Usability study mode</string>
    <!-- Title of the settings for key long press delay [CHAR LIMIT=35] -->
    <string name="prefs_key_longpress_timeout_settings">Key long press delay</string>
    <!-- Title of the settings for keypress vibration duration [CHAR LIMIT=35] -->
    <string name="prefs_keypress_vibration_duration_settings">Keypress vibration duration</string>
    <!-- Title of the settings for keypress sound volume [CHAR LIMIT=35] -->
    <string name="prefs_keypress_sound_volume_settings">Keypress sound volume</string>
    <!-- Title of the settings for reading an external dictionary file -->
    <string name="prefs_read_external_dictionary">Read external dictionary file</string>
    <!-- Message to show when there are no files to install as an external dictionary [CHAR LIMIT=100] -->
    <string name="read_external_dictionary_no_files_message">No dictionary files in the Downloads folder</string>
    <!-- Title of the dialog that selects a file to install as an external dictionary [CHAR LIMIT=50] -->
    <string name="read_external_dictionary_multiple_files_title">Select a dictionary file to install</string>
    <!-- Title of the confirmation dialog to install a file as an external dictionary [CHAR LIMIT=50] -->
    <string name="read_external_dictionary_confirm_install_message">Really install this file for <xliff:g id="locale_name">%s</xliff:g>?</string>
    <!-- Title for an error dialog that contains the details of the error in the body [CHAR LIMIT=80] -->
    <string name="error">There was an error</string>

    <!-- Title of the button to revert to the default value of the device in the settings dialog [CHAR LIMIT=15] -->
    <string name="button_default">Default</string>

    <!-- TODO: Remove translatable="false" once wordings are finalized. -->
    <!-- Title of the setup wizard. [CHAR LIMT=40] -->
    <string name="setup_title" translatable="false">"Installing <xliff:g id="application_name">%s</xliff:g>"</string>
    <!-- Ordinal number of the 1st step in the setup wizard. [CHAR LIMIT=5] -->
    <string name="setup_step1_bullet" translatable="false">1</string>
    <!-- Title of the 1st step in the setup wizard. [CHAR LIMIT=64] -->
    <string name="setup_step1_title" translatable="false">"Enable <xliff:g id="application_name">%s</xliff:g> in settings."</string>
    <!-- Detailed instruction of the 1st step in the setup wizard. [CHAR LIMIT=80] -->
    <string name="setup_step1_instruction" translatable="false">"For security, please check \"<xliff:g id="application_name">%s</xliff:g>\""</string>
    <!-- Ordinal number of the 2nd step in the setup wizard. [CHAR LIMIT=5] -->
    <string name="setup_step2_bullet" translatable="false">2</string>
    <!-- Title of the 2nd step in the setup wizard. [CHAR LIMIT=64] -->
    <string name="setup_step2_title" translatable="false">"Switch to <xliff:g id="application_name">%s</xliff:g>."</string>
    <!-- Detailed instruction of the 2nd step in the setup wizard. [CHAR LIMIT=80] -->
    <string name="setup_step2_instruction" translatable="false">"Now that you've enabled <xliff:g id="application_name">%s</xliff:g>, you can switch to it."</string>
    <!-- Ordinal number of the 3rd step in the setup wizard. [CHAR LIMIT=5] -->
    <string name="setup_step3_bullet" translatable="false">3</string>
    <!-- Title of the 3rd step in the setup wizard. [CHAR LIMIT=64] -->
    <string name="setup_step3_title" translatable="false">"Congratulations, you're all set!"</string>
    <!-- Detailed instruction of the 3rd step in the setup wizard. [CHAR LIMIT=80] -->
    <string name="setup_step3_instruction" translatable="false">Configure additional languages</string>
    <!-- Title of the Language & input settings. This should be aligned with msgid="5292716747264442359" -->
    <string name="language_settings">Language &amp; input</string>
    <!-- Title of the Input method picker. This should be aligned with msgid="4653387336791222978" -->
    <string name="select_input_method">Choose input method</string>
    <!-- Option to show setup wizard icon. [CHAR LIMIT=30]-->
    <string name="show_setup_wizard_icon" translatable="false">Show setup wizard icon</string>

    <!-- The dictionary provider application name. Visible in Settings/Applications/Manage applications. -->
    <string name="app_name">Dictionary Provider</string>
    <!-- The dictionary provider ContentProvider name. Visible in Settings/Applications/Running services. -->
    <string name="dictionary_provider_name">Dictionary Provider</string>
    <!-- The dictionary provider Service name. Visible in Settings/Applications/Running services. -->
    <string name="dictionary_service_name">Dictionary Service</string>

    <!-- Downloadable dictionaries will get update information through the network. This describes the associated download. -->
    <string name="download_description">Dictionary update information</string>

    <!-- Title and summary of the dictionary settings screen -->
    <string name="dictionary_settings_title">Add-on dictionaries</string>
    <!-- Title for the prompt dialog which informs the user that a dictionary is available for the current language and asks to decide whether to download it over 3g -->
    <string name="dictionary_install_over_metered_network_prompt">Dictionary available</string>
    <string name="dictionary_settings_summary">Settings for dictionaries</string>
    <!-- Name of the user dictionaries settings category -->
    <string name="user_dictionaries">User dictionaries</string>
    <!-- Name for the "user dictionary" preference item when there is only one -->
    <string name="default_user_dict_pref_name">User dictionary</string>
    <!-- Message about some dictionary indicating it can be downloaded, but hasn't been yet -->
    <string name="dictionary_available">Dictionary available</string>
    <!-- Message about some dictionary indicating it is downloading and should be available soon -->
    <string name="dictionary_downloading">Currently downloading</string>
    <!-- Message about some dictionary indicating it is already installed -->
    <string name="dictionary_installed">Installed</string>
    <!-- Message about some dictionary indicating the file is installed, but the dictionary is disabled -->
    <string name="dictionary_disabled">Installed, disabled</string>

    <!-- Message to display in the dictionaries setting screen when some error prevented us to list installed dictionaries [CHAR LIMIT=50] -->
    <string name="cannot_connect_to_dict_service">Problem connecting to dictionary service</string>
    <!-- Message to display in the dictionaries setting screen when we found that no dictionaries are available [CHAR LIMIT=50]-->
    <string name="no_dictionaries_available">No dictionaries available</string>

    <!-- Title of the options to press to refresh the list (as in, check for updates now) [CHAR_LIMIT=50] -->
    <string name="check_for_updates_now">Refresh</string>
    <!-- Hint to tell when the data was last updated. Usage : "Last updated [date]", may contain a : or so. [CHAR LIMIT=45] -->
    <string name="last_update">Last updated</string>

    <!-- Message to display in a dialog box while we are actively updating the word list [CHAR LIMIT=60] -->
    <string name="message_updating">Checking for updates</string>
    <!-- Message to display while the add-on dictionary list is updating [no space constraints on this, there is plenty of space but shorter is better because it's only on the screen for a second] -->
    <string name="message_loading">Loading...</string>

    <!-- String to explain this dictionary is the main dictionary for this language [CHAR_LIMIT=30] -->
    <string name="main_dict_description">Main dictionary</string>

    <!-- Standard message to dismiss a dialog box -->
    <string name="cancel">Cancel</string>

    <!-- Action to download and install a dictionary [CHAR_LIMIT=15] -->
    <string name="install_dict">Install</string>
    <!-- Action to cancel the ongoing download of a dictionary file [CHAR_LIMIT=25] -->
    <string name="cancel_download_dict">Cancel</string>
    <!-- Action to delete a dictionary file [CHAR_LIMIT=15] -->
    <string name="delete_dict">Delete</string>

    <!-- Message in the popup informing the user a dictionary is available for their language, and asking for a decision to download over their mobile data plan or not. The reason we ask for this is, the data is large and may be downloaded over a paid-per-megabyte connection but a dictionary is also essential to type comfortably, so we ask the user. This only pops in selected cases, when there is no dictionary at all currently, and the only available network seems to be metered. The "Language & input" part should be set to the actual name of the option (message ID 5292716747264442359 in the translation console). [CHAR_LIMIT=700] -->
    <string name="should_download_over_metered_prompt">The selected language on your mobile device has an available dictionary.&lt;br/>
We recommend &lt;b>downloading&lt;/b> the <xliff:g id="language" example="English">%1$s</xliff:g> dictionary to improve your typing experience.&lt;br/>
&lt;br/>
The download could take a minute or two over 3G. Charges may apply if you don\'t have an &lt;b>unlimited data plan&lt;/b>.&lt;br/>
If you are not sure which data plan you have, we recommend finding a Wi-Fi connection to start the download automatically.&lt;br/>
&lt;br/>
Tip: You can download and remove dictionaries by going to &lt;b>Language &amp; input&lt;/b> in the &lt;b>Settings&lt;/b> menu of your mobile device.</string>
    <string name="download_over_metered">Download now (<xliff:g id="size_in_megabytes" example="0.7">%1$.1f</xliff:g>MB)</string>
    <string name="do_not_download_over_metered">Download over Wi-Fi</string>
    <!-- The text of the "dictionary available" notification. -->
    <string name="dict_available_notification_title">A dictionary is available for <xliff:g id="language" example="English">%1$s</xliff:g></string>
    <!-- The small subtext in the "dictionary available" notification. -->
    <string name="dict_available_notification_description">Press to review and download</string>

    <!-- The text of the toast warning a download is starting automatically to enable suggestions for the selected language [CHAR LIMIT=100] -->
    <string name="toast_downloading_suggestions">Downloading: suggestions for <xliff:g id="language" example="English">%1$s</xliff:g> will be ready soon.</string>
</resources>
