<?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">
    <!-- Names of packages and authorities that are common to all apps
    and read from resources -->
    <!-- Name of the search suggestions authority that looks up recent suggestions. This
         needs to be modified in AndroidManifest.xml and res/xml/searchable.xml as well.  -->
    <string name="suggestions_authority" translatable="false">com.android.email.suggestionsprovider</string>

    <!-- 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 the app 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 the app 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 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>
    <!--  Button name used to complete a multi-step process -->
    <string name="done_action">Done</string>
    <!--  Menu item used to create a new quick response [CHAR_LIMIT=16] -->
    <string name="create_action">Create new</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 -->
    <string name="account_settings_action">Account settings</string>
    <!-- Menu item: options for this mailbox. [CHAR LIMIT = 32] -->
    <string name="menu_folder_options">Sync options</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>
    <!-- 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>

    <!-- 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 starred will be displayed with this name -->
    <string name="mailbox_name_display_starred">Starred</string>
    <!-- In the UI, the unread will be displayed with this name [CHAR LIMIT=15] -->
    <string name="mailbox_name_display_unread">Unread</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_verbose_logging_label" translatable="false">
        Enable extremely verbose logging?</string>
    <!-- Do Not Translate.  Checkbox label, shown only on debug screen -->
    <string name="debug_enable_file_logging_label" translatable="false">
        Enable 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>

    <!-- 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>
    <!-- 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>
    <!-- Menu item for inserting quick responses into email compose activity. [CHAR_LIMIT=30] -->
    <string name="message_compose_insert_quick_response_menu_title">Insert quick response</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">One or more attachments in your
        forwarded message will be downloaded prior to sending.</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>

    <!-- 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 unsuccessful.</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>

    <!-- Title of screen when setting up new email account [CHAR LIMIT=45] -->
    <string name="account_setup_basics_title">Account setup</string>
    <!-- Do Not Translate. Title of screen when trying to get oauth authentication -->
    <string name="oauth_authentication_title" translatable="false">OAuth authentication</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 your 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 the "Setup up email" screen, label indicating what service we are signed in with [CHAR LIMIT=40] -->
    <string name="signed_in_with_service_label">Signed in with %s</string>
    <!-- Label for the authentication section [CHAR LIMIT=20] -->
    <string name="authenticiation_label">Authentication</string>
    <!-- Label for the add authentication icon [CHAR LIMIT=40] -->
    <string name="add_authentication_label">Add authentication</string>
    <!-- Label for the add authentication icon [CHAR LIMIT=40] -->
    <string name="clear_authentication_label">Clear authentication</string>
    <!-- Button name on "Set up email" screen [CHAR LIMIT=20] -->
    <string name="account_setup_basics_manual_setup_action">Manual setup</string>
    <!-- Do not translate. Button name on "Set up email" screen [CHAR LIMIT=20] TODO: This is a temporary workaround
     to allow initiating the OAuth setup flow before we have the real design working. This string
     should be removed. -->
    <string name="account_setup_basics_oauth_setup_action" translatable="false">OAuth</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">
    Validating server settings\u2026</string>
    <!-- Appears on screen while system is checking outgoing server settings -->
    <string name="account_setup_check_settings_check_outgoing_msg">
    Validating smtp settings\u2026</string>
        <!-- Appears on screen while system is creating the account -->
    <string name="account_setup_creating_account_msg">
    Creating account\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>

    <!-- "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_server_label">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 signin</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>

    <!-- 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>
    <!-- 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">Last 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">Last 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">Last 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">Last 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">Last 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=40] -->
    <string name="account_setup_options_mail_window_default">Use account 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 is 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">Login failed.\n(<xliff:g id="error">%s</xliff:g>)</string>

    <!-- Account setup autodiscover auth failure dialog title. This is shown when autodiscover hits
        an "access denied" server error, which could imply incorrect username/password or that no
        autodiscover service has been configured for the domain [CHAR LIMIT=40] -->
    <string name="account_setup_autodiscover_dlg_authfail_title">Problem with account setup</string>
    <!-- Account setup autodiscover auth failure dialog message. This is shown when autodiscover hits
        an "access denied" server error, which could imply incorrect username/password or that no
        autodiscover service has been configured for the domain [CHAR LIMIT=NONE] -->
    <string name="account_setup_autodiscover_dlg_authfail_message">Confirm username, password, and account settings are correct.</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"
        >A client certificate is required. Do you want to connect to the server with a 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"
        >The 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_unsupported_ticker_fmt">
            Account \"<xliff:g id="account">%s</xliff:g>\" can\'t be synced due to security
    requirements.</string>
    <!-- Notification ticker when device security required (note: unused in Holo XL) -->
    <string name="security_needed_ticker_fmt">
            Account \"<xliff:g id="account">%s</xliff:g>\" requires security settings update.
    </string>
    <!-- Notification ticker when device security required (note: unused in Holo XL) -->
    <string name="security_changed_ticker_fmt">
            Account \"<xliff:g id="account">%s</xliff:g>\" changed its security settings; no user
            action is required.
    </string>
    <!-- Notification content title when device security required [CHAR_LIMIT=30] -->
    <string name="security_notification_content_update_title">Security update required</string>
    <!-- Notification content title when device security policies have changed [CHAR_LIMIT=36] -->
    <string name="security_notification_content_change_title">Security policies have
         changed</string>
    <!-- Notification content title when device security policies cannot be met [CHAR_LIMIT=30] -->
    <string name="security_notification_content_unsupported_title">Security policies can\'t be
         met</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 need to change your lock screen PIN or password soon, or the data for
         <xliff:g id="account">%s</xliff:g> will be erased. Do you want to 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. Do you want to 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>
    <!-- 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.
         Do you want to update them now?</string>
    <!-- Dialog content if you were brought here due to a login failure, and the server provided a reason
        [CHAR_LIMIT=none] -->
    <string name="account_settings_login_dialog_reason_fmt">
         Your login to <xliff:g id="account">%s</xliff:g> failed; the server said: <xliff:g id="reason">%s</xliff:g>
         Do you want to update your username and/or password?</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">Send notification 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">Sync 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_enforced_label">Policies enforced</string>
    <!-- On Settings screen, setting option summary [CHAR LIMIT=64] -->
    <string name="account_settings_enforced_summary">None</string>
    <!-- On Settings screen, setting option name -->
    <string name="account_settings_unsupported_label">Unsupported policies</string>
    <!-- On Settings screen, setting option summary [CHAR LIMIT=64] -->
    <string name="account_settings_unsupported_summary">None</string>
    <!-- On Settings screen, label for button that attempts to sync the account -->
    <string name="account_settings_retry_label">Attempt sync</string>
    <!-- On Settings screen, summmary for button that attempts to sync an account [CHAR LIMIT=64] -->
    <string name="account_settings_retry_summary">Touch here to sync this account</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. 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 email</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, section heading -->
    <string name="account_settings_policies">Security policies</string>

    <string name="system_folders_title">System folders</string>
    <string name="system_folders_trash_title">Trash folder</string>
    <string name="system_folders_trash_summary">Select your server\'s trash folder</string>
    <string name="system_folders_trash_dlg">Select your server\'s trash folder</string>
    <string name="system_folders_sent_title">Sent items folder</string>
    <string name="system_folders_sent_summary">Select your server\'s sent items folder</string>
    <string name="system_folders_sent_dlg">Select your server\'s sent items folder</string>

    <!-- On settings screen, dialog heading informing user to create or edit a quick response -->
    <string name="edit_quick_response_dialog">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=50] -->
    <string name="account_settings_sync_calendar_summary">Sync calendar event 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, setting option name -->
    <string name="account_settings_ringtone">Choose ringtone</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_servers">Server settings</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>
    <!-- On mailbox settings screen: Whether to sync this mailbox when the account syncs. -->
    <string name="mailbox_settings_sync_enabled_label">Sync this folder</string>
    <!-- On mailbox settings screen: Explanatory text for what it means to "sync this folder". -->
    <string name="mailbox_settings_sync_enabled_summary">Messages will download when connected</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 of mail to sync</string>

    <!-- Dialog title for the choosing whether to show checkboxes or sender image [CHAR LIMIT=200] -->
    <string name="prefDialogTitle_conversationListIcon">Sender image</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>

    <!-- 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 settings</string>

    <!-- General preference: Label of the setting for requiring confirmation before
         message deletion [CHAR LIMIT=32] -->
    <string name="general_preference_confirm_delete_label">Confirm before deleting</string>
    <!-- General preference: Description of the setting for requiring confirmation before
         message deletion [CHAR LIMIT=64] -->
    <!-- TODO: Delete this string, no longer used -->
    <string name="general_preference_confirm_delete_summary">Messages</string>
    <!-- General preference: Label of the setting for requiring confirmation before
         message sending [CHAR LIMIT=32] -->
    <string name="general_preference_confirm_send_label">Confirm before sending</string>
    <!-- General preference: Description of the setting for requiring confirmation before
         message sending [CHAR LIMIT=32] -->
    <!-- TODO: Delete this string, no longer used -->
    <string name="general_preference_confirm_send_summary">Messages</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>

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

    <!-- A policy disallowing the user of the device's camera [CHAR LIMIT=50] -->
    <string name="policy_dont_allow_camera">Disallow use of the device\'s camera</string>
    <!-- A policy requiring a device lock screen password [CHAR LIMIT=50] -->
    <string name="policy_require_password">Require device password</string>
    <!-- A policy disallowing the reuse of recent passwords [CHAR LIMIT=50] -->
    <string name="policy_password_history">Restrict the reuse of recent passwords</string>
    <!-- A policy that forces a password to expire after a set period of time [CHAR LIMIT=50] -->
    <string name="policy_password_expiration">Require passwords to expire</string>
    <!-- A policy requiring a maximum amount of time the device can sit idle before the lock screen
        is activated [CHAR LIMIT=50] -->
    <string name="policy_screen_timeout">Require an idle device to lock its screen</string>
    <!-- A policy limiting the number of old calendar events synced [CHAR LIMIT=50] -->
    <string name="policy_calendar_age">Limit the number of calendar events synced</string>
    <!-- A policy limiting the number of emails synced [CHAR LIMIT=50] -->
    <string name="policy_email_age">Limit the number of emails synced</string>

    <!-- The four strings below represent "quick responses" which the user can insert into a
        message being composed with just a couple of taps.  These four responses MUST be defined,
        but need not include a string (i.e. they are optional).  Further, the responses can be
        customized as necessary by the translator, in case one or more of these is inappropriate in
        a particular locale or if there are better options available. -->
    <!-- A "quick response", i.e. a quick reply to a received mail [CHAR LIMIT=NONE] -->
    <string name="quick_1">Thanks!</string>
    <!-- A "quick response", i.e. a quick reply to a received mail [CHAR LIMIT=NONE] -->
    <string name="quick_2">Sounds good to me!</string>
    <!-- A "quick response", i.e. a quick reply to a received mail [CHAR LIMIT=NONE] -->
    <string name="quick_3">I\'ll read this later and get back to you.</string>
    <!-- A "quick response", i.e. a quick reply to a received mail [CHAR LIMIT=NONE] -->
    <string name="quick_4">Let\'s set up a meeting to discuss this.</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>

    <!-- This is shown when a user responds to a meeting invitation [CHAR LIMIT=none]-->
    <string name="confirm_response">Sending response&#8230;</string>

    <!-- Displayed in the middle of the screen when the inbox is empty [CHAR LIMIT 100]-->
    <string name="no_conversations">No messages.</string>

    <!-- Used by AccountManager -->
    <string name="imap_name">IMAP</string>
    <string name="pop3_name">POP3</string>

    <string name="folder_picker_title">Folder picker</string>
    <!-- Displayed when the user must pick his server's trash folder from a list [CHAR LIMIT 30]-->
    <string name="trash_folder_selection_title">Select server trash folder for <xliff:g id="account">%s</xliff:g></string>
    <!-- Displayed when the user must pick his server's sent items folder from a list [CHAR LIMIT 30]-->
    <string name="sent_folder_selection_title">Select server sent items folder for <xliff:g id="account">%s</xliff:g></string>
    <string name="account_waiting_for_folders_msg">Loading folder list&#8230;</string>

    <!-- Feedback uri to be used when feedback is enabled -->
    <string name="email_feedback_uri" translatable="false"></string>

    <string name="account_manager_type_exchange" translatable="false">com.android.exchange</string>
    <string name="account_manager_type_pop3" translatable="false">com.android.email</string>
    <string name="account_manager_type_imap" translatable="false">com.android.email</string>
    <string name="account_manager_type_legacy_imap" translatable="false">com.android.email</string>
    <string name="intent_exchange_action" translatable="false">com.android.email.EXCHANGE_INTENT</string>
    <string name="intent_exchange_package" translatable="false">com.android.exchange</string>
    <string name="intent_account_manager_entry" translatable="false">com.android.email.activity.setup.ACCOUNT_MANAGER_ENTRY</string>
    <string name="intent_create_account" translatable="false">com.android.email.CREATE_ACCOUNT</string>
    <string name="authority_email_provider" translatable="false">com.android.email.provider</string>
    <string name="protocol_legacy_imap" translatable="false">imap</string>
    <string name="protocol_imap" translatable="false">imap</string>
    <string name="protocol_pop3" translatable="false">pop3</string>
    <string name="protocol_eas" translatable="false">eas</string>
    <string name="application_mime_type" translatable="false">application/email-ls</string>

    <!-- Content Provider Authority for Eml Attachments -->
    <string name="eml_attachment_provider" translatable="false">com.android.email.provider.eml.attachment</string>

    <!-- Provider name for widgets -->
    <string name="widget_provider" translatable="false">com.android.email.provider.WidgetProvider</string>

    <string name="print_job_name" translatable="false">Email - <xliff:g id="subject">%1$s</xliff:g></string>

</resources>
