<?xml version="1.0" encoding="utf-8"?>
<!--
/*
 * Copyright (C) 2007-2008 Esmertec AG.
 * Copyright (C) 2007-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">
    <!-- The name of the SMS/MMS app as it appears to the user in the Home screen, task switcher, etc. -->
    <string name="app_label">Messaging</string>

    <!-- Command name to open a Compose screen; displays in conversation list.
         Also used as accessibility text for widget's new message button -->
    <string name="new_message">New message</string>
    <!-- Context menu item on an individual message for dialing the sender's phone number -->
    <string name="menu_call_back">Call <xliff:g id="name">%s</xliff:g></string>
    <!-- Context menu item on an individual message for emailing the sender -->
    <string name="menu_send_email">Send email to <xliff:g id="name">%s</xliff:g></string>

    <!-- Menu item for starting a new conversation -->
    <string name="menu_compose_new">Compose</string>
    <!-- Menu item for accessing application settings -->
    <string name="menu_preferences">Settings</string>
    <!-- Menu shown in the context menu when long pressing on a message when the message contains
         one or more phone numbers and/or email addresses and the number or email is new to
         contacts. [CHAR LIMIT=50] -->
    <string name="menu_add_address_to_contacts">Add <xliff:g id="contactEmailOrNumber">%s</xliff:g> to People</string>
    <!-- Menu item to call the recipient of the conversation on the phone (imperative verb) -->
    <string name="menu_call">Call</string>
    <!-- Menu item for search -->
    <string name="menu_search">Search</string>
    <!-- Menu item for deleting all conversations -->
    <string name="menu_delete_all">Delete all threads</string>
    <!-- Context menu item on an individual conversation for deleting that conversation -->
    <string name="menu_delete">Delete thread</string>
    <!-- Context menu item on an individual conversation for viewing that conversation -->
    <string name="menu_view">View thread</string>
    <!-- Menu item for debugging - do not localize -->
    <string name="menu_debug_dump">DEBUG DUMP</string>
    <!-- Message that appears on screen while SIM card messages are retrieved -->
    <string name="refreshing">Refreshing\u2026</string>

    <!-- Menu item to show received cell broadcasts. [CHAR LIMIT=30] -->
    <string name="menu_cell_broadcasts">Cell broadcasts</string>

    <!-- Tag appearing on conversations in the conversation list that contain a draft message -->
    <string name="has_draft">Draft</string>

    <!-- Subject to display in the conversation list if there is no subject -->
    <string name="no_subject_view">(No subject)</string>

    <!-- Name of the local user when displaying sender of an outgoing message (personal pronoun) -->
    <string name="messagelist_sender_self">Me</string>
    <!-- Context menu item on an individual message for viewing an attached slideshow -->
    <string name="view_slideshow">View slideshow</string>
    <!-- Context menu item on an individual message for viewing message details such as time and date -->
    <string name="view_message_details">View details</string>
    <!-- Context menu item on an individual message for viewing a delivery report -->
    <string name="view_delivery_report">View report</string>
    <!-- Context menu item on an individual message for deleting only that message -->
    <string name="delete_message">Delete</string>
    <!-- Time and date a message is due to expire -->
    <string name="expire_on">"Expires: <xliff:g id="date">%s</xliff:g>"</string>
    <!-- Abbreviation for "kilobyte" -->
    <string name="kilobyte">KB</string>

    <!-- Dialog box title brought up when warning the user that a message could not be delivered -->
    <string name="undelivered_msg_dialog_title">Undelivered message</string>
    <!-- Dialog box message indicating that a message could not be delivered, including the time of last attempt -->
    <string name="undelivered_msg_dialog_body">Couldn\'t send this message.\nAttempt made: <xliff:g id="message">%s</xliff:g>.</string>
    <!-- Dialog box message indicating that a message could not be delivered -->
    <string name="undelivered_sms_dialog_body">Couldn\'t send this message.</string>
    <!-- Menu item for deleting the entire conversation currently being viewed -->
    <string name="delete_thread">Delete thread</string>
    <!-- Context menu item on an individual message for forwarding it to another recipient -->
    <string name="menu_forward">Forward</string>
    <!-- Text of a button appearing for MMS messages that have not yet been downloaded, causing the message
         to be downloaded (imperative verb) -->
    <string name="download">Download</string>
    <!-- Message displayed in place of the "download message" button once it has been pressed,
         indicating that the download is in progress -->
    <string name="downloading">Downloading</string>
    <!-- Formatting for subject displayed inline, prepended to MMS message text -->
    <string name="inline_subject">"&lt;Subject: <xliff:g id="subject">%s</xliff:g>&gt;"</string>
    <!-- Text to display when the actual text is inaccessible due to DRM protection -->
    <string name="drm_protected_text">"* DRM protected text *"</string>
    <!-- Error message to display when DRM rights are insufficient to access some data -->
    <string name="insufficient_drm_rights">Insufficient DRM rights detected.</string>
    <!-- Individual message context menu item -->
    <string name="copy_message_text">Copy text</string>
    <!-- Header for context menu on an individual message -->
    <string name="message_options">Message options</string>
    <!-- Header for context menu on an individual slideshow -->
    <string name="slideshow_options">Slideshow options</string>

    <!-- Button text on edit slide screen indicating the user wants to finish editing that slide -->
    <string name="done">Done</string>

    <!-- Menu item in slideshow edit screen for moving the selected slide up in the order -->
    <string name="move_up">Move up</string>
    <!-- Menu item in slideshow edit screen for moving the selected slide down in the order -->
    <string name="move_down">Move down</string>
    <!-- Menu item in slideshow edit screen for removing the selected slide from the slideshow -->
    <string name="remove_slide">Remove slide</string>
    <!-- Menu item in slideshow edit screen for adding a new slide to the slideshow -->
    <string name="add_slide">Add slide</string>
    <!-- Text displayed below "Add slide" item in slideshow edit screen -->
    <string name="add_slide_hint">Touch to create new slide.</string>
    <!-- Menu item in slideshow edit screen for discarding the entire slideshow -->
    <string name="discard_slideshow">Discard slideshow</string>
    <!-- Header of slideshow showing which slide is being displayed -->
    <string name="slide_show_part">Part <xliff:g id="part">%1$s</xliff:g>/<xliff:g id="total">%2$s</xliff:g></string>


    <!-- Menu item in slide edit screen for removing the text from the slide being edited -->
    <string name="remove_text">Remove text</string>
    <!-- Menu item in slide edit screen for adding a picture to the slide being edited -->
    <string name="add_picture">Add picture</string>
    <!-- Menu item in slide edit screen for removing the picture from the slide being edited -->
    <string name="remove_picture">Remove picture</string>
    <!-- Menu item in slide edit screen for adding music to the slide being edited -->
    <string name="add_music">Add music</string>
    <!-- Menu item in slide edit screen for removing the music from the slide being edited -->
    <string name="remove_music">Remove music</string>
    <!-- Menu item in slide edit screen for adding a video to the slide being edited -->
    <string name="add_video">Add video</string>
    <!-- Menu item in slide edit screen for removing the video from the slide being edited -->
    <string name="remove_video">Remove video</string>

    <!-- Hint displayed in message recipient text box when starting a new conversation -->
    <string name="to_hint">To</string>
    <!-- Hint displayed in subject edit text box when adding a subject -->
    <string name="subject_hint">Subject</string>

    <!-- Menu item in conversation screen for attaching something to the message being composed -->
    <string name="add_attachment">Attach</string>
    <!-- Menu item in conversation screen for adding a subject to the message being composed -->
    <string name="add_subject">Add subject</string>
    <!-- Menu item in conversation screen for discarding the message currently being composed -->
    <string name="discard">Discard</string>

    <!-- Button next to an attachment during message composition to view the attachment (imperative verb) -->
    <string name="view">View</string>
    <!-- Button next to an attachment during message composition to replace the attachment (imperative verb) -->
    <string name="replace">Replace</string>
    <!-- Button next to an attachment during message composition to remove the attachment (imperative verb) -->
    <string name="remove">Remove</string>

    <!-- Button in conversation screen for sending the SMS message currently being composed (imperative verb) -->
    <string name="send">Send</string>
    <!-- Text to appear directly below the "Send" text on the SMS/MMS send button. The "MMS" text is on a second line in a smaller font. This is similar to saying "Send (mms)". -->
    <string name="mms">MMS</string>
    <!-- Content description for the send button when sending an mms (imperative verb) -->
    <string name="send_mms">Send MMS</string>

    <!-- Menu item in conversation screen for returning to the conversation list -->
    <string name="all_threads">All threads</string>

    <!-- Hint text in message body field when keyboard is exposed -->
    <string name="type_to_compose_text_enter_to_send">Type message</string>
    <!-- Hint text in message body field when keyboard is hidden -->
    <string name="open_keyboard_to_compose_message">Open keyboard to type message</string>

    <!-- Toast message while an image is being resized -->
    <string name="compressing">Picture too large. Compressing\u2026</string>

    <!-- Error message indicating the format for the specified media type (e.g. "picture") is unsupported -->
    <string name="unsupported_media_format">Unsupported <xliff:g id="name">%1$s</xliff:g> format.</string>
    <!-- Message prompting the user to select a different item; item string as type-appropriate (e.g. "picture") -->
    <string name="select_different_media">Choose a different <xliff:g id="name">%1$s</xliff:g>.</string>
    <!-- Message indicating that the message size limit has been reached -->
    <string name="exceed_message_size_limitation">Message size limit reached.</string>
    <!-- Message indicating that the message is too big and there is no space to attach a video -->
    <string name="message_too_big_for_video">The message is too big to attach a video.</string>
    <!-- Error message indicating that the item trying to be attached could not be added -->
    <string name="failed_to_add_media">You can\'t add this <xliff:g id="name">%1$s</xliff:g> to your message.</string>
    <!-- Error message indicating that the picture being attached and resized could not be resized -->
    <string name="failed_to_resize_image">Picture not resized.</string>
    <!-- Error message indicating that an image being attached is still too large to send even after resize -->
    <string name="resize_image_error_information">This picture is too large to send, even when resized.</string>
    <!-- String prepended to forwarded messages to indicate they were forwarded -->
    <string name="forward_prefix">Fwd:\u0020</string>
    <!-- Dialog message text explaining that a draft message will not be saved due to invalid recipients -->
    <string name="discard_message_reason">Your message will be discarded because it has no valid recipients.</string>
    <!-- Dialog box title indicating which recipients are invalid when the user tries to send a message with invalid recipients -->
    <string name="has_invalid_recipient">Invalid recipient(s): &lt;<xliff:g id="name">%1$s</xliff:g>&gt;</string>
    <!-- While sending a message, if it has invalid recipient, display this message. -->
    <string name="invalid_destination">Invalid destination address.</string>
    <!-- While sending a message, this error is expected to be generated when user does not have
         MMS enabled on his account. [CHAR LIMIT=NONE] -->
    <string name="service_not_activated">Service not activated on network.</string>
    <!-- If a message has expired and is no longer available on MMSC, show this toast. [CHAR LIMIT=NONE] -->
    <string name="service_message_not_found">Message expired or not available.</string>
    <!-- If a message can't be sent because of a MMSC network problem, show this toast. [CHAR LIMIT=NONE] -->
    <string name="service_network_problem">Couldn\'t send due to network problem.</string>
    <!-- Dialog message text when the user tries to send a message with invalid recipients -->
    <string name="invalid_recipient_message">Correct the recipient(s) or they won\'t receive the message.</string>
    <!-- Dialog box title indicating the message cannot be sent because there are no valid recipients -->
    <string name="cannot_send_message">Can\'t send message</string>
    <!-- Dialog message text indicating the message cannot be sent because there are no valid recipients -->
    <string name="cannot_send_message_reason">Your message has no valid recipients.</string>
    <!-- Error message displayed when the user attempts to forward a message with DRM-locked contents -->
    <string name="cannot_forward_drm_obj">The DRM object included in the message can\'t be forwarded.</string>

    <!-- Brief message that appears when converting a message from SMS to MMS. -->
    <string name="converting_to_picture_message">Converting to multimedia message\u2026</string>
    <!-- Brief message that appears when the maximum number of slides has been reached -->
    <string name="cannot_add_slide_anymore">Can\'t add more slides.</string>
    <!-- Brief message that appears when user tries to add picture to a slide which already has a video. -->
    <string name="cannot_add_picture_and_video">Can\'t add video and picture to one slide.</string>
    <!-- Brief message that appears when the message cannot be saved -->
    <string name="cannot_save_message">Can\'t save message.</string>
    <!-- Brief message that appears when a message has automatically been saved as a draft -->
    <string name="message_saved_as_draft">Message saved as draft.</string>
    <!-- Brief message that appears when too many recipients have been added -->
    <string name="too_many_recipients">Message has too many recipients (<xliff:g id="currentCount">%1$s</xliff:g>). There is a limit of <xliff:g id="maxLimit">%2$s</xliff:g> recipients.</string>
    <!-- Brief message that appears when too many videos/pictures are imported -->
    <string name="too_many_attachments">There is a limit of <xliff:g id="maxLimit">%1$s</xliff:g> attachments. Only the first <xliff:g id="currentCount">%2$s</xliff:g> will be added.</string>
    <!-- Alert dialog title when adding attachments is taking a while  [CHAR LIMIT=none] -->
    <string name="adding_attachments_title">Adding attachments</string>
    <!-- Alert dialog when adding attachments is taking a while -->
    <string name="adding_attachments">Wait while the items are added to the slideshow.</string>
    <!-- Alert dialog title when creating a slideshow [CHAR LIMIT=none] -->
    <string name="building_slideshow_title">Building slideshow</string>

    <!-- Error message indicating that an audio attachment cannot be played -->
    <string name="cannot_play_audio">Can\'t play audio.</string>

    <!-- Button in the slide editor screen used to preview the slide (imperative verb) -->
    <string name="preview">Preview</string>
    <!-- Menu item in the slide editor screen used to preview the entire slideshow (imperative verb) -->
    <string name="preview_slideshow">Preview</string>
    <!-- Button in the slide editor screen used to replace the attached picture -->
    <string name="replace_image">Replace picture</string>
    <!-- String for slide duration in seconds -->
    <string name="duration_sec">Duration (<xliff:g id="duration">%s</xliff:g> sec)</string>
    <!-- Dialog box title for duration selector -->
    <string name="duration_selector_title">"Duration for slide "</string>
    <!-- Dialog box title for slide layout selector -->
    <string name="layout_selector_title">"Slideshow layout "</string>
    <!-- Slide layout option for layout at the top -->
    <string name="layout_top">Layout (top)</string>
    <!-- Slide layout option for layout at the bottom -->
    <string name="layout_bottom">Layout (bottom)</string>
    <!-- Hint in slide text field before text is typed -->
    <string name="type_to_compose_text_or_leave_blank">Type message, or leave blank</string>
    <!-- Toast when the user enters a non-numeric value for the duration of a slide -->
    <string name="duration_not_a_number">Duration must be a number.</string>
    <!-- Toast when the user enters a zero value for the duration of a slide -->
    <string name="duration_zero">Duration must be greater than zero seconds.</string>

    <!-- In duration selection dialog box, short version of "seconds" -->
    <string name="secs">secs</string>
    <!-- Options for slide duration in duration selection dialog box -->
    <string-array name="select_dialog_items">
         <item>1 second</item>
         <item>2 seconds</item>
         <item>3 seconds</item>
         <item>4 seconds</item>
         <item>5 seconds</item>
         <item>6 seconds</item>
         <item>7 seconds</item>
         <item>8 seconds</item>
         <item>9 seconds</item>
         <item>10 seconds</item>
         <item>Other</item>
    </string-array>

    <!-- Context menu item on a message recipient for viewing their contact info -->
    <string name="menu_view_contact">View contact</string>
    <!-- Context menu item on a message recipient for adding them to the user's
         contacts (used if the recipient is not already in the address book) -->
    <string name="menu_add_to_contacts">Add to People</string>

    <!-- Sender to be used if the sender address has been hidden -->
    <string name="hidden_sender_address">Hidden sender address</string>

    <!-- Text to be used for affirmative response button in dialog boxes -->
    <string name="yes">OK</string>
    <!-- Text to be used for negative response button in dialog boxes -->
    <string name="no">Cancel</string>
    <!-- Text to be used for affirmative response button in setting SMS limits dialog box -->
    <string name="set">Set</string>

    <!-- Button text used for playing an attachment or slideshow (imperative verb) -->
    <string name="play">Play</string>
    <!-- Button text used for editing a slideshow (imperative verb) -->
    <string name="edit">Edit</string>
    <!-- Button used for trying to send a message that has some valid recipients and some
         invalid recipients, in spite of the warning presented to the user -->
    <string name="try_to_send">Try to send</string>

    <!-- Title of Settings screen -->
    <string name="preferences_title">"Settings"</string>
    <!-- Settings screen menu item for restoring all settings to default -->
    <string name="restore_default">"Restore default settings"</string>

    <!-- Settings screen, section heading for notifications -->
    <string name="pref_notification_settings_title">Notifications</string>
    <!-- Settings screen, section heading for MMS-specific settings -->
    <string name="pref_mms_settings_title">"Multimedia (MMS) messages"</string>
    <!-- Settings screen, section heading for SMS-specific settings -->
    <string name="pref_sms_settings_title">"Text (SMS) messages"</string>
    <!-- Settings screen, section heading for storage-specific settings -->
    <string name="pref_sms_storage_title">Storage</string>

    <!-- Settings item description for entering SIM card message screen -->
    <string name="pref_summary_manage_sim_messages">Manage messages stored on your SIM card</string>
    <!-- Settings item description for boolean MMS delivery report setting -->
    <string name="pref_summary_mms_delivery_reports">Request a delivery report for each message you send</string>
    <!-- Settings item description for boolean MMS read report setting -->
    <string name="pref_summary_mms_read_reports">Request a read report for each message you send</string>
    <!-- Settings item description for boolean SMS delivery report setting -->
    <string name="pref_summary_sms_delivery_reports">Request a delivery report for each message you send</string>
    <!-- Settings item description for boolean auto-delete messages setting -->
    <string name="pref_summary_auto_delete">Delete old messages as limits are reached</string>
    <!-- Settings item description for integer auto-delete sms message limit -->
    <string name="pref_summary_delete_limit"><xliff:g id="count">%1$s</xliff:g> messages per conversation</string>
    <!-- Settings item description for boolean MMS enable group MMS setting -->
    <string name="pref_summary_mms_group_mms">Use MMS to send a single message when there are multiple recipients</string>
    <!-- Settings item for entering SIM card message screen -->
    <string name="pref_title_manage_sim_messages">Manage SIM card messages</string>
    <!-- Settings item for boolean option to enable/disable MMS delivery reports -->
    <string name="pref_title_mms_delivery_reports">Delivery reports</string>
    <!-- Settings item for boolean option to enable/disable MMS group messages -->
    <string name="pref_title_mms_group_mms">Group messaging</string>
    <!-- Settings item for boolean option to enable/disable MMS read reports -->
    <string name="pref_title_mms_read_reports">Read reports</string>
    <!-- Settings item for boolean option to enable/disable SMS delivery reports -->
    <string name="pref_title_sms_delivery_reports">Delivery reports</string>
    <!-- Settings item for boolean option to enable/disable auto-deletion of messages -->
    <string name="pref_title_auto_delete">Delete old messages</string>
    <!-- Settings item for integer option to set SMS delete limit -->
    <string name="pref_title_sms_delete">Text message limit</string>
    <!-- Settings item for integer option to set MMS delete limit -->
    <string name="pref_title_mms_delete">Multimedia message limit</string>
    <!-- Settings item for boolean option to display message notifications -->
    <string name="pref_title_notification_enabled">Notifications</string>
    <!-- Settings item description for boolean message notification option -->
    <string name="pref_summary_notification_enabled">Display message notifications in status bar</string>
    <!-- Settings item for boolean option to vibrate during message notification -->
    <string name="pref_title_notification_vibrateWhen">Vibrate</string>
    <!-- Settings item description for boolean vibrate option -->
    <string name="pref_summary_notification_vibrateWhen">Also vibrate when notified</string>
    <!-- Settings item for entering ringtone selection screen -->
    <string name="pref_title_notification_ringtone">Choose ringtone</string>
    <!-- Settings item for setting the number of message to save for each conversation -->
    <string name="pref_messages_to_save">Set number of messages to save</string>

    <!-- The vibrate notification modes -->
    <string-array name="prefEntries_vibrateWhen">
        <!-- Always -->
        <item>Always</item>
        <!-- Only when the phone is in Silent mode -->
        <item>Only when silent</item>
        <!-- Never -->
        <item>Never</item>
    </string-array>

    <!-- The default vibrateWhen value, when none is set -->
    <string translatable="false" name="prefDefault_vibrateWhen">never</string>
    <!-- The value to use when migrating from old versions for a true vibrate setting -->
    <string translatable="false" name="prefDefault_vibrate_true">always</string>
    <!-- The value to use when migrating from old versions for a false vibrate setting -->
    <string translatable="false" name="prefDefault_vibrate_false">never</string>

    <!-- The vibrateWhen values -->
    <string-array translatable="false" name="prefValues_vibrateWhen">
        <item>always</item>
        <item>silent</item>
        <item>never</item>
    </string-array>

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

    <!-- Settings item for boolean option to auto-retrieve incoming MMS messages -->
    <string name="pref_title_mms_auto_retrieval">Auto-retrieve</string>
    <!-- Settings item description for boolean MMS auto-retrieve option -->
    <string name="pref_summary_mms_auto_retrieval">Automatically retrieve messages</string>
    <!-- Settings item for boolean option to auto-retrieve incoming MMS messages while roaming -->
    <string name="pref_title_mms_retrieval_during_roaming">Roaming auto-retrieve</string>
    <!-- Settings item description for boolean MMS auto-retrieve while roaming option -->
    <string name="pref_summary_mms_retrieval_during_roaming">Automatically retrieve messages while roaming</string>

    <!-- Confirm Delete -->
    <!-- Delete confirmation dialog title -->
    <string name="confirm_dialog_title">Delete?</string>
    <!-- Delete confirmation dialog title for locked messages -->
    <string name="confirm_dialog_locked_title">Delete locked message?</string>
    <!-- This message is displayed in a confirmation dialog when the user selects one or more
         conversations and then taps the "Delete" button. -->
    <plurals name="confirm_delete_conversation">
        <!-- Case of 1 result. -->
        <item quantity="one">One conversation will be deleted.</item>
        <!-- Case of 0 or 2 or more results. -->
        <item quantity="other"><xliff:g id="number" example="15">%1$s</xliff:g> conversations will be deleted.</item>
    </plurals>
    <string name="confirm_delete_conversation">The entire thread will be deleted.</string>
    <!-- Delete all threads confirmation dialog message -->
    <string name="confirm_delete_all_conversations">All threads will be deleted.</string>
    <!-- Delete message confirmation dialog message -->
    <string name="confirm_delete_message">The message will be deleted.</string>
    <!-- Delete message confirmation dialog message for a locked message -->
    <string name="confirm_delete_locked_message">Delete this locked message?</string>
    <!-- Delete all the messages on the SIM dialog message -->
    <string name="confirm_delete_all_SIM_messages">All messages on the SIM card will be deleted.</string>
    <!-- Delete the selected message on the SIM dialog message -->
    <string name="confirm_delete_SIM_message">This message on the SIM card will be deleted.</string>
    <!-- Delete unlocked checkbox title -->
    <string name="delete_unlocked">Delete locked messages</string>
    <!-- Delete button title -->
    <string name="delete">Delete</string>
    <!-- Action bar mode title when multi-selecting conversations -->
    <string name="select_conversations">Choose conversations</string>
    <!-- Show this in the middle of the main activity when there are no conversations [CHAR LIMIT=none] -->
    <string name="no_conversations">No conversations.</string>
    <!-- Show this in the middle of the main activity when loading conversations [CHAR LIMIT=none] -->
    <string name="loading_conversations">Loading conversations.</string>

    <!-- When the user tries to view message details and some error occurs while
         retrieving those details, this message will be shown. -->
    <string name="cannot_get_details">Can\'t get details.</string>
    <!-- Title of "Message details" dialog -->
    <string name="message_details_title">Message details</string>
    <!-- Label in "Message details" dialog -->
    <string name="message_type_label">Type:\u0020</string>
    <!-- "Type" value in "Message details" dialog -->
    <string name="text_message">Text message</string>
    <!-- "Type" value in "Message details" dialog -->
    <string name="multimedia_message">Multimedia message</string>
    <!-- "Type" value in "Message details" dialog -->
    <string name="multimedia_notification">Multimedia message notification</string>
    <!-- Label in "Message details" dialog showing who sent the message. -->
    <string name="from_label">From:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="to_address_label">To:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="bcc_label">Bcc:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="sent_label">Sent:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="received_label">Received:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="saved_label">Saved:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="subject_label">Subject:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="message_size_label">Message size:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="priority_label">Priority:\u0020</string>
    <!-- "Priority" value in "Message details" dialog -->
    <string name="priority_high">High</string>
    <!-- "Priority" value in "Message details" dialog -->
    <string name="priority_normal">Normal</string>
    <!-- "Priority" value in "Message details" dialog -->
    <string name="priority_low">Low</string>
    <!-- Label in "Message details" dialog -->
    <string name="message_class_label">Message class:\u0020</string>
    <!-- Label in "Message details" dialog -->
    <string name="error_code_label">Error code:\u0020</string>

   <!-- Menu title for editing a message -->
   <string name="menu_edit">Edit</string>
   <!-- Menu title for deleting undelivered messages or messages on
        the SIM card. -->
   <string name="menu_delete_messages">Delete messages</string>
   <!-- Menu title for locking a message -->
   <string name="menu_lock">Lock</string>
   <!-- Menu title for unlocking a message -->
   <string name="menu_unlock">Unlock</string>

    <!-- Manage SIM Messages -->
    <!-- Menu title to copy a selected message from the SIM card to the phone. -->
    <string name="sim_copy_to_phone_memory" product="tablet">Copy to tablet memory</string>
    <!-- Menu title to copy a selected message from the SIM card to the phone. -->
    <string name="sim_copy_to_phone_memory" product="default">Copy to phone memory</string>
    <!-- Menu title to delete a selected messaged from the SIM card. -->
    <string name="sim_delete">Delete</string>
    <!-- Title of screen displaying messages on SIM card -->
    <string name="sim_manage_messages_title">Text messages on SIM card</string>
    <!-- Context menu item but currently commented out in 1.0. -->
    <string name="sim_view">View</string>
    <!-- Message that appears on the "SMS messges on SIM card" screen when there are no messages on the SIM card -->
    <string name="sim_empty">No messages on SIM card.</string>

    <!-- Delivery Header View -->
    <!-- Title of "Report" window -->
    <string name="delivery_header_title">Report</string>

    <!-- Delivery Report Activity -->
    <!-- Status in "Report" window -->
    <string name="status_none">(None)</string>
    <!-- Status in "Report" window -->
    <string name="status_pending">Pending</string>
    <!-- Status in "Report" window -->
    <string name="status_read">Read</string>
    <!-- Status in "Report" window -->
    <string name="status_received">Received</string>
    <!-- Status in "Report" window -->
    <string name="status_failed">Unsuccessful</string>
    <!-- Status in "Report" window -->
    <string name="status_unread">Unread</string>
    <!-- Status in "Report" window -->
    <string name="status_rejected">Rejected</string>
    <!-- Label in "Report" window -->
    <string name="recipient_label">Recipient:\u0020</string>
    <!-- Label in "Report" window -->
    <string name="status_label">Status:\u0020</string>
    <!-- Label in "Report" window [CHAR LIMIT=50]-->
    <string name="delivered_label">Delivered:\u0020</string>


    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_image">Pictures</string>
    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_take_photo">Capture picture</string>
    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_video">Videos</string>
    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_record_video">Capture video</string>
    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_sound">Audio</string>
    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_record_sound">Record audio</string>
    <!-- Attachment Type Selector Adapter. This string is an option in the "Attach" dialog, "Add music" dialog -->
    <string name="attach_slideshow">Slideshow</string>

    <!-- Layout Selector Adapter. Slideshow layout dialog option for aligning an icon. -->
    <string name="select_bottom_text">Text on bottom</string>
    <!-- Layout Selector Adapter. Slideshow layout dialog option for aligning an icon. -->
    <string name="select_top_text">Text on top</string>

    <!-- Delivery Report Toast dialog content -->
    <string name="delivery_toast_body">Message received by %s.</string>

    <!-- Delivery Report Notification dialog title. -->
    <string name="notification_multiple"><xliff:g id="count">%s</xliff:g> unread messages.</string>
    <!-- Delivery Report Notification dialog title. -->
    <string name="notification_multiple_title">New messages</string>

    <!-- Failed to send/download Notification dialog title. -->
    <string name="notification_failed_multiple"><xliff:g id="count">%s</xliff:g> messages couldn\'t be sent</string>
    <!-- Failed to send/download Notification dialog title. -->
    <string name="notification_failed_multiple_title">Messages not sent</string>

    <!-- Sim Full Notification dialog title. -->
    <string name="sim_full_title">SIM card full</string>
    <!-- Sim Full Notification dialog text. -->
    <string name="sim_full_body">Delete some messages to make room for more.</string>

    <!-- Device Full Notification dialog title. -->
    <string name="sms_full_title">Text message memory full</string>
    <!-- Device Full Notification dialog text. -->
    <string name="sms_full_body">An incoming message was rejected due to full memory. Delete some old messages.</string>

    <!-- Sms's Being Rejected Notification dialog title. -->
    <string name="sms_rejected_title">Text message rejected</string>
    <!-- Sms's Being Rejected Notification dialog text. -->
    <string name="sms_rejected_body">An incoming message was rejected due to an unknown reason.</string>

    <!-- Multimedia type used in building other messages.
         For instance: Sorry, you cannot add this audio to your message. -->
    <string name="type_audio">audio</string>
    <!-- Multimedia type used in building other messages.
         For instance: Sorry, you cannot add this picture to your message. -->
    <string name="type_picture">picture</string>
    <!-- Multimedia type used in building other messages.
         For instance: Sorry, you cannot add this video to your message. -->
    <string name="type_video">video</string>

    <!-- Dialog title for the Read Report dialog. -->
    <string name="confirm">Confirm</string>
    <!-- Dialog text for the Read Report dialog. -->
    <string name="message_send_read_report">A read report will be sent.</string>

    <!-- This is the text of a toast message briefly displayed when a problem occurs
         while sending. -->
    <string name="message_queued">Currently can\'t send your message. It will be sent when the service becomes available.</string>

    <!-- dialog error message when only is FDN is allowed. -->
    <string name="fdn_check_failure">You can only send messages to your fixed dialing numbers.</string>

    <!-- Download Manager -->
    <!-- When an error occurs downloading a new message and a subject isn't available, substitute
         this default subject. -->
    <string name="no_subject">(No subject)</string>
    <!-- When an error occurs downloading a new message and the sender is unknown, substitute
         this default text. -->
    <string name="unknown_sender">Unknown sender</string>
    <!-- When an error occurs downloading a new message, display this message.
         An example: Download of message Wanna get pizza from dorkman was unsuccessful. -->
    <string name="dl_failure_notification">Couldn\'t download message <xliff:g id="subject">%1$s</xliff:g> from <xliff:g id="from">%2$s</xliff:g>.</string>

    <!-- This is the confirm rate limit alert dialog title. -->
    <string name="rate_limit_surpassed">Confirm</string>
    <!-- This is the confirm rate limit alert dialog text. -->
    <string name="confirm_rate_limit">A large number of multimedia messages are being sent. Is this OK?</string>

    <!-- Message Failed Notification -->
    <!-- Dialog box title when receiving a message failed. -->
    <string name="message_download_failed_title">Message not downloaded</string>
    <!-- Dialog box title when sending a message failed. -->
    <string name="message_send_failed_title">Message not sent</string>
    <!-- Dialog box message text when failure occurs sending a message. -->
    <string name="message_failed_body">Touch to review the message and try again.</string>
    <!-- Dialog box message when there's a problem retrieving messages. -->
    <string name="download_later">Can\'t download right now. Try again later.</string>

    <!-- Title for audio file picker -->
    <string name="select_audio">Choose audio</string>
    <!-- Menu title to copy an attachment to the shared storage [CHAR LIMIT=25] -->
    <string name="copy_to_sdcard">Save attachment</string>
    <!-- Toast message on successful copy to shared storage [CHAR LIMIT=30] -->
    <string name="copy_to_sdcard_success">Attachment saved.</string>
    <!-- Toast message on failed copy to shared storage [CHAR LIMIT=30] -->
    <string name="copy_to_sdcard_fail">Couldn\'t save attachment.</string>
    <!-- Menu title to save a sound as a ringtone -->
    <string name="save_ringtone">Save as ringtone</string>
    <!-- Toast message on successful copying ringtone to drm provider -->
    <string name="saved_ringtone">Ringtone saved.</string>
    <!-- Toast message on failed copying ringtone to drm provider -->
    <string name="saved_ringtone_fail">Couldn\'t save ringtone.</string>
    <!-- Menu item -->
    <string name="menu_insert_smiley">Insert smiley</string>
    <!-- Menu item  [CHAR LIMIT=40] -->
    <string name="menu_group_participants">Group participants</string>

    <!-- This is the dialog title for the "Select link" dialog, shown when the user clicks on a
    chat in the chat history view if there are links in the chat message. The dialog displays the
    links if there are any -->
    <string name="select_link_title">Choose action</string>

    <!-- Name of the Nth slide, shown in the list in the slideshow editor. -->
    <string name="slide_number">Slide <xliff:g id="number" example="5">%s</xliff:g></string>
    <!-- Duration of the slide, shown in the list in the slideshow editor -->
    <plurals name="slide_duration">
        <!-- Case of 1-second duration. -->
        <item quantity="one"><xliff:g id="number" example="1">%s</xliff:g> sec</item>
        <!-- Case of "few" (small number of) seconds of duration. -->
        <item quantity="few"><xliff:g id="number" example="2">%s</xliff:g> secs</item>
        <!-- Case of multiple-second duration. -->
        <item quantity="other"><xliff:g id="number" example="15">%s</xliff:g> secs</item>
    </plurals>

    <!-- Title of the delivery report activity. -->
    <string name="delivery_report_activity">Delivery report</string>

    <!-- Title of the activity that tells the user about storage limits. -->
    <string name="storage_limits_activity">Storage limits</string>

    <!-- Title of the slide duration editor activity. -->
    <string name="change_duration_activity">Change duration</string>

    <!-- Title of the slideshow editor activity. -->
    <string name="edit_slideshow_activity">Edit slideshow</string>

    <!-- Title of the recipient list activity. [CHAR LIMIT=NONE] -->
    <string name="recipient_list_activity">Group participants</string>

    <!-- Title of the slide editor activity. -->
    <string name="edit_slide_activity">Edit slide</string>

    <!-- Title of the slideshow activity. -->
    <string name="slideshow_activity">Slideshow</string>

    <!-- Title of the class-0 message activity. -->
    <string name="class_0_message_activity">Class 0 message</string>

    <!-- Application name shown when searching -->
    <string name="search_label">Messaging</string>

    <!-- Search hint -->
    <string name="search_hint">Search messaging</string>

    <!-- Search activity name -->
    <string name="search">Messaging</string>
    <!-- Search setting description -->
    <string name="search_setting_description">Text in your messages</string>

    <!--  Search empty results -->
    <string name="search_empty">No matches.</string>

    <!--  Search results title -->
    <plurals name="search_results_title">
        <!-- Case of 1 result. -->
        <item quantity="one"><xliff:g id="number" example="1">%1$s</xliff:g> result for \"<xliff:g id="search" example="???">%2$s</xliff:g>\"</item>
        <!-- Case of 0 or 2 or more results. -->
        <item quantity="other"><xliff:g id="number" example="15">%1$s</xliff:g> results for \"<xliff:g id="search" example="???">%2$s</xliff:g>\"</item>
    </plurals>

    <!--- String saved in history searches. -->
    <string name="search_history"><xliff:g id="count">%1$s</xliff:g> results for \"<xliff:g id="search">%2$s</xliff:g>\"</string>

    <!-- Button title in Messaging preferences. -->
    <string name="confirm_clear_search_title">Clear</string>
    <!-- Text for the preferences button. -->
    <string name="confirm_clear_search_text">Search history will be cleared.</string>
    <!--- Button title in preferences to clear the search history. It's a verb action that takes place
          immediately when clicked. -->
    <string name="pref_mms_clear_search_history_title">Clear search history</string>
    <!--- Button description in preferences to clear the search history. -->
    <string name="pref_mms_clear_search_history_summary">Clear previous Messaging searches from showing up in the Search box</string>

    <!-- Dialog text for display mode save dialog. -->
    <string name="save">Save</string>

    <!-- Dialog title for dialog that informs user about new storage settings. -->
    <string name="storage_limits_title">Limit messages</string>

    <!-- Dialog message for dialog that informs user about new storage settings. -->
    <string name="storage_limits_message">Limit the number of messages you save per conversation?</string>

    <!-- Button title for dialog that informs user about new storage settings. -->
    <string name="storage_limits_setting">Set limits</string>

    <!-- Button title to dismiss dialog that informs user about new storage settings. -->
    <string name="storage_limits_setting_dismiss">No limits</string>

    <!-- Toast message when a user tries to send a Mms message when there are already too many
         outstanding unsent message. -->
    <string name="too_many_unsent_mms">Can\'t send message right now. Too many unsent multimedia messages.</string>

    <!-- Brief small label shown to right of message when it is being sent. -->
    <string name="sending_message">SENDING\u2026</string>

    <!-- Title of progress dialog for picker -->
    <string name="pick_too_many_recipients">Too many recipients</string>

    <!-- Message of progress dialog for picker -->
    <string name="adding_recipients">Adding recipients\u2026</string>

    <!-- In conversation list items, this is the separator between a contact's name
         and the draft stamp [CHAR LIMIT=5] -->
    <string name="draft_separator">,\u0020</string>

    <!-- In conversation list items, this comes after the receipient's name and contains
         the number of messages in the thread [CHAR LIMIT=5] -->
    <string name="message_count_format">\u00a0<xliff:g id="number" example="1">%1$s</xliff:g></string>

    <!-- When showing a multi-message notification, this is the title [CHAR LIMIT=none] -->
    <string name="message_count_notification"><xliff:g id="number" example="3">%1$s</xliff:g> new messages</string>
    <!-- In digest notifications when we show N messages, but there are N+M outstanding messages,
         this text is displayed at the bottom of the notification. [CHAR LIMIT=50] -->
    <plurals name="message_count_notification_overflow">
        <!-- Case of 1 result. -->
        <item quantity="one">+<xliff:g id="number" example="1">%1$s</xliff:g> other message"</item>
        <!-- Case of 2 or more results. -->
        <item quantity="other">+<xliff:g id="number" example="15">%1$s</xliff:g> other messages"</item>
    </plurals>

    <!-- For debugging: Dialog box title indicating there's a situation where data has unexpectedly
         changed -->
    <string name="error_state">Inconsistent state</string>
    <!-- For debugging: Dialog box text indicating there's a situation where data has unexpectedly
         changed -->
    <string name="error_state_text">The state of threads and recipients is inconsistent. Please capture a bug report and report it via http://go/droidanizer </string>

    <!-- In the title of the compose message activity, when there are multiple recipients, we show
         the number of recipients in the subtitle of the action bar. There's never a case of one. [CHAR LIMIT=50] -->
    <plurals name="recipient_count">
        <!-- Case of 0 or 2 or more results. -->
        <item quantity="other"><xliff:g id="number" example="15">%1$s</xliff:g> people</item>
    </plurals>

    <!-- Message of the dialog used to disable messaging notifications [CHAR LIMIT=none] -->
    <string name="disable_notifications_dialog_message">Stop duplicate text message notifications from default Messaging app?</string>

    <!-- Displayed at the end of the conversation list in the widget. Tapping on this will open the default conversation list. [CHAR LIMIT=35] -->
    <string name="view_more_conversations">View more conversations</string>

    <!-- Attachment type shown in notification. [CHAR LIMIT=35] -->
    <string name="attachment_audio">Audio</string>
    <!-- Attachment type shown in notification. [CHAR LIMIT=35] -->
    <string name="attachment_slideshow">Slideshow</string>
    <!-- Attachment type shown in notification. [CHAR LIMIT=35] -->
    <string name="attachment_video">Video</string>
    <!-- Attachment type shown in notification. [CHAR LIMIT=35] -->
    <string name="attachment_picture">Picture</string>

    <!-- Separator between parts of a notification in each line of an inboxStyle notification. [CHAR LIMIT=2] -->
    <string name="notification_separator">\u0020\u0020</string>

    <!-- An enumeration comma for separating multiple names in notifications. [CHAR LIMIT=2] -->
    <string name="enumeration_comma">,\u0020</string>

    <!-- In message list items, this string builds the timestamp line when the message is in a group [CHAR LIMIT=NONE] -->
    <string name="message_timestamp_format"><xliff:g id="string" example="Fred Flinstone">%1$s</xliff:g>\u0020-\u0020<xliff:g id="string" example="9:39AM">%2$s</xliff:g></string>

</resources>

