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

    <!-- Deprecated strings - Move the identifiers to this section, mark as DO NOT TRANSLATE,
         and remove the actual text.  These will be removed in a bulk operation. -->
    <!-- Do Not Translate.  Unused string. -->
    <string name="account_settings_exchange_summary" translatable="false"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="message_compose_attachments_skipped_toast" translatable="false"></string>
    <!-- Do Not Translate.  Unused string. -->
    <string name="status_loading_more" translatable="false"></string>

    <!-- Messages that are not currently used, but will probably reused in the near future -->
    <!-- STOPSHIP Remove them if they're not used after all -->
    <!-- Appears in message list view of outbox while messages are being sent -->
    <string name="status_sending_messages">Sending messages\u2026</string>
    <!-- Appears at the bottom of list of messages of outbox;
         user selects to send pending messages. -->
    <string name="message_list_send_pending_messages_action">Send outgoing messages</string>
    <!-- Toast while fetching attachment -->
    <string name="message_view_fetching_attachment_toast">Fetching attachment.</string>
    <!-- Appears progress dialog for fetching attachment -->
    <string name="message_view_fetching_attachment_progress">Fetching attachment <xliff:g
        id="filename">%s</xliff:g></string>
    <!-- Permissions label for reading attachments -->
    <string name="read_attachment_label">Read Email attachments</string>
    <!-- Permissions description for reading attachments -->
    <string name="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 />

    <!-- 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>
    <!-- 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>
    <!--  Button name used to complete a multi-step process -->
    <string name="done_action">Done</string>
    <!-- Menu item/button name -->
    <string name="discard_action">Discard</string>
    <!-- Menu item/button name -->
    <string name="save_draft_action">Save as draft</string>
    <!-- Menu item/button name -->
    <string name="read_unread_action">Read/Unread</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="favorite_action">Favorite</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="deselect_all_action">Deselect all</string>
    <!-- Menu item -->
    <string name="compose_action">Compose</string>
    <!-- Menu item/button name -->
    <string name="search_action">Search</string>
    <!-- Menu item/button name -->
    <string name="open_action">Open</string>
    <!-- Menu item -->
    <string name="account_settings_action">Account settings</string>
    <!-- Menu item -->
    <string name="remove_account_action">Remove account</string>
    <!-- Menu item -->
    <string name="folders_action">Folders</string>
    <!-- Menu item -->
    <string name="accounts_action">Accounts</string>
    <!-- Menu item -->
    <string name="mark_as_read_action">Mark as read</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" translatable="false">Move</string>
    <!-- Menu item -->
    <string name="add_cc_bcc_action">Add Cc/Bcc</string>
    <!-- Menu item -->
    <string name="add_attachment_action">Add attachment</string>
    <!-- Menu item (debug screen) -->
    <string name="dump_settings_action">Dump settings</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 -->
    <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 error</string>
    <!-- Notification title in status bar -->
    <string name="notification_new_title">New email</string>
    <!-- Dialog text when we are unable to load the message for display -->
    <string name="error_loading_message_body">Unexpected error while loading message text.  Message
        may be too large to view.</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>

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

    <!-- 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_sensitive_logging_label" translatable="false">Enable sensitive information debug logging? (May show passwords in logs.)</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>

    <!-- The text in the small separator between smart folders and the accounts -->
    <string name="account_folder_list_separator_accounts">Accounts</string>
    <!-- The summary section entry in the AccountFolder list to display all inboxes -->
    <string name="account_folder_list_summary_inbox">Combined Inbox</string>
    <!-- The summary section entry in the AccountFolder list to display all starred -->
    <string name="account_folder_list_summary_starred">All Starred</string>
    <!-- The summary section entry in the AccountFolder list to display all drafts -->
    <string name="account_folder_list_summary_drafts">All Drafts</string>
    <!-- The summary section entry in the AccountFolder list to display all outboxes -->
    <string name="account_folder_list_summary_outbox">Combined Outbox</string>
    <!-- Toast that appears when you select "Refresh" menu option -->
    <string name="account_folder_list_refresh_toast">Please longpress an account to refresh it</string>

    <!-- Title of the screen that shows a list of mailboxes for an account -->
    <string name="mailbox_list_title">Mailbox</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>
    <!-- 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>
    <!-- Hint text in Message composer body field -->
    <string name="message_compose_body_hint">Compose Mail</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">Quoted 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>
    <!-- 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>
    <!-- Button name to view an attachment (in another activity) [CHAR LIMIT=10]-->
    <string name="message_view_attachment_view_action">View</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 save the attachment to SD card [CHAR LIMIT=10]-->
    <string name="message_view_attachment_save_action">Save</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 -->
    <string name="message_view_status_attachment_saved">Attachment saved to SD card as <xliff:g id="filename">%s</xliff:g>.</string>
    <!-- Toast after attachment could not be saved-->
    <string name="message_view_status_attachment_not_saved">Unable to save attachment to SD card.</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>
    <!-- Displayed in message view -->
    <string name="message_view_show_pictures_instructions">Select \"Show pictures\" to display embedded pictures.</string>
    <!-- Button on email opened for reading -->
    <string name="message_view_show_pictures_action">Show pictures</string>
    <!-- Calendar invitation, label of the button to open in calendar -->
    <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 have accepted this invitation</string>
    <!-- Toast shown following a meeting invite reply, maybe -->
    <string name="message_view_invite_toast_maybe">
        You have replied \"maybe\" to this invitation</string>
    <!-- Toast shown following a meeting invite reply, declined -->
    <string name="message_view_invite_toast_no">You have declined this invitation</string>
    <!-- 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">This attachment cannot be
        displayed.</string>
    <!-- String that is displayed when the attachment could not be loaded.[CHAR LIMIT=none] -->
    <string name="message_view_load_attachment_failed_toast">The attachment \"
        <xliff:g id="filename">%s</xliff:g>\" could not be loaded.</string>
    <!-- String that is displayed when a long message is being parsed. -->
    <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">"An attachment couldn't be forwarded"</string>
    <!-- Notification text when a forwarded attachment couldn't be sent -->
    <string name="forward_download_failed_notification">"The attachment "<xliff:g id="filename">%s
        </xliff:g>" couldn't be sent with your outgoing mail because it couldn't be downloaded."
        </string>

    <!-- Size unit for bytes for attachments-->
    <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 -->
    <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 -->
    <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 -->
    <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>

    <!-- Do Not Translate.  The label of the next button on the message view screen. -->
    <string name="message_view_move_to_newer" translatable="false">&lt;</string>
    <!-- Do Not Translate.  The label of the previous button on the message view screen. -->
    <string name="message_view_move_to_older" translatable="false">&gt;</string>

    <!-- The message snippet, of the form subject + separator + start of text  -->
    <string name="message_list_snippet"><xliff:g id="subject" example="Re: Foo">
        %1$s</xliff:g> - <xliff:g id="text" example="Hi, John. Blah...">%2$s</xliff:g></string>

    <!-- Title of screen when setting up new email account -->
    <string name="account_setup_basics_title">Set up email</string>
    <!-- Title of the screen when adding exchange account -->
    <string name="account_setup_basics_exchange_title">
        Add an Exchange account</string>
    <!-- Title of the screen when adding exchange account -->
    <string name="account_setup_basics_exchange_title_alternate">
        Add an Exchange ActiveSync account</string>
    <!-- On "Set up email" screen, enthusiastic welcome message. -->
    <string name="accounts_welcome">You can configure 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 configure 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 configure 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_hint">Email address</string>
    <!-- On "Set up email" screen, hint for account email password text field -->
    <string name="account_setup_basics_password_hint">Password</string>
    <!-- On "Set up email" screen, checkbox label for making this the new account be 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">Please 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">
        This login is already in use for the account \"<xliff:g id="duplicate">%s</xliff:g>\".
    </string>

    <!-- Do Not Translate.  Activity Title for check-settings screen -->
    <string name="account_setup_check_settings_title" translatable="false"></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>
    <!-- On check-settings screen, displayed briefly when user cancels the operation. -->
    <string name="account_setup_check_settings_canceling_msg">Canceling\u2026</string>
    <!-- Title of "Set up email" screen after success -->
    <string name="account_setup_names_title">Set up email</string>
    <!-- Text that appears on top of "Set up email" screen after successfully setting up an account -->
    <string name="account_setup_names_instructions">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>

    <!-- Activity Title for the first screen in manual setup (where you select IMAP or POP3) -->
    <string name="account_setup_account_type_title">Add new email account</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, label for text field -->
    <string name="account_setup_incoming_title">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, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_none_label">None</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_ssl_trust_certificates_label">SSL (Accept all certificates)</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_ssl_label">SSL</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_tls_trust_certificates_label">TLS (Accept all certificates)</string>
    <!-- "Incoming server settings" screen, options for "Security type" pop-up menu -->
    <string name="account_setup_incoming_security_tls_label">TLS</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>
    <!-- Title of "Outgoing server settings" screen -->
    <string name="account_setup_outgoing_title">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 -->
    <string name="account_setup_exchange_title">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, the exchange device-id label -->
    <string name="account_setup_exchange_device_id_label">Mobile Device ID</string>

    <!-- In Account setup options screen, Activity title -->
    <string name="account_setup_options_title">Account options</string>
    <!-- In Account setup options screen, label for email check frequency selector -->
    <string name="account_setup_options_mail_check_frequency_label">Email 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>
    <!-- Dialog title when "setup" could not finish -->
    <string name="account_setup_failed_dlg_title">Setup could not finish</string>
    <!-- In Account setup options screen, label for email check frequency selector -->
    <string name="account_setup_options_mail_window_label">Amount to synchronize</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_1day">One day</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_3days">Three days</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_1week">One week</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_2weeks">Two weeks</string>
    <!-- In account setup options & account settings screens (exchange), sync window length  -->
    <string name="account_setup_options_mail_window_1month">One month</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>

    <!-- "Setup could not finish" dialog text; e.g., Cannot safely connect to server -->
    <string name="account_setup_failed_dlg_certificate_message">Cannot safely connect to server.</string>
    <!-- "Setup could not finish" dialog text; e.g., Cannot safely connect to server\n(TLS Not Supported) -->
    <string name="account_setup_failed_dlg_certificate_message_fmt">Cannot safely connect to server.\n(<xliff:g id="error">%s</xliff:g>)</string>

    <!-- "Setup could not finish" dialog text; e.g., Cannot connect to server -->
    <string name="account_setup_failed_dlg_server_message">Cannot 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">Cannot 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 are not supported by server.</string>
    <!-- Additional diagnostic text when server connection failed due to security error -->
    <string name="account_setup_failed_security">Unable to 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">Unable to open connection to server.</string>
    <!-- Additional diagnostic text when server connection failed due to our inability to support a
         required EAS protocol version -->
    <string name="account_setup_failed_protocol_unsupported">
         You entered an incorrect server address or the server requires a protocol version that
         Email does not support.</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. -->
    <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 phone.  Do you wish to finish setting up this account?
         </string>
    <!-- Additional diagnostic text when validation failed due to required provisioning not
         being supported -->
    <string name="account_setup_failed_security_policies_unsupported">
         This server requires security features your phone does not support.</string>

    <!-- Notification ticker  when device security required -->
    <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 -->
    <string name="security_notification_content_title">Update Security Settings</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. -->
    <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 phone.</string>

    <!-- "Setup could not finish" dialog action button -->
    <string name="account_setup_failed_dlg_edit_details_action">Edit details</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 Settings screen, section heading -->
    <string name="account_settings_title_fmt">General settings</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 -->
    <string name="account_settings_notify_label">Email notifications</string>
    <!-- On Settings screen, summary line when called via AccountManager for Exchange accounts -->
    <string name="account_settings_summary">Sync frequency, notifications, etc.</string>
    <!-- On Settings screen, setting summary text -->
    <string name="account_settings_notify_summary">Notify in status 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">Email check frequency</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_incoming_label">Incoming settings</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_outgoing_label">Outgoing 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 -->
    <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, sync contacts check box label -->
    <string name="account_settings_sync_contacts_enable">Sync Contacts</string>
    <!-- On settings screen, sync contacts summary text -->
    <string name="account_settings_sync_contacts_summary">Sync contacts for this account</string>
    <!-- On settings screen, sync calendar check box label -->
        <string name="account_settings_sync_calendar_enable">Sync Calendar</string>
    <!-- On settings screen, sync calendar summary text -->
    <string name="account_settings_sync_calendar_summary">Sync calendar for this account</string>
    <!-- On settings screen, sync email check box label -->
    <string name="account_settings_sync_email_enable">Sync Email</string>
    <!-- On settings screen, sync email summary text -->
    <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">Select 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>

    <!-- Title of Upgrade Accounts activity -->
    <string name="upgrade_accounts_title">Upgrade accounts</string>
    <string name="upgrade_accounts_error">Unable to upgrade account</string>

    <!-- Message that appears when user adds a Yahoo mail account. This alert has no title. -->
    <string name="provider_note_yahoo">Mailbox access is not supported for some types of
        Yahoo! mail accounts.  If you have trouble connecting, visit yahoo.com for more
        information.</string>
    <!-- Message that appears when user adds a Yahoo UK mail account. -->
    <string name="provider_note_yahoo_uk">Before setting up this email account, please visit the
        Yahoo! web site and enable POP3 email access for this account.</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 are not able to sign in with
        your correct email address and password, you may not have a paid
        \"Plus\" account. Please launch the Web browser to gain access to
        these mail accounts.</string>
    <!-- Message that appears when adding a T-Online account -->
    <string name="provider_note_t_online">Before setting up this email account, please visit the T-Online Web site 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 subject for meeting accepted response.  This will be followed by a colon
         and the title of the meeting (i.e. the title of the meeting becomes part of the subject of
         the message that's sent) -->
    <string name="meeting_accepted">Accepted: <xliff:g id="subject">%s</xliff:g></string>
    <!-- Message subject for meeting declined response. This is followed by a colon
         and the title of the meeting (i.e. the title of the meeting becomes part of the subject of
         the message that's sent) -->
    <string name="meeting_declined">Declined: <xliff:g id="subject">%s</xliff:g></string>
    <!-- Message subject for meeting tentative response.  This is followed by a colon
         and the title of the meeting (i.e. the title of the meeting becomes part of the subject of
         the message that's sent) -->
    <string name="meeting_tentative">Tentative: <xliff:g id="subject">%s</xliff:g></string>
    <!-- Message subject for a canceled meeting email.  This is followed by a colon
         and the title of the meeting (i.e. the title of the meeting becomes part of the subject of
         the message that's sent) -->
    <string name="meeting_canceled">Canceled: <xliff:g id="subject">%s</xliff:g></string>
    <!-- Message subject for an updated meeting email.  This is followed by a colon
         and the title of the meeting (i.e. the title of the meeting becomes part of the subject of
         the message that's sent) -->
    <string name="meeting_updated">Updated: <xliff:g id="subject">%s</xliff:g></string>

    <!-- Indicate when a meeting takes place.  This is presented in in bullet form, as
         in, "When: xxx" followed by "Where: xxx" -->
    <string name="meeting_when">When: <xliff:g id="when">%s</xliff:g></string>
    <!--  Indicate where a meeting takes place.  This is presented in in bullet form, as
         in, "When: xxx" followed by "Where: xxx" -->
    <string name="meeting_where">Where: <xliff:g id="where">%s</xliff:g></string>
    <!--  Indicate that a meeting is recurring.  This would normally be presented after
         "When: xxx", e.g. "When: Tue, Mar 10, 2010 at 2:30pm (recurring)" -->
    <string name="meeting_recurring">When: <xliff:g id="eventdate"
         example="Tue, Mar 10, 2010 at 2:30 pm">%s</xliff:g> (recurring)</string>

    <!-- Used as the body text of a message reporting to an attendee that a specific instance
         of a recurring meeting has been canceled -->
    <string name="exception_cancel">This event has been canceled
         for: <xliff:g id="date">%s</xliff:g></string>
    <!-- Used as the body text of a message reporting to an attendee that a specific instance
         of a recurring meeting has been changed -->
    <string name="exception_updated">The details of this event have been changed
         for: <xliff:g id="date">%s</xliff:g></string>

	<!-- Message that appears if the AccountManager cannot create the system Account -->
	<string name="system_account_create_failed">The AccountManager could not create the Account; please 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>

    <!-- Notification message in notifications window when calendar sync is
         automatically enabled for pre-existing Exchange accounts on upgrade -->
    <string name="notification_exchange_calendar_added">Exchange calendar added</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>
    <!-- Displayed in small separator in to/cc/bcc dropdowns, when searching GAL completes,
         and a limited amount (not all) of the server results are being displayed.  This is
         always a larger value because it represents the limit of displayed results.  -->
    <string name="gal_completed_limited_fmt">First <xliff:g id="results" example="20">%1$d</xliff:g>
        results from <xliff:g id="domain">%2$s</xliff:g></string>

    <!-- General Preferences Screen -->
    <!-- Label in preferences header to describe general preferences -->
    <string name="header_label_general_preferences">Email Preferences</string>
    <!-- First category in general preferences -->
    <string name="category_general_preferences">Application Preferences</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">
         Select 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>

    <!--
        Strings for temporary UI
        STOPSHIP Remove them or move them up and make translatable
    -->
    <!-- Toast shown when a message(s) can't be moved because it's not supported
         on the POP3 protocol. [CHAR LIMIT=none]-->
    <string name="cannot_move_protocol_not_supported_toast" translatable="false">
        Move is not 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" translatable="false">
        Cannot move.  Selection contains multiple accounts.</string>
    <!-- Toast shown when messages can't be moved because they're in a special
         mailbox.  Do not translate "Drafts", "Outbox" and "Sent". [CHAR LIMIT=none]-->
    <string name="cannot_move_special_messages" translatable="false">
        Messages in Drafts, Outbox and Sent cannot be moved.</string>
</resources>
