<?xml version="1.0" encoding="utf-8"?>
<!-- Copyright (C) 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">

    <!-- Permissions label for reading attachments -->
    <string name="permission_read_attachment_label">Read email attachments</string>
    <!-- Permissions description for reading attachments -->
    <string name="permission_read_attachment_desc">Allows this application to read your email
        attachments.</string>
    <!-- Permissions label for accessing the main provider -->
    <string name="permission_access_provider_label">Access email provider data</string>
    <!-- Permissions description for accessing the main provider -->
    <string name="permission_access_provider_desc">Allows this application to access your email
        database, including received messages, sent messages, usernames, and passwords.</string>

    <!-- Name of application on Home screen -->
    <string name="app_name">Email</string>
    <!-- Title of compose screen -->
    <string name="compose_title">Compose</string>
    <!-- Title of debug screen -->
    <string name="debug_title">Debug</string>

    <!-- Actions will be used as buttons and in menu items -->
    <skip />

    <!-- Button name used as part of a multi-step process -->
    <string name="next_action">Next</string>
    <!-- Button name used to confirm acceptance of dialog boxes, warnings, errors, etc. -->
    <string name="okay_action">OK</string>
    <!-- Button name used to cancel out of dialog boxes -->
    <string name="cancel_action">Cancel</string>
    <!-- Button name used to move to previous step during setup sequence [CHAR_LIMIT=16] -->
    <string name="previous_action">Previous</string>
    <!-- Menu item/button name -->
    <string name="send_action">Send</string>
    <!-- Menu item/button name -->
    <string name="reply_action">Reply</string>
    <!-- Menu item/button name -->
    <string name="reply_all_action">Reply all</string>
    <!-- Menu item/button name -->
    <string name="delete_action">Delete</string>
    <!-- Menu item/button name -->
    <string name="forward_action">Forward</string>
    <!-- Menu/Button item name and label for marking a message as a favorite
         (usually called starred) [CHAR LIMIT=40] -->
    <string name="favorite_action">Star</string>
    <!--  Button name used to complete a multi-step process -->
    <string name="done_action">Done</string>
    <!--  Button name used to create a new quick response [CHAR_LIMIT=16] -->
    <string name="create_action">Create new</string>
    <!--  Button name used to delete a quick response [CHAR_LIMIT=16] -->
    <string name="delete_quick_response_action">Delete</string>
    <!-- Message informing user when a list that would contain quick responses
            is empty [CHAR_LIMIT=80] -->
    <string name="quick_responses_empty_view">No quick responses</string>
    <!-- Menu item/button name -->
    <string name="discard_action">Discard</string>
    <!-- Menu item/button name [CHAR_LIMIT=16] -->
    <string name="save_draft_action">Save draft</string>
    <!-- Menu item/button name. Pressing will insert previously saved text
            into message body. [CHAR_LIMIT=24] -->
    <string name="show_quick_text_list_dialog_action">Insert quick response</string>
    <!-- Menu item/button name -->
    <string name="read_action">Mark read</string>
    <!-- Menu item/button name -->
    <string name="unread_action">Mark unread</string>
    <!-- Menu item/button name -->
    <string name="set_star_action">Add star</string>
    <!-- Menu item/button name -->
    <string name="remove_star_action">Remove star</string>
    <!-- Menu item -->
    <string name="refresh_action">Refresh</string>
    <!-- Menu item -->
    <string name="add_account_action">Add account</string>
    <!-- Menu item -->
    <string name="compose_action">Compose</string>
    <!-- Menu item/button name -->
    <string name="search_action">Search</string>
    <!-- Menu item -->
    <string name="account_settings_action">Account settings</string>
    <!-- Menu item for settings [CHAR LIMIT=40]-->
    <string name="settings_action">Settings</string>
    <!-- Menu item [CHAR LIMIT=32] -->
    <string name="mailbox_settings_action">Sync options</string>
    <!-- Menu item -->
    <string name="mark_as_unread_action">Mark as unread</string>
    <!-- Menu item for moving messages to folders [CHAR LIMIT=10] -->
    <string name="move_action">Move</string>
    <!-- Menu item for navigating to an newer message [CHAR LIMIT=10] -->
    <string name="newer_action">Newer</string>
    <!-- Menu item for navigating to an older message [CHAR LIMIT=10] -->
    <string name="older_action">Older</string>
    <!-- Button label for adding CC/BCC fields on message compose. [CHAR LIMIT=16] -->
    <string name="plus_cc_label">+ Cc/Bcc</string>
    <!-- Menu item label for adding CC/BCC fields on message compose. [CHAR LIMIT=20] -->
    <string name="add_cc_bcc_menu">Add Cc/Bcc</string>
    <!-- Menu item label for adding an attachment on message compose. [CHAR LIMIT=20] -->
    <string name="add_file_attachment">Attach file</string>
    <!-- Generic button [CHAR LIMIT=16] -->
    <string name="close_action">Close</string>
    <!-- Command shown on Outbox to send all pending messages [CHAR LIMIT=20] -->
    <string name="message_list_send_pending_messages_action">Send all messages</string>
    <!-- Appears in choose attachment dialog title -->
    <string name="choose_attachment_dialog_title">Choose attachment</string>
    <!-- Dialog title to select a mailbox to which the user moves messages [CHAR LIMIT=20] -->
    <string name="move_to_folder_dialog_title">Move to</string>
    <!-- Appears in message list view while messages are being loaded [CHAR LIMIT=260dip] -->
    <string name="status_loading_messages">Loading messages\u2026</string>
    <!-- Appears in message list view when there's a network error. -->
    <!-- Also appears in a toast, in the message viewer, when there's a network error. -->
    <string name="status_network_error">Connection problem.</string>
    <!-- Dialog text when we are unable to load the message for display -->
    <string name="error_loading_message_body">Couldn\'t load the message text. The message
        may be too large to view.</string>
    <!-- Text shown with dragged messages to indicate how many are being dragged [CHAR LIMIT=40]-->
    <plurals name="move_messages">
        <item quantity="one">Move message</item>
        <item quantity="other">Move messages</item>
    </plurals>
    <!-- Toast shown when a message(s) can't be moved because it's not supported by the POP3
        protocol. [CHAR LIMIT=none]-->
    <string name="cannot_move_protocol_not_supported_toast">Move isn\'t supported on POP3 accounts.
        </string>
    <!-- Toast shown when messages can't be moved because the selection contains multiple accounts'
        messages. [CHAR LIMIT=none]-->
    <string name="cannot_move_multiple_accounts_toast">Can\'t move because selection contains multiple
        accounts.</string>
    <!-- Toast shown when messages can't be moved because they're in a special mailbox.  "Drafts",
        "Outbox" and "Sent". [CHAR LIMIT=none]-->
    <string name="cannot_move_special_mailboxes_toast">Messages in Drafts, Outbox, and Sent can\'t be
        moved.</string>

    <!-- Notification message in notifications window when one account has
         one or more new messages; e.g, "279 unread (someone@google.com)". -->
    <plurals name="notification_new_one_account_fmt">
        <!-- Case of one new message. -->
        <item quantity="one"><xliff:g id="unread_message_count" example="1">%1$d</xliff:g> unread (<xliff:g id="account">%2$s</xliff:g>)</item>

        <!-- Case of "few" (small number of) new messages. -->
        <item quantity="few"><xliff:g id="unread_message_count" example="2">%1$d</xliff:g> unread (<xliff:g id="account">%2$s</xliff:g>)</item>

        <!-- Case of a plural number of new messages. -->
        <item quantity="other"><xliff:g id="unread_message_count" example="279">%1$d</xliff:g> unread (<xliff:g id="account">%2$s</xliff:g>)</item>
    </plurals>

    <!-- Notification message in notifications window when 2+ accounts have new mail; e.g, "in 3 accounts". -->
    <plurals name="notification_new_multi_account_fmt">
        <!-- Case of "few" (small number of) accounts with unread messages. -->
        <item quantity="few">in <xliff:g id="number_accounts" example="2">%d</xliff:g> accounts</item>
        <!-- Case of plural number of accounts with unread messages. -->
        <item quantity="other">in <xliff:g id="number_accounts" example="10">%d</xliff:g> accounts</item>
    </plurals>
    <!-- String to indicate which account received a new message. [CHAR LIMIT=none] -->
    <string name="notification_to_account">to <xliff:g id="receiver_name"
            example="Main">%1$s</xliff:g></string>

    <!-- Notification for multiple messages [CHAR LIMIT=60] -->
    <string name="notification_multiple_new_messages_fmt">
        <xliff:g example="2">%1$d</xliff:g> new messages</string>

    <!-- Name given to "all accounts" in the account picker for shortcuts and widget [CHAR LIMIT=20] -->
    <string name="account_name_display_all">All accounts</string>

    <!-- The number of accounts configured. [CHAR LIMIT=16] -->
    <plurals name="number_of_accounts">
        <item quantity="one"><xliff:g id="num_accounts" example="1">%1$d</xliff:g> account</item>
        <item quantity="other"><xliff:g id="num_accounts" example="2">%1$d</xliff:g> accounts</item>
    </plurals>
    <!-- The next set of strings are used server-side and must not be localized. -->
    <!-- Do Not Translate.  This is the name of the "inbox" folder, on the server. -->
    <string name="mailbox_name_server_inbox" translatable="false">Inbox</string>
    <!-- Do Not Translate.  This is the name of the "outbox" folder, on the server. -->
    <string name="mailbox_name_server_outbox" translatable="false">Outbox</string>
    <!-- Do Not Translate.  This is the name of the "drafts" folder, on the server. -->
    <string name="mailbox_name_server_drafts" translatable="false">Drafts</string>
    <!-- Do Not Translate.  This is the name of the "trash" folder, on the server. -->
    <string name="mailbox_name_server_trash" translatable="false">Trash</string>
    <!-- Do Not Translate.  This is the name of the "sent" folder, on the server. -->
    <string name="mailbox_name_server_sent" translatable="false">Sent</string>
    <!-- Do Not Translate.  This is the name of the "junk" folder, on the server. -->
    <string name="mailbox_name_server_junk" translatable="false">Junk</string>

    <!-- The next set of strings are used in local display and may be localized. -->
    <!-- In the UI, the inbox will be displayed with this name -->
    <string name="mailbox_name_display_inbox">Inbox</string>
    <!-- In the UI, the outbox will be displayed with this name -->
    <string name="mailbox_name_display_outbox">Outbox</string>
    <!-- In the UI, the drafts will be displayed with this name -->
    <string name="mailbox_name_display_drafts">Drafts</string>
    <!-- In the UI, the trash will be displayed with this name -->
    <string name="mailbox_name_display_trash">Trash</string>
    <!-- In the UI, the sent will be displayed with this name -->
    <string name="mailbox_name_display_sent">Sent</string>
    <!-- In the UI, the junk will be displayed with this name -->
    <string name="mailbox_name_display_junk">Junk</string>
    <!-- In the UI, the unread will be displayed with this name [CHAR LIMIT=15] -->
    <string name="mailbox_name_display_unread">Unread</string>
    <!-- In the shortcut/widget configuration UI, the label for selecting only the unread messages in an account's inbox [CHAR LIMIT=30] -->
    <string name="picker_mailbox_name_all_unread">Inbox (unread)</string>
    <!-- In the shortcut/widget configuration UI, the label for selecting all messages in an account's inbox [CHAR LIMIT=30] -->
    <string name="picker_mailbox_name_all_inbox">Inbox (all)</string>
    <!-- In the shortcut/widget configuration UI, use this for the "all accounts" account list item [CHAR LIMIT=30] -->
    <string name="picker_combined_view_fmt">Combined view (<xliff:g id="count">%s</xliff:g>)</string>
    <!-- Count of accounts; used in picker_combined_view_fmt -->
    <plurals name="picker_combined_view_account_count">
        <item quantity="one"  ><xliff:g id="account_count" example="1">%d</xliff:g> account</item>
        <item quantity="other"><xliff:g id="account_count" example="9">%d</xliff:g> accounts</item>
    </plurals>

    <!-- Version number, shown only on debug screen -->
    <string name="debug_version_fmt">Version: <xliff:g id="version">%s</xliff:g></string>
    <!-- Do Not Translate.  Checkbox label, shown only on debug screen -->
    <string name="debug_enable_debug_logging_label" translatable="false">
        Enable extra debug logging?</string>
    <!-- Do Not Translate.  Checkbox label, shown only on debug screen -->
    <string name="debug_enable_exchange_logging_label" translatable="false">
        Enable exchange parser logging? (extremely verbose)</string>
    <!-- Do Not Translate.  Checkbox label, shown only on debug screen -->
    <string name="debug_enable_exchange_file_logging_label" translatable="false">
        Enable exchange sd card logging?</string>
    <!-- Do Not Translate.  Button label, shown only on debug screen -->
    <string name="debug_clear_webview_cache" translatable="false">
        Clear WebView cache</string>
    <!-- Do Not Translate.  Checkbox label, shown on debug screen. -->
    <string name="debug_disable_graphics_acceleration_label" translatable="false">
        Disable hardware graphics acceleration</string>
    <!-- Do Not Translate.  Checkbox label, shown on debug screen. -->
    <string name="debug_force_one_minute_refresh_label" translatable="false">
        Force 1-minute refresh for POP/IMAP</string>
    <!-- Do Not Translate.  Checkbox label, shown on debug screen. -->
    <string name="debug_enable_strict_mode_label" translatable="false">
        Enable strict mode (with logging)</string>

    <!-- The summary section entry in the AccountFolder list to display all inboxes -->
    <string name="account_folder_list_summary_inbox">Inbox</string>
    <!-- The summary section entry in the AccountFolder list to display all starred
        [CHAR LIMIT=200dip] -->
    <string name="account_folder_list_summary_starred">Starred</string>
    <!-- The summary section entry in the AccountFolder list to display all drafts
        [CHAR LIMIT=200dip] -->
    <string name="account_folder_list_summary_drafts">Drafts</string>
    <!-- The summary section entry in the AccountFolder list to display all outboxes
        [CHAR LIMIT=200dip] -->
    <string name="account_folder_list_summary_outbox">Outbox</string>

    <!-- Label shown in the account selector to select "Combined view", which contains
         Combined Inbox, Combined Outbox, etc. [CHAR LIMIT=30] -->
    <string name="mailbox_list_account_selector_combined_view">Combined view</string>
    <!-- Label shown in the account/mailbox selector to switch to the show all the top-level mailboxes. [CHAR LIMIT=30] -->
    <string name="mailbox_list_account_selector_show_all_folders">Show all folders</string>
    <!-- Account list header in the account/mailbox selector. [CHAR LIMIT=30] -->
    <string name="mailbox_list_account_selector_account_header">Accounts</string>
    <!-- Recent mailbox header in the account/mailbox selector. [CHAR LIMIT=30] -->
    <string name="mailbox_list_account_selector_mailbox_header_fmt">
        Recent folders (<xliff:g id="email_address">%s</xliff:g>)</string>

    <!-- Mailbox list header for user folders [CHAR LIMIT=30] -->
    <string name="mailbox_list_user_mailboxes">All folders</string>
    <!-- Mailbox list header for recent folders [CHAR LIMIT=30] -->
    <string name="mailbox_list_recent_mailboxes">Recent folders</string>

    <!-- Announces the subject field for a message for users with accessibility requirements -->
    <string name="message_subject_description">Subject</string>
    <!-- Announces that a message has no sender or subject
            to users with accessibility requirements -->
    <string name="message_is_empty_description">No subject</string>
    <!-- Appears at the bottom of list of messages; user selects to load more messages from that folder. -->
    <string name="message_list_load_more_messages_action">Load more messages</string>
    <!--  The number of messages that are currently selected for various operations such as
          "delete message(s)" [CHAR LIMIT=32] -->
    <plurals name="message_view_selected_message_count">
        <item quantity="one"  ><xliff:g id="message_count" example="1">%d</xliff:g> selected</item>
        <item quantity="other"><xliff:g id="message_count" example="9">%d</xliff:g> selected</item>
    </plurals>
    <!-- Message to show when there are no messages (emails) in the selected mailbox.
         [CHAR LIMIT=26] -->
    <string name="message_list_no_messages">No messages</string>
    <!-- Hint text in To field -->
    <string name="message_compose_to_hint">To</string>
    <!-- Hint text in Cc field -->
    <string name="message_compose_cc_hint">Cc</string>
    <!-- Hint text in Bcc field -->
    <string name="message_compose_bcc_hint">Bcc</string>
    <!-- Hint text in Subject field -->
    <string name="message_compose_subject_hint">Subject</string>
    <!-- Label for From field [CHAR LIMIT=12] -->
    <string name="message_compose_from_label">From:</string>
    <!-- Label for To field [CHAR LIMIT=12] -->
    <string name="to">To</string>
    <!-- Label for Cc field [CHAR LIMIT=12] -->
    <string name="cc">Cc</string>
    <!-- Label for Bcc field [CHAR LIMIT=12] -->
    <string name="bcc">Bcc</string>
    <!-- Label for Subject field [CHAR LIMIT=12] -->
    <string name="subject_hint">Subject</string>
    <!-- Hint text in Message composer body field -->
    <string name="body_hint">Compose email</string>
    <!-- Header for forwarded original messages -->
    <string name="message_compose_fwd_header_fmt">\n\n-------- Original Message --------\nSubject: <xliff:g id="subject">%1$s</xliff:g>\nFrom: <xliff:g id="sender">%2$s</xliff:g>\nTo: <xliff:g id="to">%3$s</xliff:g>\nCC: <xliff:g id="cc">%4$s</xliff:g>\n\n</string>
    <!-- Header for replied-to messages -->
    <string name="message_compose_reply_header_fmt">\n\n<xliff:g id="sender">%s</xliff:g> wrote:\n\n</string>
    <!-- Heading that appears before forwarded text -->
    <string name="message_compose_quoted_text_label">Include quoted text</string>
    <!-- Label of checkbox to include original message in a forwarded/replied message
         [CHAR_LIMIT=32] -->
    <string name="message_compose_include_quoted_text_checkbox_label">Include text</string>
    <!-- Toast that appears if you try to send with no recipients. -->
    <string name="message_compose_error_no_recipients">You must add at least one recipient.</string>
    <!-- An address field contains invalid email addresses. -->
    <string name="message_compose_error_invalid_email">Some email addresses are invalid.</string>
    <!-- Toast that appears when an attachment is too big to send. -->
    <string name="message_compose_attachment_size">File too large to attach.</string>
    <!-- Title for dialog containing list of quick responses that user may insert
            into message body. [CHAR_LIMIT=30] -->
    <string name="message_compose_insert_quick_response_list_title">Insert quick response</string>
    <!-- Display name for composed message, indicating the destination of the message.
      e.g. "John and 2 others" -->
    <string name="message_compose_display_name"><xliff:g id="name" example="John">%1$s</xliff:g> and <xliff:g id="number" example="27">%2$d</xliff:g> others</string>
    <!-- Label for To field in read message view -->
    <string name="message_view_to_label">To:</string>
    <!-- Label for CC field in read message view -->
    <string name="message_view_cc_label">Cc:</string>
    <string name="message_view_bcc_label">Bcc:</string>
    <!-- Label for the date field. [CHAR LIMIT=20]-->
    <string name="message_view_date_label">Date:</string>
    <!-- Label for the from field. [CHAR LIMIT=20]-->
    <string name="message_view_from_label">From:</string>
    <!-- Label for the subject field. [CHAR LIMIT=20]-->
    <string name="message_view_subject_label">Subject:</string>
    <!-- Button name to view an attachment [CHAR LIMIT=10]-->
    <string name="message_view_attachment_view_action">View</string>
    <!-- Button name to install an .apk attachment [CHAR LIMIT=10]-->
    <string name="message_view_attachment_install_action">Install</string>
    <!-- Button name to play a media (i.e. audio/video) attachment [CHAR LIMIT=10]-->
    <string name="message_view_attachment_play_action">Play</string>
    <!-- Button name, to load an attachment from the mail server [CHAR LIMIT=10]-->
    <string name="message_view_attachment_load_action">Load</string>
    <!-- Button name, to show info about an attachment from the mail server [CHAR LIMIT=10]-->
    <string name="message_view_attachment_info_action">Info</string>
    <!-- Button name, to save the attachment to SD card [CHAR LIMIT=10]-->
    <string name="message_view_attachment_save_action">Save</string>
    <!-- Disabled button text to indicate an attachment has been saved [CHAR LIMIT=10] -->
    <string name="message_view_attachment_saved">Saved</string>
    <!-- Button name, to cancel a queued attachment download [CHAR LIMIT=10]-->
    <string name="message_view_attachment_cancel_action">Stop</string>
    <!-- Toast after saving attachment [CHAR LIMIT=30] -->
    <string name="message_view_status_attachment_saved">Attachment saved
