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

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

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

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

    <!-- Title of debug screen -->
    <string name="debug_title">Debug</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 exchange 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. Button label. Shown only on debug screen -->
    <string name="debug_clear_migration_state" translatable="false">Clear migration state</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>


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

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

    <!-- Title of screen when setting up new email account [CHAR LIMIT=45] -->
    <string name="account_setup_basics_title">Account setup</string>
    <!-- Title of screen when trying to get oauth authentication -->
    <string name="oauth_authentication_title">Requesting authorization</string>
    <!-- Title of screen to choose with authentication to use -->
    <string name="sign_in_title">Sign in</string>

    <!-- Warning if there is a problem authenticating with oauth -->
    <string name="oauth_error_description">Unable to authenticate</string>
    <!-- Warning label displayed when the email address or password are incorrect -->
    <string name="password_warning_label">Email address or password are incorrect</string>
    <!-- Label displayed to confirm what email address we are trying to validate -->
    <string name="email_confirmation_label">Email address:</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>

    <!-- Label between OAuth and password authentication, indicating the user must do one or the other [CHAR LIMIT=40] -->
    <string name="or_label">OR</string>
    <!-- Label for signing in with Google using OAuth -->
    <string name="sign_in_with_google">Sign in with Google</string>
    <!-- On "Set up email" screen, hint for account email password text field, should be uppercase where applicable -->
    <string name="account_setup_basics_password_label">PASSWORD</string>
    <!-- hint for account email password text field -->
    <string name="password_hint">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, should be uppercase where applicable [CHAR LIMIT=20] -->
    <string name="authentication_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, with action underlined using html [CHAR LIMIT=20] -->
    <string name="account_setup_basics_manual_setup_action">Manual setup</string>
    <!-- Toast when we can't build a URI from the given email & password -->
    <!-- Note, the error message in the toast is purposefully vague, because I *don't* know
        exactly what's wrong. -->
    <string name="account_setup_username_password_toast">
        Type a valid email address and password.</string>
    <!-- Title of dialog shown when a duplicate account is created -->
    <string name="account_duplicate_dlg_title">Duplicate account</string>
    <!-- Message of dialog shown when a duplicate account is created.  The display name of
         the duplicate account is displayed. -->
    <string name="account_duplicate_dlg_message_fmt">
        You\'re already using this username for the account \"<xliff:g id="duplicate">%s</xliff:g>\".
    </string>

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

    <!-- Headline text that appears on "Confirm account type" screen [CHAR LIMIT=none] -->
    <string name="account_setup_ab_headline">Confirm account type</string>
    <!-- Explanatory text that appears on the "Confirm account type" screen [CHAR LIMIT=none] -->
    <string name="account_setup_ab_instructions_format">You indicated <xliff:g id="email">%1$s</xliff:g> uses <xliff:g id="userProtocol">%2$s</xliff:g>, but the account may use <xliff:g id="providerProtocol">%3$s</xliff:g></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>

    <!-- 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, 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, should be uppercase where applicable -->
    <string name="account_setup_incoming_username_label">USERNAME</string>
    <!-- "Incoming server settings" screen, label for text field, should be uppercase where applicable -->
    <string name="account_setup_incoming_password_label">PASSWORD</string>
    <!-- "Incoming server settings" screen, label for text field -->
    <string name="account_setup_password_subheading">Password</string>
    <!-- "Incoming server settings" screen, label for text field, should be uppercase where applicable -->
    <string name="account_setup_incoming_server_label">SERVER</string>
    <!-- "Incoming server settings" screen, label for text field, should be uppercase where applicable -->
    <string name="account_setup_incoming_port_label">PORT</string>
    <!-- "Incoming server settings" screen, label for pop-up menu, should be uppercase where applicable -->
    <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, 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, should be uppercase where applicable -->
    <string name="account_setup_outgoing_smtp_server_label">SMTP SERVER</string>
    <!-- On "Outgoing server settings" screen, label for text field, should be uppercase where applicable -->
    <string name="account_setup_outgoing_port_label">PORT</string>
    <!-- On "Outgoing server settings" screen, label for pop-up menu, should be uppercase where applicable -->
    <string name="account_setup_outgoing_security_label">SECURITY TYPE</string>
    <!-- On "Outgoing server settings" screen, label for check box, should be uppercase where applicable -->
    <string name="account_setup_outgoing_require_login_label">Require signin</string>
    <!-- On "Outgoing server settings" screen, label for text field, should be uppercase where applicable-->
    <string name="account_setup_outgoing_username_label">USERNAME</string>

    <!-- On "Exchange" setup screen, a heading title for the current client certificate, should be uppercase where applicable [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, should be uppercase where applicable [CHAR LIMIT=30] -->
    <string name="account_setup_exchange_device_id_label">MOBILE DEVICE ID</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">Sync 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">Sync emails from:</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>

    <!-- 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>
    <!-- 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 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="label_notification_vibrate_title">Vibrate</string>

    <!-- On Settings screen, setting option name -->
    <string name="account_settings_ringtone">Choose ringtone</string>
    <!-- On Settings screen, section heading -->
    <string name="account_settings_servers">Server settings</string>

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

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

    <!-- Short name of Microsoft Exchange account type; used by AccountManager -->
    <string name="exchange_eas_name" translatable="false">Exchange</string>
    <!-- Long 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>

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

    <!-- Used by AccountManager -->
    <!-- Account type name as used by AccountManager UI (IMAP is not translatable) [CHAR LIMIT=30] -->
    <string name="imap_name">Personal (IMAP)</string>
    <!-- Account type name as used by AccountManager UI (POP3 is not translatable) [CHAR LIMIT=30] -->
    <string name="pop3_name">Personal (POP3)</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_cert_action" translatable="false">com.android.email.EXCHANGE_REQUEST_CERT</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_force_create_email_account" translatable="false">com.android.email.FORCE_CREATE_ACCOUNT</string>
    <string name="intent_create_email_account" translatable="false">com.android.email.CREATE_NEW_ACCOUNT</string>
    <string name="authority_email_provider" translatable="false">com.android.email.provider</string>
    <string name="authority_conversation_provider" translatable="false">com.android.email.conversation.provider</string>
    <string name="authority_account_cache_provider" translatable="false">com.android.email.accountcache</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>

    <!-- This message indicates no quick responses exist to choose from -->
    <string name="no_quick_responses">None available</string>

    <!-- Activity name of the compose activity that should be reconciled -->
    <string name="reconciliation_compose_activity_name" translatable="false">com.android.email.activity.ComposeActivityEmail</string>

    <!-- Gmail name for redirecting during account setup -->
    <string name="gmail_name">Gmail</string>

    <!-- Name for preference entry which leads to the per-folder sync settings activity -->
    <string name="folder_sync_settings_pref_title">Folder sync settings</string>
</resources>