as <xliff:g id="filename">%s</xliff:g>.</string>
    <!-- Toast after attachment could not be saved [CHAR LIMIT=30] -->
    <string name="message_view_status_attachment_not_saved">Couldn\'t save the attachment.</string>
    <!-- Toast upon using "send" when one or more attachments will need to be background loaded
      [CHAR LIMIT=none]-->
    <string name="message_view_attachment_background_load">Note: One or more attachments in your
        forwarded message will be downloaded prior to sending.</string>
    <!--Button on the message view screen to show the message content [CHAR LIMIT=16] -->
    <string name="message_view_show_message_action">Message</string>
    <!--Button on the message view screen to show the calendar invite [CHAR LIMIT=16] -->
    <string name="message_view_show_invite_action">Invite</string>
    <!--Button on the message view screen to show the attachments [CHAR LIMIT=16] -->
    <plurals name="message_view_show_attachments_action">
        <item quantity="one">Attachment <xliff:g id="num_attachment" example="1" >%1$d</xliff:g>
            </item>
        <item quantity="other">Attachments <xliff:g id="num_attachment" example="3" >%1$d</xliff:g>
            </item>
    </plurals>
    <!-- Button on the message view screen to show the embedded pictures [CHAR LIMIT=16] -->
    <string name="message_view_show_pictures_action">Show pictures</string>
    <!-- Button on the message view screen to always show pictures from the given
         sender [CHAR LIMIT=32] -->
    <string name="message_view_always_show_pictures_button">Always show</string>
    <!-- Prompt on the message view screen whether or not to always show pictures from the
         given sender [CHAR LIMIT=80] -->
    <string name="message_view_always_show_pictures_prompt"
        >Always show pictures from this sender</string>
    <!-- Confirmation toast to indicate that the user has chosen to always show
         pictures from the given sender [CHAR LIMIT=160] -->
    <string name="message_view_always_show_pictures_confirmation"
      >Pictures from this sender will be shown automatically.</string>
    <!-- Calendar invitation, label of the button to open in calendar [CHAR LIMIT=24] -->
    <string name="message_view_invite_view">View in Calendar</string>
    <!-- String shown with a calendar invitation. -->
    <string name="message_view_invite_title">Calendar invite</string>
    <!-- String shown with a calendar invitation. -->
    <string name="message_view_invite_text">Going?</string>
    <!-- Button text: Calendar invitation: Accept. The leading space is used for spacing -->
    <string name="message_view_invite_accept">" Yes"</string>
    <!-- Button text: Calendar invitation: Maybe. The leading space is used for spacing -->
    <string name="message_view_invite_maybe">" Maybe"</string>
    <!-- Button text: Calendar invitation: Decline. The leading space is used for spacing -->
    <string name="message_view_invite_decline">" No"</string>
    <!-- Toast shown following a meeting invite reply, accepted -->
    <string name="message_view_invite_toast_yes">You\'ve accepted this invitation.</string>
    <!-- Toast shown following a meeting invite reply, maybe -->
    <string name="message_view_invite_toast_maybe">
        You\'ve replied \"maybe\" to this invitation.</string>
    <!-- Toast shown following a meeting invite reply, declined -->
    <string name="message_view_invite_toast_no">You\'ve declined this invitation.</string>
    <!--Confirmation dialog title shown when user tries to delete messages.  [CHAR LIMIT=16] -->
    <!-- Link label to show to/cc/bcc of the curent message [CHAR LIMIT=32] -->
    <string name="message_view_show_details">Show details</string>
    <!-- Title of the dialog box to show to/cc/bcc of the message.  [CHAR LIMIT=32] -->
    <string name="message_view_message_details_dialog_title">Message details</string>

    <!-- Title for most attachment info dialogs [CHAR LIMIT=32] -->
    <string name="attachment_info_dialog_default_title">Attachment info</string>
    <!-- Title when Wi-Fi settings prevent attachments from downloading [CHAR LIMIT=32] -->
    <string name="attachment_info_dialog_wifi_title">Wi-Fi connection required</string>
    <!-- Text of button to launch the Wi-Fi settings activity [CHAR LIMIT=24] -->
    <string name="attachment_info_wifi_settings">Wi-Fi settings</string>
    <!-- Text of button to launch the application settings activity [CHAR LIMIT=24] -->
    <string name="attachment_info_application_settings">App settings</string>
    <!-- Message body when we don't know exactly why an attachment can't be shown -->
    <string name="attachment_info_unknown">Can\'t open attachment.</string>
    <!-- Message body when the attachment is suspected of being malware -->
    <string name="attachment_info_malware">
            You can\'t save or open this file because this type of attachment
            might contain malicious software.</string>
    <!-- Message body when the attachment can't be loaded due to security policy restrictions -->
    <string name="attachment_info_policy">
            This attachment can\'t be saved or opened because of
            this account\'s security policies.</string>
    <!-- Message body when the attachment can only be downloaded over Wi-Fi -->
    <string name="attachment_info_wifi_only">
            This attachment is too large to download over a mobile network.
            You can download it the next time you connect to a Wi-Fi network.</string>
    <!-- Message body when no activities can open the attachment -->
    <string name="attachment_info_no_intent">
            There is no installed app that can open this attachment.
            Try downloading an appropriate app from Android Market.</string>
    <!-- Message body when the attachment is an application, but, side loading is disabled -->
    <string name="attachment_info_sideload_disabled">
            This attachment is an app. You must check Unknown Sources
            in Settings &gt; Apps before you can install it.</string>
    <!-- Message body when the attachment is an application, and side loading is enabled -->
    <string name="attachment_info_apk_install_disabled">
            Apps can\'t be installed directly from email. First save
            this app and then install it using the Downloads app.</string>
    <!-- Error banner when an attachment could not be downloaded due to a problem at the server
            [CHAR LIMIT=100] -->
    <string name="attachment_not_found">Couldn\'t download the attachment.</string>

    <!-- String used in place of a message that could not be properly decoded (e.g. bad base64
         data was received.) [CHAR LIMIT=none] -->
    <string name="message_decode_error">There was an error while decoding the message.</string>

    <!-- Title of the EML viewer activity. [CHAR LIMIT=32] -->
    <string name="eml_view_title">Viewing
            <xliff:g id="filename" example="test.eml">%s</xliff:g></string>

    <string name="message_delete_dialog_title"></string>
    <!--Confirmation dialog text shown when user tries to delete messages.  [CHAR LIMIT=32] -->
    <plurals name="message_delete_confirm">
        <item quantity="one">Delete this message?</item>
        <item quantity="other">Delete these messages?</item>
    </plurals>
    <!-- Toast shown briefly while deleting a message -->
    <plurals name="message_deleted_toast">
        <item quantity="one">Message deleted.</item>
        <item quantity="other">Messages deleted.</item>
    </plurals>
    <!-- Toast shown briefly while deleting an unsent (draft) message -->
    <string name="message_discarded_toast">Message discarded.</string>
    <!-- Toast shown briefly while saving a draft -->
    <string name="message_saved_toast">Message saved as draft.</string>
    <!-- String that is displayed when the attachment could not be displayed. -->
    <string name="message_view_display_attachment_toast">Can\'t display
        attachment.</string>
    <!-- String that is displayed when the attachment could not be loaded.[CHAR LIMIT=none] -->
    <string name="message_view_load_attachment_failed_toast">Couldn\'t load attachment \"
        <xliff:g id="filename">%s</xliff:g>\".</string>
    <!-- String that is displayed when a long message is being parsed. [CHAR LIMIT=none] -->
    <string name="message_view_parse_message_toast">Opening message\u2026</string>
    <!-- Toast shown after moving a message to a different mailbox. [CHAR LIMIT=none]-->
    <plurals name="message_moved_toast">
        <item quantity="one"  ><xliff:g id="num_message" example="1" >%1$d</xliff:g>
        message moved to <xliff:g id="mailbox_name" example="Inbox" >%2$s</xliff:g></item>
        <item quantity="other"  ><xliff:g id="num_message" example="5" >%1$d</xliff:g>
        messages moved to <xliff:g id="mailbox_name" example="Inbox" >%2$s</xliff:g></item>
    </plurals>

    <!-- Notification ticker when a forwarded attachment couldn't be sent [CHAR LIMIT=none] -->
    <string name="forward_download_failed_ticker">Couldn\'t forward one or more attachments.</string>
    <!-- Notification title when a forwarded attachment couldn't be sent [CHAR LIMIT=30]-->
    <string name="forward_download_failed_title">Attachment not forwarded</string>

    <!-- Notification ticker when email account authentication fails [CHAR LIMIT=none] -->
    <string name="login_failed_ticker">
        <xliff:g id="account_name">%s</xliff:g> signin failed.</string>
    <!-- Notification title when email account authentication fails [CHAR LIMIT=30]-->
    <string name="login_failed_title">Couldn\'t sign in</string>

    <!-- Size unit for bytes for attachments [CHAR LIMIT=10] -->
    <plurals name="message_view_attachment_bytes">
        <item quantity="one"  ><xliff:g id="size_in_bytes" example="1"  >%d</xliff:g>B</item>
        <item quantity="other"><xliff:g id="size_in_bytes" example="279">%d</xliff:g>B</item>
    </plurals>
    <!-- Size unit for kilo bytes for attachments [CHAR LIMIT=10] -->
    <plurals name="message_view_attachment_kilobytes">
        <item quantity="one"  ><xliff:g id="size_in_kilobytes" example="1"  >%d</xliff:g>KB</item>
        <item quantity="other"><xliff:g id="size_in_kilobytes" example="279">%d</xliff:g>KB</item>
    </plurals>
    <!-- Size unit for mega bytes for attachments [CHAR LIMIT=10] -->
    <plurals name="message_view_attachment_megabytes">
        <item quantity="one"  ><xliff:g id="size_in_megabytes" example="1"  >%d</xliff:g>MB</item>
        <item quantity="other"><xliff:g id="size_in_megabytes" example="279">%d</xliff:g>MB</item>
    </plurals>
    <!-- Size unit for giga bytes for attachments [CHAR LIMIT=10] -->
    <plurals name="message_view_attachment_gigabytes">
        <item quantity="one"  ><xliff:g id="size_in_gigabytes" example="1"  >%d</xliff:g>GB</item>
        <item quantity="other"><xliff:g id="size_in_gigabytes" example="279">%d</xliff:g>GB</item>
    </plurals>

    <!-- The label of the next button on the message view screen. -->
    <string name="message_view_move_to_newer">Newer</string>
    <!-- The label of the previous button on the message view screen. -->
    <string name="message_view_move_to_older">Older</string>

    <!-- A simple divider between subject and message snippet in the message list view
        [CHAR LIMIT=4]-->
    <string name="message_list_subject_snippet_divider">\u0020\u2014\u0020</string>

    <!-- Title of screen when setting up new email account [CHAR LIMIT=45] -->
    <string name="account_setup_basics_title">Account setup</string>
    <!-- Title of the screen when adding exchange account [CHAR LIMIT=45] -->
    <string name="account_setup_basics_exchange_title">
        Add an Exchange account</string>
    <!-- Title of the screen when adding exchange account [CHAR LIMIT=45] -->
    <string name="account_setup_basics_exchange_title_alternate">
        Add an Exchange ActiveSync account</string>
    <!-- Headline of screen when setting up new email account (large text over divider)
        [CHAR LIMIT=none] -->
    <string name="account_setup_basics_headline">Email account</string>
    <!-- On "Set up email" screen, enthusiastic welcome message. -->
    <string name="accounts_welcome">You can set up email for most accounts in just a few steps.
        </string>
    <!-- On "Set up email" screen, enthusiastic welcome message (in EAS mode). -->
    <string name="accounts_welcome_exchange">You can set up an Exchange account in just a few
        steps.</string>
    <!-- On "Set up email" screen, enthusiastic welcome message (in EAS mode). -->
    <string name="accounts_welcome_exchange_alternate">
        You can set up an Exchange ActiveSync account in just a few steps.</string>
    <!-- On "Set up email" screen, hint for account email address text field -->
    <string name="account_setup_basics_email_label">Email address</string>
    <!-- On "Set up email" screen, hint for account email password text field -->
    <string name="account_setup_basics_password_label">Password</string>
    <!-- On "Set up email" screen, checkbox label for making the new account the default account -->
    <string name="account_setup_basics_default_label">
        Send email from this account by default.</string>
    <!-- Button name on "Set up email" screen -->
    <string name="account_setup_basics_manual_setup_action">Manual setup</string>
    <!-- Toast when we can't build a URI from the given email & password -->
    <!-- Note, the error message in the toast is purposefully vague, because I *don't* know
        exactly what's wrong. -->
    <string name="account_setup_username_password_toast">
        Type a valid email address and password.</string>
    <!-- Title of dialog shown when a duplicate account is created -->
    <string name="account_duplicate_dlg_title">Duplicate account</string>
    <!-- Message of dialog shown when a duplicate account is created.  The display name of
         the duplicate account is displayed. -->
    <string name="account_duplicate_dlg_message_fmt">
        You\'re already using this username for the account \"<xliff:g id="duplicate">%s</xliff:g>\".
    </string>
    <!-- String that is displayed as error text for passwords with leading or trailing
         spaces.  [CHAR LIMIT=none] -->
    <string name="account_password_spaces_error">This password starts or ends with one or more
        space characters. Many servers don\'t support passwords with spaces.</string>

    <!-- On check-settings screen, this is the initially-displayed message. -->
    <string name="account_setup_check_settings_retr_info_msg">
    Retrieving account information\u2026</string>
    <!-- Appears on screen while system is checking incoming server settings -->
    <string name="account_setup_check_settings_check_incoming_msg">
    Checking incoming server settings\u2026</string>
    <!-- Appears on screen while system is checking outgoing server settings -->
    <string name="account_setup_check_settings_check_outgoing_msg">
    Checking outgoing server settings\u2026</string>

    <!-- Title of "Set up email" screen after success [CHAR LIMIT=45] -->
    <string name="account_setup_names_title">Account setup</string>
    <!-- Text that appears on "Set up email" screen after successfully setting up an account
        [CHAR LIMIT=none] -->
    <string name="account_setup_names_headline">
        Your account is set up, and email is on its way!</string>
    <!-- On "Set up email" screen, label of text field -->
    <string name="account_setup_names_account_name_label">
        Give this account a name (optional)</string>
    <!-- On "Set up email" screen, label of text field -->
    <string name="account_setup_names_user_name_label">
        Your name (displayed on outgoing messages)</string>
    <!-- On "Set up email" screen, error pop-up when user_name field is empty [CHAR LIMIT=none] -->
    <string name="account_setup_names_user_name_empty_error">This field can\'t be blank.</string>

    <!-- Activity Title for the account type selector (IMAP or POP3 or EAS) [CHAR LIMIT=45] -->
    <string name="account_setup_account_type_title">Account setup</string>
    <!-- Headline for the the account type selector (IMAP or POP3 or EAS) [CHAR LIMIT=none] -->
    <string name="account_setup_account_type_headline">Account type</string>
    <!-- "Add new email account" screen, text that appears on screen -->
    <string name="account_setup_account_type_instructions">What type of account is this?</string>

    <!-- Do Not Translate. "Add new email account" screen, button name in response to what
         type of account this is -->
    <string name="account_setup_account_type_pop_action" translatable="false">POP3</string>
    <!-- Do Not Translate. "Add new email account" screen, button name in response to what
         type of account this is -->
    <string name="account_setup_account_type_imap_action" translatable="false">IMAP</string>
    <!-- Do Not Translate. "Add new email account" screen, button name in response to what
         type of account this is -->
    <string name="account_setup_account_type_exchange_action" translatable="false">Exchange</string>
    <!-- Do Not Translate. "Add new email account" screen, button name in
         response to what type of account this is -->
    <string name="account_setup_account_type_exchange_action_alternate"
         translatable="false">Microsoft Exchange ActiveSync</string>

    <!-- "Incoming server settings" screen, title [CHAR LIMIT=45] -->
    <string name="account_setup_incoming_title">Account setup</string>
    <!-- "Incoming server settings" screen, headline (text over divider) [CHAR LIMIT=none] -->
    <string name="account_setup_incoming_headline">Incoming server settings</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_username_label">Username</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_password_label">Password</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_pop_server_label">POP3 server</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_imap_server_label">IMAP server</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_incoming_port_label">Port</string>
    <!-- "Incoming server settings" screen, label for pop-up menu -->
    <string name="account_setup_incoming_security_label">Security type</string>
    <!-- "Incoming server settings" screen, option for "Security type" pop-up menu indicating
        the desire for an unencrypted session -->
    <string name="account_setup_incoming_security_none_label">None</string>
    <!-- "Incoming server settings" screen, option for "Security type" pop-up menu indicating
        the desire for an encrypted session on the selected port, accepting all SSL certificates -->
    <string name="account_setup_incoming_security_ssl_trust_certificates_label">
        SSL/TLS (Accept all certificates)</string>
    <!-- "Incoming server settings" screen, option for "Security type" pop-up menu indicating
        the desire for an encrypted session on the selected port, including SSL certificate
        checks -->
    <string name="account_setup_incoming_security_ssl_label">SSL/TLS</string>
    <!-- "Incoming server settings" screen, option for "Security type" pop-up menu indicating
        the desire for an encrypted session overlaid on a plain text session using the selected
        port, accepting all SSL certificates -->
    <string name="account_setup_incoming_security_tls_trust_certificates_label">
        STARTTLS (accept all certificates)</string>
    <!-- "Incoming server settings" screen, option for "Security type" pop-up menu indicating
        the desire for an encrypted session overlaid on a plain text session on the selected
        port, including SSL certificate checks -->
    <string name="account_setup_incoming_security_tls_label">STARTTLS</string>
    <!-- "Incoming server settings" screen, label for pop-up menu -->
    <string name="account_setup_incoming_delete_policy_label">Delete email from server</string>
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <string name="account_setup_incoming_delete_policy_never_label">Never</string>
    <!-- "Incoming server settings" screen, options in pop-up menu for Delete email from server: -->
    <string name="account_setup_incoming_delete_policy_delete_label">
        When I delete from Inbox</string>
    <!-- "Incoming server settings" screen, label for setting IMAP path prefix: -->
    <string name="account_setup_incoming_imap_path_prefix_label">IMAP path prefix</string>
    <!-- "Incoming server settings" screen, hint for setting IMAP path prefix: -->
    <string name="account_setup_incoming_imap_path_prefix_hint">Optional</string>

    <!-- "Outgoing server settings" screen, title [CHAR LIMIT=45] -->
    <string name="account_setup_outgoing_title">Account setup</string>
    <!-- "Outgoing server settings" screen, headline (text over divider) [CHAR LIMIT=none] -->
    <string name="account_setup_outgoing_headline">Outgoing server settings</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_smtp_server_label">SMTP server</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_port_label">Port</string>
    <!-- On "Outgoing server settings" screen, label for pop-up menu -->
    <string name="account_setup_outgoing_security_label">Security type</string>
    <!-- On "Outgoing server settings" screen, label for check box -->
    <string name="account_setup_outgoing_require_login_label">Require sign-in.</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_username_label">Username</string>
    <!-- On "Outgoing server settings" screen, label for text field -->
    <string name="account_setup_outgoing_password_label">Password</string>

    <!-- Title of "Exchange server settings" screen [CHAR LIMIT=45] -->
    <string name="account_setup_exchange_title">Account setup</string>
    <!-- Headline of "Exchange server settings" screen (text over divider) [CHAR LIMIT=none] -->
    <string name="account_setup_exchange_headline">Server settings</string>
    <!-- On "Exchange" setup screen, the name of the server -->
    <string name="account_setup_exchange_server_label">Server</string>
    <!-- On "Exchange" setup screen, the domain\\username -->
    <string name="account_setup_exchange_username_label">Domain\\Username</string>
    <!-- On "Exchange" setup screen, the use-SSL checkbox label -->
    <string name="account_setup_exchange_ssl_label">Use secure connection (SSL)</string>
    <!-- On "Exchange" setup screen, the trust ssl certificates checkbox label -->
    <string name="account_setup_exchange_trust_certificates_label">Accept all SSL certificates</string>
    <!-- On "Exchange" setup screen, a heading title for the current client certificate [CHAR LIMIT=50] -->
    <string name="account_setup_exchange_certificate_title">Client certificate</string>
    <!-- On "Exchange" setup screen, a button label to include a client certificate [CHAR LIMIT=35] -->
    <string name="account_setup_exchange_select_certificate">Select</string>
    <!-- On "Exchange" setup screen, a button label to include a client certificate [CHAR LIMIT=35] -->
    <string name="account_setup_exchange_use_certificate">Use client certificate</string>
    <!-- On "Exchange" setup screen, a button label to remove the currently used client certificate [CHAR LIMIT=35] -->
    <string name="account_setup_exchange_remove_certificate">Remove</string>
    <!-- On "Exchange" setup screen, placeholder text to indicate no client
         certificate is used [CHAR LIMIT=50] -->
    <string name="account_setup_exchange_no_certificate">None</string>
    <!-- On "Exchange" setup screen, the exchange device-id label [CHAR LIMIT=30] -->
    <string name="account_setup_exchange_device_id_label">Mobile Device ID</string>

    <!-- In Account setup options screen, Activity title [CHAR LIMIT=45] -->
    <string name="account_setup_options_title">Account settings</string>
    <!-- In Account setup options screen, Activity headline [CHAR LIMIT=none] -->
    <string name="account_setup_options_headline">Account options</string>
    <!-- In Account setup options screen, label for email check frequency selector -->
    <string name="account_setup_options_mail_check_frequency_label">Inbox checking frequency</string>
    <!-- In Account setup options & Account Settings screens, label for email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_never">Never</string>
    <!-- In Account setup options & Account Settings screens, label for email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_push">Automatic (Push)</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_5min">Every 5 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_10min">Every 10 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_15min">Every 15 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_30min">Every 30 minutes</string>
    <!-- In Account setup options & Account Settings screens, email check frequency option -->
    <string name="account_setup_options_mail_check_frequency_1hour">Every hour</string>
    <!-- Check box label on "Set up email" screen to make this the default account -->
    <!-- Note, this should usually match the default account summary preference string -->
    <string name="account_setup_options_default_label">Send email from this account by default.</string>
    <!-- In Account setup options & Account Settings screens, check box for new-mail notification -->
    <string name="account_setup_options_notify_label">Notify me when email arrives.</string>
    <!-- In Account setup options screen, optional check box to also sync contacts -->
    <string name="account_setup_options_sync_contacts_label">Sync contacts from this account.
    </string>
    <!-- In Account setup options screen, optional check box to also sync contacts -->
    <string name="account_setup_options_sync_calendar_label">Sync calendar from this account.
    </string>
    <!-- In Account setup options screen, check box to sync email -->
    <string name="account_setup_options_sync_email_label">Sync email from this account.
    </string>
    <!-- In Account setup options screen, check box to auto-download attachments  [CHAR LIMIT=none]
        -->
    <string name="account_setup_options_background_attachments_label">
        Automatically download attachments when connected to Wi-Fi</string>
    <!-- Dialog title when "setup" could not finish -->
    <string name="account_setup_failed_dlg_title">Couldn\'t finish</string>
    <!-- In Account setup options screen, label for email lookback selector -->
    <string name="account_setup_options_mail_window_label">Days to sync</string>
    <!-- In account setup options & account settings screens (exchange), sync window length; this
        implies loading a 'reasonable' number of messages [CHAR LIMIT=25] -->
    <string name="account_setup_options_mail_window_auto">Automatic</string>
    <!-- A sync window length setting (i.e. load messages this far back) [CHAR LIMIT=25]  -->
    <string name="account_setup_options_mail_window_1day">One day</string>
    <!-- A sync window length setting (i.e. load messages this far back) [CHAR LIMIT=25]  -->
    <string name="account_setup_options_mail_window_3days">Three days</string>
    <!-- A sync window length setting (i.e. load messages this far back) [CHAR LIMIT=25]  -->
    <string name="account_setup_options_mail_window_1week">One week</string>
    <!-- A sync window length setting (i.e. load messages this far back) [CHAR LIMIT=25]  -->
    <string name="account_setup_options_mail_window_2weeks">Two weeks</string>
    <!-- A sync window length setting (i.e. load messages this far back) [CHAR LIMIT=25]  -->
    <string name="account_setup_options_mail_window_1month">One month</string>
    <!-- A sync window length setting (i.e. load messages this far back) [CHAR LIMIT=25]  -->
    <string name="account_setup_options_mail_window_all">All</string>
    <!-- Per-mailbox sync window setting.  This means "use the account's sync window setting" [CHAR LIMIT=25] -->
    <string name="account_setup_options_mail_window_default">Use account\'s default</string>

    <!-- "Setup could not finish" dialog text; e.g., Username or password incorrect -->
    <string name="account_setup_failed_dlg_auth_message">Username or password incorrect.</string>
    <!-- "Setup could not finish" dialog text; e.g., Username or password incorrect\n(ERR01 Account does not exist) -->
    <string name="account_setup_failed_dlg_auth_message_fmt">Username or password incorrect.\n(<xliff:g id="error">%s</xliff:g>)</string>

    <!-- An error message presented to the user when the server's identity
         cannot be established or trusted [CHAR LIMIT=NONE] -->
    <string name="account_setup_failed_dlg_certificate_message"
        >Can\'t safely connect to server.</string>
    <!-- An error message presented to the user when the server's identity
         cannot be established or trusted [CHAR LIMIT=NONE] -->
    <string name="account_setup_failed_dlg_certificate_message_fmt"
        >Can\'t safely connect to server.\n(<xliff:g id="error">%s</xliff:g>)</string>
    <!-- An error message presented to the user when the server requires a
         client certificate to connect [CHAR LIMIT=NONE] -->
    <string name="account_setup_failed_certificate_required"
        >Client certificate is required. Connect to server with client certificate?</string>
    <!-- An error message presented to the user when the certificate they
         specified for connecting to a server is inaccessible [CHAR LIMIT=NONE] -->
    <string name="account_setup_failed_certificate_inaccessible"
        >Certificate is invalid or inaccessible.</string>

    <!-- Dialog text for ambiguous setup failure; server error/bad credentials [CHAR LIMIT=none] -->
    <string name="account_setup_failed_check_credentials_message">
         The server responded with an error. Check your username and password
         then try again.</string>

    <!-- "Setup could not finish" dialog text; e.g., Cannot connect to server -->
    <string name="account_setup_failed_dlg_server_message">Can\'t connect to server.</string>
    <!-- "Setup could not finish" dialog text; e.g., Cannot connect to server\n(Connection timed out) -->
    <string name="account_setup_failed_dlg_server_message_fmt">Can\'t connect to server.\n(<xliff:g id="error">%s</xliff:g>)</string>

    <!-- Additional diagnostic text when TLS was required but the server doesn't support it -->
    <string name="account_setup_failed_tls_required">TLS required but not supported by server.</string>
    <!-- Additional diagnostic text when server does not support any of our authentication methods -->
    <string name="account_setup_failed_auth_required">Authentication methods aren\'t supported by server.</string>
    <!-- Additional diagnostic text when server connection failed due to security error -->
    <string name="account_setup_failed_security">Couldn\'t open connection to server due to security error.</string>
    <!-- Additional diagnostic text when server connection failed due to io error (connection) -->
    <string name="account_setup_failed_ioerror">Couldn\'t open connection to server.</string>
    <!-- Additional diagnostic text when server connection failed due to our inability to support a
         required EAS protocol version [CHAR LIMIT=none] -->
    <string name="account_setup_failed_protocol_unsupported">
         You typed an incorrect server address or the server requires a protocol version that
         Email doesn\'t support.</string>
    <!-- Additional diagnostic text when server access was denied; the user should contact the
         administrator of the server for more information [CHAR LIMIT=none] -->
    <string name="account_setup_failed_access_denied">
         You don\'t have permission to sync with this server. Contact your server\'s
         administrator for more information.</string>

    <!-- Dialog title when validation requires security provisioning (e.g. support
         for device lock PIN, or remote wipe.) and we ask the user permission before continuing -->
    <string name="account_setup_security_required_title">Remote security administration</string>
    <!-- Additional diagnostic text when validation requires security provisioning (e.g. support
         for device lock PIN, or remote wipe.) and we ask the user permission before continuing.
         [CHAR LIMIT=none] -->
    <string name="account_setup_security_policies_required_fmt">
         The server <xliff:g id="server">%s</xliff:g> requires that you allow it to remotely control
         some security features of your Android device.  Do you want to finish setting up this
         account?</string>
    <!-- Additional diagnostic text when validation failed due to required provisioning not
         being supported [CHAR LIMIT=none] -->
    <string name="account_setup_failed_security_policies_unsupported">
         This server requires security features that your Android device doesn\'t support,
          including: <xliff:g id="error">%s</xliff:g></string>
    <!-- The user name can only be changed during initial account setup. [CHAR LIMIT=none] -->
    <string name="account_setup_username_uneditable_error">You can\'t change an account\'s username.
         To add an account with a different username, touch Add Account.</string>
    <!-- Warning given to users when they request disabling device administration (i.e. that their
         administered accounts will be deleted) [CHAR LIMIT=none] -->
    <string name="disable_admin_warning">WARNING: Deactivating the Email app\'s authority
         to administer your device will delete all email accounts that require it, along with their
         email, contacts, calendar events, and other data.</string>

    <!-- Dialog shown when the account requires some amount of device security provisioning,
         just before jumping into system settings such as Device Policy grant, PIN/password,
         or encryption setup.  [CHAR_LIMIT=40] -->
    <string name="account_security_dialog_title">Security update</string>
    <!-- Additional diagnostic text when the account requires some amount of device security
         provisioning, just before jumping into system settings such as Device Policy grant,
         PIN/password, or encryption setup.  [CHAR LIMIT=none] -->
    <string name="account_security_dialog_content_fmt">
         <xliff:g id="account">%s</xliff:g> requires that you update your security settings.</string>

    <!-- Notification ticker when device security required (note: unused in Holo XL) -->
    <string name="security_notification_ticker_fmt">
            Account \"<xliff:g id="account">%s</xliff:g>\" requires security settings update.
    </string>
    <!-- Notification content title when device security required [CHAR_LIMIT=30] -->
    <string name="security_notification_content_title">Security update required</string>
    <!-- Title of the activity that dispatches changes to device security.  Not normally seen. -->
    <string name="account_security_title">Device security</string>
    <!-- Additional diagnostic text when the email app asserts control of the phone.
        [CHAR LIMIT=none] -->
    <string name="account_security_policy_explanation_fmt">
         The server <xliff:g id="server">%s</xliff:g> requires that you allow it to remotely control
         some security features of your Android device.</string>

    <!-- "Setup could not finish" dialog action button -->
    <string name="account_setup_failed_dlg_edit_details_action">Edit details</string>

    <!-- Notification ticker when device password is getting ready to expire [CHAR_LIMIT=80] -->
    <string name="password_expire_warning_ticker_fmt">
            \"<xliff:g id="account">%s</xliff:g>\" requires that you change your lock screen
            PIN or password.</string>
    <!-- Notification content title when device password is getting ready to expire
            [CHAR_LIMIT=30] -->
    <string name="password_expire_warning_content_title">Lock screen password expiring</string>

    <!-- Notification ticker when device password has expired [CHAR_LIMIT=80] -->
    <string name="password_expired_ticker">Your lock screen PIN or password has expired.</string>
    <!-- Notification content title when device password has expired [CHAR_LIMIT=28] -->
    <string name="password_expired_content_title">Lock screen password expired</string>

    <!-- Dialog title if device pin/password is going to expire soon. [CHAR_LIMIT=40] -->
    <string name="password_expire_warning_dialog_title">Lock screen password expiring</string>
    <!-- Dialog content device pin/password is going to expire soon. [CHAR_LIMIT=none] -->
    <string name="password_expire_warning_dialog_content_fmt">
         You must change your lock screen PIN or password soon, or the data for
         <xliff:g id="account">%s</xliff:g> will be erased. Change it now?</string>

    <!-- Dialog title if device pin/password has already expired. [CHAR_LIMIT=40] -->
    <string name="password_expired_dialog_title">Lock screen password expired</string>
    <!-- Dialog content device pin/password has already expired. [CHAR_LIMIT=none] -->
    <string name="password_expired_dialog_content_fmt">
         The data for <xliff:g id="account">%s</xliff:g> is being erased from your device.
         You can restore it by changing your lock screen PIN or password. Change it now?</string>

    <!-- On AccountSettingsXL, dialog text if you try to exit in/out/eas fragment (server settings)
         without checking/saving [CHAR LIMIT=none]-->
    <string name="account_settings_exit_server_settings">Discard unsaved changes?</string>

    <!-- On AccountSettingsXL, dialog title if you were brought here due to a login failure.
        [CHAR_LIMIT=40] -->
    <string name="account_settings_login_dialog_title">Couldn\'t sign in</string>
    <!-- On AccountSettingsXL, dialog content if you were brought here due to a login failure.
        [CHAR_LIMIT=none] -->
    <string name="account_settings_login_dialog_content_fmt">
         The username or password for <xliff:g id="account">%s</xliff:g> is incorrect.
         Update them now?</string>

    <!-- On Settings screen, setting option name -->
    <string name="account_settings_default_label">Default account</string>
    <!-- Check box "summary" label on "Account options" screen to make this the default account -->
    <!-- Note, this should usually match the default account account setup checkbox string -->
    <string name="account_settings_default_summary">Send email from this account by default</string>
    <!-- On Settings screen, setting option name -->
    <!-- Title of account preference for downloading attachments in background [CHAR LIMIT=32] -->
    <string name="account_settings_background_attachments_label">
        Download attachments</string>
    <!-- Summary of account preference for downloading attachments in background [CHAR LIMIT=64] -->
    <string name="account_settings_background_attachments_summary">
        Auto-download attachments to recent messages via Wi-Fi</string>
    <string name="account_settings_notify_label">Email notifications</string>
    <!-- On Settings screen, summary line when called via AccountManager for Exchange accounts
        [CHAR LIMIT=50] -->
    <string name="account_settings_summary">Sync frequency, notifications, etc.</string>
    <!-- On Settings screen, setting summary text -->
    <string name="account_settings_notify_summary">Notify in System bar when email arrives</string>
    <!-- On Settings screen, setting option name and title of dialog box that opens -->
    <string name="account_settings_mail_check_frequency_label">Inbox check frequency</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_incoming_label">Incoming settings</string>
   <!-- On Settings screen, setting option summary [CHAR LIMIT=64] -->
    <string name="account_settings_incoming_summary">
        Username, password, and other incoming server settings</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_outgoing_label">Outgoing settings</string>
   <!-- On Settings screen, setting option summary [CHAR LIMIT=64] -->
    <string name="account_settings_outgoing_summary">
        Username, password, and other outgoing server settings</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_description_label">Account name</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_name_label">Your name</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_signature_label">Signature</string>
    <!-- On Settings screen, setting option name. Allows user to modify saved quick responses
        for insertion in message body. [CHAR_LIMIT=24]-->
    <string name="account_settings_edit_quick_responses_label">Quick responses</string>
    <!-- On Settings screen, setting option summary [CHAR LIMIT=64] -->
    <string name="account_settings_edit_quick_responses_summary">
        Edit text that you frequently insert when composing emails</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_signature_hint">Append text to messages you send</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_notifications">Notification settings</string>
    <!-- On Settings screen, section heading for data usage [CHAR LIMIT=70] -->
    <string name="account_settings_data_usage">Data usage</string>

    <!-- On settings screen, dialog heading informing user to edit a quick response -->
    <string name="edit_quick_response_dialog">Edit quick response</string>
    <!-- On settings screen, edit quick response dialog's "save" button -->
    <string name="save_action">Save</string>

    <!-- On settings screen, sync contacts check box label [CHAR LIMIT=20]-->
    <string name="account_settings_sync_contacts_enable">Sync contacts</string>
    <!-- On settings screen, sync contacts summary text [CHAR LIMIT=35] -->
    <string name="account_settings_sync_contacts_summary">Sync contacts for this account</string>
    <!-- On settings screen, sync calendar check box label [CHAR LIMIT=20]-->
        <string name="account_settings_sync_calendar_enable">Sync Calendar</string>
    <!-- On settings screen, sync calendar summary text [CHAR LIMIT=35] -->
    <string name="account_settings_sync_calendar_summary">Sync calendar for this account</string>
    <!-- On settings screen, sync email check box label [CHAR LIMIT=20]-->
    <string name="account_settings_sync_email_enable">Sync email</string>
    <!-- On settings screen, sync email summary text [CHAR LIMIT=35] -->
    <string name="account_settings_sync_email_summary">Sync email for this account</string>

    <!-- On Settings screen, vibrate pop-up menu label -->
    <string name="account_settings_vibrate_when_label">Vibrate</string>
    <!-- On Settings screen, vibrate pop-up menu summary text -->
    <string name="account_settings_vibrate_when_summary">Also vibrate when email arrives</string>
    <!-- On Settings screen, vibrate pop-up menu option "always" text -->
    <string name="account_settings_vibrate_when_always">Always</string>
    <!-- On Settings screen, vibrate pop-up menu option "silent" text -->
    <string name="account_settings_vibrate_when_silent">Only when silent</string>
    <!-- On Settings screen, vibrate pop-up menu option "never" text -->
    <string name="account_settings_vibrate_when_never">Never</string>

    <!-- Dialog title for the Vibrate dialog -->
    <string name="account_settings_vibrate_when_dlg_title">Vibrate</string>

    <!-- On Settings screen, setting option name -->
    <string name="account_settings_ringtone">Choose ringtone</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_servers">Server settings</string>
    <!-- Title of Remove account confirmation dialog box -->
    <string name="account_delete_dlg_title">Remove account</string>
    <!-- Message of Remove account confirmation dialog box -->
    <string name="account_delete_dlg_instructions_fmt">
    The account \"<xliff:g id="account">%s</xliff:g>\" will be removed from Email.</string>

    <!-- On Settings screen, section heading for delete account [CHAR LIMIT=none] -->
    <string name="account_settings_category_delete_account">Remove account</string>
    <!-- On Settings screen, settings option for delete account [CHAR LIMIT=none] -->
    <string name="account_settings_delete_account_label">Remove account</string>

    <!-- Mailbox settings activity title [CHAR LIMIT=none] -->
    <string name="mailbox_settings_activity_title">Sync options</string>
    <!-- Mailbox settings activity title, with the target folder name [CHAR LIMIT=none] -->
    <string name="mailbox_settings_activity_title_with_mailbox">Sync options (<xliff:g id="mailboxx_name" example="Family">%s</xliff:g>)</string>
    <!-- Mailbox "sync settings" preference header [CHAR LIMIT=none] -->
    <string name="mailbox_preferences_header">Sync settings</string>
    <!-- On mailbox settings screen: Mailbox check frequency setting label [CHAR LIMIT=none] -->
    <string name="mailbox_settings_mailbox_check_frequency_label">Check frequency</string>
    <!-- On mailbox settings screen: Mailbox sync window (the number of days to synchronize email for) setting label [CHAR LIMIT=none] -->
    <string name="mailbox_settings_mailbox_sync_window_label">Days to sync</string>

    <!-- Strings used for account shortcut picker -->
    <!-- String displayed in launcher [CHAR_LIMIT=10] -->
    <string name="account_shortcut_picker_name">Email account</string>
    <!-- Title of the account list for the shortcut picker [CHAR_LIMIT=20] -->
    <string name="account_shortcut_picker_title">Choose an account</string>
    <!-- Title of mailbox list for the shortcut picker [CHAR_LIMIT=20] -->
    <string name="mailbox_shortcut_picker_title">Select a folder</string>

    <!-- Toast shown when the selected account no longer exists.  This is used when, for example,
         a shotcut or a widget is stale and points at a deleted account.
         [CHAR_LIMIT=none]-->
    <string name="toast_account_not_found">Account wasn\'t found. It may have been removed.</string>

    <!-- Toast shown when the selected folder no longer exists.  This is used when, for example,
         a shotcut or a widget is stale and points at a deleted folder.
         [CHAR_LIMIT=none]-->
    <string name="toast_mailbox_not_found">Folder wasn\'t found. It may have been removed.</string>

    <!-- Message that appears when adding a Windows Live Hotmail Plus account -->
    <string name="provider_note_live">Only some \"Plus\" accounts include POP access
        allowing this program to connect. If you\'re not able to sign in with
        your correct email address and password, you may not have a paid
        \"Plus\" account. Launch the web browser to gain access to
        these email accounts.</string>
    <!-- Message that appears when adding a T-Online account -->
    <string name="provider_note_t_online">Before setting up this email account, visit the T-Online website and create a password for POP3 email access.</string>

    <!-- Name of Microsoft Exchange account type; used by AccountManager -->
    <string name="exchange_name">Corporate</string>
    <!-- Name of Microsoft Exchange account type; used by AccountManager -->
    <string name="exchange_name_alternate">Microsoft Exchange ActiveSync</string>

    <!-- Message that appears if the AccountManager cannot create the system Account -->
    <string name="system_account_create_failed">Couldn\'t create the account. Try again.</string>

    <!-- Strings that support the DeviceAdmin / DevicePolicyManager API -->
    <!-- Name of the DeviceAdmin (seen in settings & in user confirmation screen) -->
    <string name="device_admin_label">Email</string>
    <!-- Long-form description of the DeviceAdmin (2nd line in settings & in user conf. screen) -->
    <string name="device_admin_description">Enables server-specified security policies</string>

    <!-- Strings used for GAL access -->

    <!-- Displayed in small separator in to/cc/bcc dropdowns, when searching GAL begins.
         Example:  "Searching bigcompany.com..." -->
    <string name="gal_searching_fmt">Searching <xliff:g id="domain">%s</xliff:g>\u2026</string>
    <!-- Displayed in small separator in to/cc/bcc dropdowns, when searching GAL completes,
         and all of the server results are being displayed.  Example:
         "5 results from bigcompany.com..."  -->
    <plurals name="gal_completed_fmt">
        <!-- Case of one result from server. -->
        <item quantity="one"><xliff:g id="results" example="1">%1$d</xliff:g> result
        from <xliff:g id="domain">%2$s</xliff:g></item>

        <!-- Case of multiple results from server -->
        <item quantity="other"><xliff:g id="results" example="20">%1$d</xliff:g> results
        from <xliff:g id="domain">%2$s</xliff:g></item>
    </plurals>

    <!-- Settings activity title [CHAR LIMIT=40]-->
    <string name="settings_activity_title">Settings</string>

    <!-- General Preferences Screen -->
    <!-- Label in preferences header to describe general preferences [CHAR LIMIT=32] -->
    <string name="header_label_general_preferences">General</string>
    <!-- First category in general preferences [CHAR LIMIT=64] -->
    <string name="category_general_preferences">Application</string>

    <!-- General preference: Label of the setting for the direction to move to
         when deleting the current message.
         Options contain "newer message","older message", etc. [CHAR LIMIT=32] -->
    <string name="general_preference_auto_advance_label">Auto-advance</string>
    <!-- General preference: Description of the setting for the direction to move to
         when deleting the current message.
         Options contain "newer message","older message", etc. [CHAR LIMIT=64] -->
    <string name="general_preference_auto_advance_summary">
         Choose which screen to show after you delete a message</string>
    <!-- General preference: Title of the dialog box containing options for setting for
         the direction to move to when deleting the current message.
         Options contain "newer message","older message", etc. [CHAR LIMIT=32] -->
    <string name="general_preference_auto_advance_dialog_title">Advance to</string>
    <!-- General preference: Option for the setting for
         the direction to move to when deleting the current message.
         This option is for "move to the newer message" [CHAR LIMIT=32] -->
    <string name="general_preference_auto_advance_newer">Newer message</string>
    <!-- General preference: Option for the setting for
         the direction to move to when deleting the current message.
         This option is for "move to the older message" [CHAR LIMIT=32] -->
    <string name="general_preference_auto_advance_older">Older message</string>
    <!-- General preference: Option for the setting for
         the direction to move to when deleting the current message.
         This option is for "move back to the message list" [CHAR LIMIT=32] -->
    <string name="general_preference_auto_advance_message_list">Message list</string>

    <!-- General preference: Label of the setting for the text zoom.  [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_label">Message text size</string>
    <!-- General preference: Description of each setting for text zoom.  The entries here must
         correspond to the strings general_preference_text_zoom_tiny,
         general_preference_text_zoom_small, general_preference_text_zoom_normal, etc.
         [CHAR LIMIT=64] -->
    <string-array name="general_preference_text_zoom_summary_array">
        <item>Tiny text</item>
        <item>Small text</item>
        <item>Normal-sized text</item>
        <item>Large text</item>
        <item>Huge text</item>
    </string-array>

    <!-- The message text size values -->
    <string-array translatable="false" name="general_preference_text_zoom_size">
        <item>0.8</item>
        <item>0.9</item>
        <item>1.0</item>
        <item>1.2</item>
        <item>1.5</item>
    </string-array>

    <!-- General preference: Title of the dialog box with options for text zoom. [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_dialog_title">Message text size</string>
    <!-- General preference:  Text zoom.  Value is "tiny" (-2) [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_tiny">Tiny</string>
    <!-- General preference:  Text zoom.  Value is "small" (-1) [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_small">Small</string>
    <!-- General preference:  Text zoom.  Value is "normal" (0) [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_normal">Normal</string>
    <!-- General preference:  Text zoom.  Value is "large" (+1) [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_large">Large</string>
    <!-- General preference:  Text zoom.  Value is "huge" (+2) [CHAR LIMIT=32] -->
    <string name="general_preference_text_zoom_huge">Huge</string>

    <!--  Settings screen, Reply to all default setting title  [CHAR LIMIT=30] -->
    <string msgid="6469564953937885304" name="general_preference_reply_all_label">Reply all</string>
    <!--  Settings screen, Reply to all default setting summary [CHAR LIMIT=70] -->
    <string msgid="3356918650886350497" name="general_preference_reply_all_summary">Make \"Reply all\" the default for message replies</string>

    <!-- Settings screen, title used to clear the setting for the list of
         senders to automatically show pictures for [CHAR LIMIT=80] -->
    <string name="general_preferences_clear_trusted_senders_title"
        >Ask to show pictures</string>
    <!-- Settings screen, summary for clearing the settings for the list of
         senders to automatically show pictures for [CHAR LIMIT=160] -->
    <string name="general_preferences_clear_trusted_senders_summary"
        >Pictures in messages won\'t be shown automatically</string>
    <!-- Message shown in toast when the user taps to clear the lsit of senders
         to automatically show pictures for [CHAR LIMIT=80] -->
    <string name="trusted_senders_cleared">\"Show pictures\" cleared.</string>

    <!-- Generic string for "current position" / "total number" [CHAR LIMIT=12] -->
    <string name="position_of_count"><xliff:g example="1">%1$d</xliff:g> of <xliff:g
            example="12">%2$s</xliff:g></string>

    <!-- Message shown during the first sync after an account is set up.  [CHAR LIMIT=NONE] -->
    <string name="waitinf_for_sync_message_1">Waiting for sync</string>
    <!-- Message shown during the first sync after an account is set up.  [CHAR LIMIT=NONE] -->
    <string name="waitinf_for_sync_message_2">Your email will appear soon.</string>

    <!-- Widget -->
    <!-- Instruction for how to move to different widget views [CHAR LIMIT=20] -->
    <string name="widget_other_views">Touch icon to change.</string>
    <!-- Header for the "Combined Inbox" view (showing mail in all inboxes) [CHAR LIMIT=20] -->
    <string name="widget_all_mail">Combined Inbox</string>
    <!-- Header for the "Unread" widget view (showing all unread mail) [CHAR LIMIT=20] -->
    <string name="widget_unread">Unread</string>
    <!-- Header for the "Starred" widget view (showing all starred mail) [CHAR LIMIT=20] -->
    <string name="widget_starred">Starred</string>
    <!-- Shown when waiting for mail data to be loaded into the widget list view [CHAR LIMIT=20] -->
    <string name="widget_loading">Loading\u2026</string>
    <!-- Shown when no accounts are configured and the widget supports changing
         on the fly [CHAR LIMIT=35] -->
    <string name="widget_touch_to_configure">Touch to set up.</string>
    <!-- Shown in a toast when no accounts are configured and the Email widget
         cannot be created in the first place [CHAR LIMIT=none] -->
    <string name="widget_no_accounts">You haven\'t set up an email account yet.</string>
    <!-- Shown in a toast when no mailboxes have synced for the account and the Email widget
         cannot be created in the first place [CHAR LIMIT=none] -->
    <string name="widget_no_mailboxes">This account isn\'t synced. Try again later.</string>

    <!-- Generic string shown instead of regular numbers, when a number is larger than 999.
         This should not be altered if the original string ("999+") makes sense in the
         target language. Typical alternatives include "+999" and ">999".  [CHAR_LIMIT=4] -->
    <string name="more_than_999">999+</string>

    <!-- The hint used in the search box when searching all mailboxes [CHAR LIMIT=35] -->
    <string name="search_hint">Search email</string>

    <!-- The hint used in the search box when searching a single mailbox [CHAR LIMIT=35] -->
    <string name="search_mailbox_hint">Search <xliff:g example="Inbox">%1$s</xliff:g></string>

    <!-- The title above the messages list when showing search results. [CHAR LIMIT=50] -->
    <string name="search_header_text_fmt"
          >Results</string>

    <!-- A warning title to show to the user when search results are taking a long
         time. [CHAR LIMIT=NONE] -->
    <string name="search_slow_warning_title">Waiting for results</string>

    <!-- A warning message to show to the user when search results are taking a long
         time. [CHAR LIMIT=NONE] -->
    <string name="search_slow_warning_message">Some servers may take a long time.</string>

    <!-- Title shown on the action bar on the mailbox list screen. [CHAR LIMIT=16] -->
    <string name="action_bar_mailbox_list_title">Folders</string>

    <!-- A long placeholder string to be used in template XML files message_list_item_*.xml.
         Used only in layout computation, and never actually exposed to the user. -->
    <string name="long_string" translatable="false">looooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooooong</string>

    <!-- This is the message warning the user that they must sync manually when roaming. [CHAR LIMIT=none]-->
    <string name="require_manual_sync_message">Background sync for this account is disabled while\
     roaming.</string>
</resources>
