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

    <!-- Application name used in Settings/Apps. Default label for activities
         that don't specify a label. -->
    <string name="applicationLabel">Contacts</string>

    <!-- Title for the activity that launches Contacts.  This is the name
         used in the Launcher icon. -->
    <string name="launcherActivityLabel">Contacts</string>

    <!-- Directory partition name -->
    <string name="contactsList">Contacts</string>

    <!-- Name of activity that allows users to create shortcuts on the home screen to a contact.
         This shows up in a list of things like bookmark, folder, music playlist, etc -->
    <string name="shortcutContact">Contact</string>

    <!-- Name of activity that allows users to create shortcuts on the home screen to dial a contact.
         This shows up in a list of things like bookmark, folder, music playlist, etc -->
    <string name="shortcutDialContact">Direct dial</string>

    <!-- Name of activity that allows users to create shortcuts on the home screen to message (SMS) a contact.
         This shows up in a list of things like bookmark, folder, music playlist, etc -->
    <string name="shortcutMessageContact">Direct message</string>

    <!-- Activity title when the user is selecting a contact for a shortcut. -->
    <string name="shortcutActivityTitle">Choose a contact shortcut</string>

    <!-- Activity title when the user is selecting a contact for a direct dial shortcut. -->
    <string name="callShortcutActivityTitle">Choose a number to call</string>

    <!-- Activity title when the user is selecting a contact for a direct message shortcut. -->
    <string name="messageShortcutActivityTitle">Choose a number to message</string>

    <!-- Activity title when the user is inserting into an existing contact, or creating a new one.  [CHAR LIMIT=128] -->
    <string name="contactInsertOrEditActivityTitle">Add to contact</string>

    <!-- Activity title when the user is selecting a contact.  [CHAR LIMIT=128] -->
    <string name="contactPickerActivityTitle">Choose a contact</string>

    <!-- Entry that prompts user to select a newly created contact.  [CHAR LIMIT=30] -->
    <string name="header_entry_contact_list_adapter_header_title">Create new contact</string>

    <!-- Title for the activity that shows only starred contacts -->
    <string name="starredList">Starred</string>

    <!-- Title for the activity that shows only frequently contacted contacts -->
    <string name="frequentList">Frequent</string>

    <!-- Title for the activity that shows a mix of starred contacts and frequently contacted
         contacts. -->
    <string name="strequentList">Favorites</string>

    <!-- The title bar when viewing the contact details activity -->
    <string name="viewContactTitle">Contact details</string>

    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
         editing a contact. This string represents the built in way to edit the contact. -->
    <string name="editContactDescription">Edit contact</string>

    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
         creating a new contact. This string represents the built in way to create the contact. -->
    <string name="insertContactDescription">Create contact</string>

    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
         editing a group. This string represents the built in way to edit the group. [CHAR LIMIT=NONE] -->
    <string name="editGroupDescription">Edit group</string>

    <!-- The description presented to the user in the Intent choose when there are multiple activities that allow
         creating a new group. This string represents the built in way to create the group. [CHAR LIMIT=NONE] -->
    <string name="insertGroupDescription">Create group</string>

    <!-- The tab label for the contact detail activity that displays information about the contact [CHAR LIMIT=15] -->
    <string name="contactDetailAbout">About</string>

    <!-- The tab label for the contact detail activity that displays information about the contact [CHAR LIMIT=15] -->
    <string name="contactDetailUpdates">Updates</string>

    <!-- Hint text in the search box when the user hits the Search key while in the contacts app -->
    <string name="searchHint">Search contacts</string>

    <!-- Menu item used to view the details for a specific contact -->
    <string name="menu_viewContact">View contact</string>

    <!-- Menu item used to add a star to a contact, which makes that contact show up at the top of favorites -->
    <string name="menu_addStar">Add to favorites</string>

    <!-- Menu item used to remove a star from a contact, making the contact no longer show up at the top of favorites -->
    <string name="menu_removeStar">Remove from favorites</string>

    <!-- Description of what happens when you click on the unstar MenuItem. [CHAR LIMIT=NONE] -->
    <string name="description_action_menu_remove_star">Removed from favorites</string>
    <!-- Description of what happens when you click on the star MenuItem. [CHAR LIMIT=NONE] -->
    <string name="description_action_menu_add_star">Added to favorites</string>

    <!-- Menu item used to edit a specific contact -->
    <string name="menu_editContact">Edit</string>

    <!-- Menu item used to delete a specific contact -->
    <string name="menu_deleteContact">Delete</string>

    <!-- Menu item used to change the photo for a specific contact [CHAR LIMIT=30]-->
    <string name="menu_change_photo">Change photo</string>

    <!-- Menu item used to create a contact shortcut when viewing contact details. [CHAR LIMIT=30] -->
    <string name="menu_create_contact_shortcut">Place on Home screen</string>

    <!-- Menu item used to call a specific contact when viewing the details of that contact. -->
    <string name="menu_call">Call contact</string>

    <!-- Menu item used to send an SMS or MMS message to a specific phone number or a contacts default phone number -->
    <string name="menu_sendSMS">Text contact</string>

    <!-- Menu item that splits an item from the contact detail into a separate aggregate -->
    <string name="menu_splitAggregate">Separate</string>

    <!-- Menu item that edits the currently selected group [CHAR LIMIT=30] -->
    <string name="menu_editGroup">Edit</string>

    <!-- Menu item that deletes the currently selected group [CHAR LIMIT=30] -->
    <string name="menu_deleteGroup">Delete</string>

    <!-- Menu item (in the action bar) that creates a new contact [CHAR LIMIT=30] -->
    <string name="menu_new_contact_action_bar">Add Contact</string>

    <!-- Menu item (in the action bar) that creates a new group [CHAR LIMIT=30] -->
    <string name="menu_new_group_action_bar">Add Group</string>

    <!-- Title of the confirmation dialog for separating contacts into multiple instances [CHAR LIMIT=26] -->
    <string name="splitConfirmation_title">Separate contact?</string>

    <!-- Confirmation dialog for separating contacts into multiple instances [CHAR LIMIT=NONE] -->
    <string name="splitConfirmation">This contact will be separated into multiple contacts.</string>

    <!-- Menu item that joins an aggregate with another aggregate -->
    <string name="menu_joinAggregate">Merge</string>

    <!-- Menu item (in the action bar) to indicate that changes should be saved [CHAR LIMIT=20] -->
    <string name="menu_save">Save</string>

    <!-- Heading of the Join Contact screen -->
    <string name="titleJoinContactDataWith">Join contacts</string>

    <!-- Info blurb on the Join Contact screen [CHAR LIMIT=NONE]-->
    <string name="blurbJoinContactDataWith">Choose the contact you want to join with <xliff:g id="name">%s</xliff:g>:</string>

    <!-- An item in the Join Contact activity that opens up the full contact A-Z list -->
    <string name="showAllContactsJoinItem">Show all contacts</string>

    <!-- List separator for the Join Contact list: Suggestions -->
    <string name="separatorJoinAggregateSuggestions">Suggested contacts</string>

    <!-- List separator for the Join Contact list: A-Z -->
    <string name="separatorJoinAggregateAll">All contacts</string>

    <!-- Toast shown after two contacts have been joined by a user action. [CHAR LIMIT=NONE] -->
    <string name="contactsJoinedMessage">Contacts merged</string>

    <!-- Toast shown after contacts that the user has selected are deleted by a user action. [CHAR LIMIT=NONE] -->
    <string name="contacts_deleted_toast">Contacts deleted</string>

    <!-- Menu item that opens the Options activity for a given contact [CHAR LIMIT=15] -->
    <string name="menu_set_ring_tone">Set ringtone</string>

    <!-- Menu item that opens the Options activity for a given contact [CHAR LIMIT=30] -->
    <string name="menu_redirect_calls_to_vm">All calls to voicemail</string>

    <!-- Warning dialog contents after users selects to delete a ReadOnly contact. [CHAR LIMIT=NONE] -->
    <string name="readOnlyContactWarning">You can\'t delete contacts from read-only accounts, but you can hide them in your contacts lists.</string>

    <!-- Warning dialog contents after users selects to delete a contact with ReadOnly and Writable sources. -->
    <string name="readOnlyContactDeleteConfirmation">This contact contains information from multiple accounts. Information from read-only accounts will be hidden in your contacts lists, not deleted.</string>

    <!-- Warning dialog. Shown if user selects a single contact to merge. [CHAR LIMIT=NONE]  -->
    <string name="batch_merge_single_contact_warning">You need at least two contacts selected to perform a merge.</string>

    <!-- Confirmation dialog. Shown after user selects to merge contacts. [CHAR LIMIT=NONE]  -->
    <string name="batch_merge_confirmation">The selected contacts will be merged into a single contact.</string>

    <!-- Confirmation dialog. Shown after user selects to delete writable contacts. [CHAR LIMIT=NONE]  -->
    <string name="batch_delete_confirmation">The selected contacts will be deleted.</string>

    <!-- Confirmation dialog. Shown after user selects to delete readonly contacts. [CHAR LIMIT=NONE] -->
    <string name="batch_delete_read_only_contact_confirmation">Information from read-only accounts will be hidden in your contacts lists, not deleted.</string>

    <!-- Confirmation dialog. Shown after user selects to delete contacts from multiple accounts. [CHAR LIMIT=NONE]  -->
    <string name="batch_delete_multiple_accounts_confirmation">These contacts contains information from multiple accounts. Information from read-only accounts will be hidden in your contacts lists, not deleted.</string>

    <!-- Warning dialog contents after users selects to delete a contact with multiple Writable sources. -->
    <string name="multipleContactDeleteConfirmation">Deleting this contact will delete information from multiple accounts.</string>

    <!-- Confirmation dialog contents after users selects to delete a Writable contact. -->
    <string name="deleteConfirmation">This contact will be deleted.</string>

    <!-- Menu item to indicate you want to stop editing a contact and NOT save the changes you've made [CHAR LIMIT=30] -->
    <string name="menu_discard">Discard changes</string>

    <!-- Message displayed in a toast when you try to view the details of a contact that
         for some reason doesn't exist anymore. [CHAR LIMIT=NONE]-->
    <string name="invalidContactMessage">The contact doesn\'t exist.</string>

    <!-- Message displayed in a toast after you create a contact shortcut in the launcher [CHAR LIMIT=NONE]-->
    <string name="createContactShortcutSuccessful">Contact widget added to Home screen.</string>

    <!-- When picking a contact from a list of all contacts there is an entry at the top of the
         list that allows the user to create a new contact, which this string is used for -->
    <string name="pickerNewContactHeader">Create new contact</string>

    <!-- Text for a "create new contact" button on the bottom of the contact picker screen.
         The text will be all capitalized.
         [CHAR LIMIT=30] -->
    <string name="pickerNewContactText">Create new contact</string>

    <!-- The order of the items below is important, don't reorder without changing EditContactActivity.java -->
    <skip/>
    <!-- The labels that are under the otherLabelsGroup when editing a contact. [CHAR LIMIT=20] -->
    <string-array name="otherLabels">
        <!-- An organization associated with a contact -->
        <item>Organization</item>
        <!-- A note associated with a contact -->
        <item>Note</item>
    </string-array>

    <!-- Description in the dialog that appears if there are no pictures from which to create an icon for a contact -->
    <string name="photoPickerNotFoundText" product="tablet">No pictures are available on the tablet.</string>
    <!-- Description in the dialog that appears if there are no pictures from which to create an icon for a contact -->
    <string name="photoPickerNotFoundText" product="default">No pictures are available on the phone.</string>

    <!-- Description used in the attach photo Intent from third party apps [CHAR LIMIT=50] -->
    <string name="attach_photo_dialog_title">Contact photo</string>

    <!-- Title of the dialog used to set a custom label for a contact detail, like a phone number or email address.
         For example, this may be used to set a phone number's label to "Vaction house" -->
    <string name="customLabelPickerTitle">Custom label name</string>

    <!-- Check box label that allows calls to the contact to be sent directly to voicemail -->
    <string name="send_to_voicemail_checkbox">Send calls directly to voicemail</string>

    <!-- The menu item that allows you to remove a photo from a contact [CHAR LIMIT=50] -->
    <string name="removePhoto">Remove photo</string>

    <!-- The text displayed when the contacts list is empty while displaying all contacts [CHAR LIMIT=NONE] -->
    <string name="noContacts">No contacts.</string>

    <!-- The text displayed when the groups list is empty while displaying all groups [CHAR LIMIT=NONE] -->
    <string name="noGroups">No groups.</string>

    <!-- The text displayed when the groups list is empty and no accounts are set on the device while displaying all groups [CHAR LIMIT=NONE] -->
    <string name="noAccounts">To create groups you need an account.</string>

    <!-- The text displayed when there are no members in the group while displaying the group detail page [CHAR LIMIT=40] -->
    <string name="emptyGroup">No people in this group.</string>

    <!-- The text displayed to instruct users to add members to a group (when viewing a group detail page for a group with no members) [CHAR LIMIT=50] -->
    <string name="addPeopleToGroup">To add some, edit the group.</string>

    <!-- Displayed in a spinner dialog after the user creates a contact and it's being saved to the database -->
    <string name="savingContact">Saving contact\u2026</string>

    <!-- Toast displayed when a contact is saved [CHAR LIMIT=NONE] -->
    <string name="contactSavedToast">Contact saved.</string>

    <!-- Toast displayed when saving a contact failed. [CHAR LIMIT=NONE] -->
    <string name="contactSavedErrorToast">Couldn\'t save contact changes.</string>

    <!-- Toast displayed when saving a contact photo failed. [CHAR LIMIT=NONE] -->
    <string name="contactPhotoSavedErrorToast">Couldn\'t save contact photo changes.</string>

    <!-- Toast displayed when a group is saved [CHAR LIMIT=NONE] -->
    <string name="groupSavedToast">Group saved.</string>

    <!-- Toast displayed when saving a group failed [CHAR LIMIT=NONE] -->
    <string name="groupSavedErrorToast">Couldn\'t save group changes.</string>

    <!-- Displayed at the top of the contacts showing the total number of contacts visible when "Only contacts with phones" is selected -->
    <plurals name="listTotalPhoneContacts">
        <item quantity="one">1 contact with phone number</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> contacts with phone numbers</item>
    </plurals>

    <!-- Displayed at the top of the contacts showing the zero as total number of contacts visible when "Only contacts with phones" is selected [CHAR LIMIT=64]-->
    <string name="listTotalPhoneContactsZero">No contacts with phone numbers</string>

    <!-- Displayed at the top of the contacts showing the total number of contacts found when "Only contacts with phones" not selected [CHAR LIMIT=30] -->
    <plurals name="listFoundAllContacts">
        <item quantity="one">1 found</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> found</item>
    </plurals>

    <!-- Displayed at the top of the contacts showing the zero total number of contacts found when "Only contacts with phones" not selected. [CHAR LIMIT=30] -->
    <string name="listFoundAllContactsZero">No contacts</string>

    <!-- Displayed at the top of the contacts showing the total number of contacts found when typing search query -->
    <plurals name="searchFoundContacts">
        <item quantity="one">1 found</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> found</item>
    </plurals>

    <!-- The title of "all contacts" tab. [CHAR LIMIT=14] -->
    <string name="all_contacts_tab_label">All contacts</string>

    <!-- The title of "favorites" tab. [CHAR LIMIT=14] -->
    <string name="favorites_tab_label">Favorites</string>

    <!-- Action string for calling back a number in the call log -->
    <string name="callBack">Call back</string>

    <!-- Action string for calling a number in the call log again -->
    <string name="callAgain">Call again</string>

    <!-- Action string for returning a missed call in the call log -->
    <string name="returnCall">Return call</string>

    <!-- Dialog message when prompting before creating a contact. Includes
         the email address, e.g. "Add xyz@foo.com to contacts?" -->
    <string name="add_contact_dlg_message_fmt">Add \"<xliff:g id="email">%s</xliff:g>\" to contacts?</string>

    <!-- String describing the Contact Photo Image

         Used by AccessibilityService to announce the purpose of the view.
    -->
    <string name="description_contact_photo">contact photo</string>

    <!-- String describing the Contact Editor Plus button

         Used by AccessibilityService to announce the purpose of the button.
    -->
    <string name="description_plus_button">plus</string>

    <!-- Message in progress bar while exporting contact list to a file "(current number) of (total number) contacts" The order of "current number" and "total number" cannot be changed (like "total: (total number), current: (current number)")-->
    <string name="exporting_contact_list_progress"><xliff:g id="current_number">%s</xliff:g> of <xliff:g id="total_number">%s</xliff:g> contacts</string>

    <!-- The string used to describe Contacts as a searchable item within system search settings. -->
    <string name="search_settings_description">Names of your contacts</string>

    <!-- Shown as a toast when the user taps on a QuickContact icon, and no application
         was found that could perform the selected action. [CHAR LIMIT=NONE] -->
    <string name="quickcontact_missing_app">No app was found to handle this action.</string>
    <!-- Content description for the transparent views around the visible section of QuickContacts.
         Clicking this view causes Quick Contacts to close. [CHAR LIMIT=NONE] -->
    <string name="quickcontact_transparent_view_description">Click to return to previous screen</string>

    <!-- When a contact has no data, we prompt the user to add a phone number for the contact. [CHAR LIMIT=40] -->
    <string name="quickcontact_add_phone_number">Add phone number</string>
    <!-- When a contact has no data, we prompt the user to add an email for the contact. [CHAR LIMIT=40] -->
    <string name="quickcontact_add_email">Add email</string>

    <!-- Shown as a toast when the user attempts an action (add contact, edit
         contact, etc) and no application was found that could perform that
         action. [CHAR LIMIT=NONE] -->
    <string name="missing_app">No app was found to handle this action.</string>

    <!-- The menu item to share the currently viewed contact [CHAR LIMIT=30] -->
    <string name="menu_share">Share</string>

    <!-- The menu item to add the the currently viewed contact to your contacts [CHAR LIMIT=30] -->
    <string name="menu_add_contact">Add to contacts</string>

    <!-- Dialog title when picking the application to share a contact with. -->
    <string name="share_via">Share contact via</string>

    <!-- Title for the disambiguation dialog that requests the user choose an account for the new group to be created under [CHAR LIMIT=NONE] -->
    <string name="dialog_new_group_account">Create group under account</string>

    <!-- Generic action string for starting an audio chat. Used by AccessibilityService to announce the purpose of the view. [CHAR LIMIT=NONE] -->
    <string name="audio_chat">Voice chat</string>
    <!-- Generic action string for starting a video chat. Used by AccessibilityService to announce the purpose of the view. [CHAR LIMIT=NONE] -->
    <string name="video_chat">Video chat</string>

    <!-- Title for the list of all contact details that come from third-party sources (including a corporate directory) [CHAR LIMIT=20] -->
    <string name="connections">Connections</string>

    <!-- Label of the button to open the "add connection" popup where the user can invite a contact to other social networks or services [CHAR LIMIT=32] -->
    <string name="add_connection_button">Add connection</string>

    <!-- Section title for the page containing the contact's social updates on the contact card (this abbreviated version of "Recent updates" is used when "updates" is already shown as the title of the page) [CHAR LIMIT=20]-->
    <string name="recent" msgid="2062236709538790412">Recent</string>

    <!-- Section title for the page containing the contact's social updates on the contact card [CHAR LIMIT=20]-->
    <string name="recent_updates" msgid="2018245636796411442">Recent updates</string>

    <!-- String describing which account type a contact came from when editing it -->
    <string name="account_type_format"><xliff:g id="source" example="Gmail">%1$s</xliff:g> contact</string>

    <!-- String describing that a contact came from the google account type when editing it.  -->
    <string name="google_account_type_format"><xliff:g id="source" example="Google">%1$s</xliff:g> account</string>

    <!-- String describing which account a contact came from when editing it -->
    <string name="from_account_format"><xliff:g id="source" example="user@gmail.com">%1$s</xliff:g></string>

    <!-- Text used to explain that a contact cannot be edited from the People application since the data is read only [CHAR LIMIT=40] -->
    <string name="contact_read_only">Not editable from this app.</string>

    <!-- Text used to explain that a group cannot be edited since the data is read only [CHAR LIMIT=40] -->
    <string name="group_read_only">Not editable on this device.</string>

    <!-- An option in the 'Contact photo' dialog, if there is no photo yet [CHAR LIMIT=50] -->
    <string name="take_photo">Take photo</string>

    <!-- An option in the 'Contact photo' dialog, if there is already a photo [CHAR LIMIT=50] -->
    <string name="take_new_photo">Take new photo</string>

    <!-- An option in the 'Contact photo' dialog, if there is no photo yet [CHAR LIMIT=50] -->
    <string name="pick_photo">Choose photo</string>

    <!-- An option in the 'Contact photo' dialog, if there is already a photo [CHAR LIMIT=50] -->
    <string name="pick_new_photo">Select new photo</string>

    <!-- Text shown in the contacts app while the background process updates contacts after a system upgrade [CHAR LIMIT=300] -->
    <string name="upgrade_in_progress">Contact list is being updated.</string>

    <!-- Title shown in the search result activity of contacts app while searching.  [CHAR LIMIT=20] -->
    <string name="search_results_searching">Searching\u2026</string>

    <!-- Label to display only selection in multiple picker -->
    <string name="menu_display_selected">"Show selected"</string>

    <!-- Label to display all recipients in multiple picker -->
    <string name="menu_display_all">"Show all"</string>

    <!-- Label to select all contacts in multiple picker -->
    <string name="menu_select_all">"Select all"</string>

    <!-- Label to clear all selection in multiple picker -->
    <string name="menu_select_none">"Unselect all"</string>

    <!-- The button to add another entry of a specific data type (i.e. email, phone, address) to a contact in the Raw Contact Editor [CHAR LIMIT=22] -->
    <string name="add_new_entry_for_section">Add new</string>

    <!-- The button to add an organization field to a contact in the Raw Contact Editor [CHAR LIMIT=22] -->
    <string name="add_organization">Add organization</string>

    <!-- The button to add an organization field to a contact in the Raw Contact Editor [CHAR LIMIT=12] -->
    <string name="event_edit_field_hint_text">Date</string>

    <!-- The button to add an organization field to a contact in the Raw Contact Editor [CHAR LIMIT=15] -->
    <string name="group_edit_field_hint_text">Group name</string>

    <!-- Button used for changing a photo in the Raw Contact Editor [CHAR LIMIT=15] -->
    <string name="change_photo">Change</string>

    <!-- RadioButton that determines whether a raw contact's photo should be used for the entire contact [CHAR LIMIT=25] -->
    <string name="primary_photo">Primary photo</string>

    <!-- String describing the Star/Favorite checkbox

         Used by AccessibilityService to announce the purpose of the view.
    -->
    <string name="description_star">favorite</string>

    <!-- The title of the Edit-Contact screen -->
    <string name="edit_contact">Edit contact</string>

    <!-- Shows how many contacts have been merged. The value 1 is not shown but should be translated
         anyway if we change our mind later -->
    <plurals name="merge_info">
        <item quantity="one">not merged</item>
        <item quantity="other">merged from <xliff:g id="count">%0$d</xliff:g> sources</item>
    </plurals>

    <!-- The message in a confirmation dialog shown when the user selects a
        contact aggregation suggestion in Contact editor. [CHAR LIMIT=512]-->
    <string name="aggregation_suggestion_join_dialog_message">Join
        the current contact with the selected contact?</string>

    <!-- The message in a confirmation dialog shown when the user selects a
        contact aggregation suggestion in Contact editor. [CHAR LIMIT=512]-->
    <string name="aggregation_suggestion_edit_dialog_message">Switch to editing
        the selected contact? Information you entered so far will be copied.</string>

    <!-- The button that creates a local copy of a corporate contact. [CHAR LIMIT=40]-->
    <string name="menu_copyContact">Copy to My Contacts</string>

    <!-- The button that adds a contact to the predefined group "My Contacts" (as this is
         mostly interesting for Google-contacts, this should have the same description as the
         function of GMail/Contacts on the Web
         [CHAR LIMIT=40] -->
    <string name="add_to_my_contacts">Add to My Contacts</string>

    <!-- The description of the directory where the contact was found [CHAR LIMIT=100]-->
    <string name="contact_directory_description">Directory <xliff:g id="type" example="Corporate Directory">%1$s</xliff:g></string>

    <!-- Contact list filter indicating that the list shows groups chosen by the user [CHAR LIMIT=64] -->
    <string name="list_filter_custom">Custom</string>

    <!-- Title of the settings activity [CHAR LIMIT=64] -->
    <string name="activity_title_settings">Settings</string>

    <!-- Menu item for the settings activity [CHAR LIMIT=64] -->
    <string name="menu_settings" msgid="377929915873428211">Settings</string>

    <!-- Menu item for invoking contextual Help & Feedback [CHAR LIMIT=64] -->
    <string name="menu_help">Help &amp; feedback</string>

    <!-- The preference section title for contact display options [CHAR LIMIT=128] -->
    <string name="preference_displayOptions">Display options</string>

    <!-- Text used to show a organization that has both a company and title. This is used in the Detail-View
    of a Contact. This is mostly about the formatting of the two elements, so it should be kept small [CHAR LIMIT=79] -->
    <string name="organization_company_and_title"><xliff:g id="company" example="Technical Program Manager">%2$s</xliff:g>, <xliff:g id="company" example="Google Inc.">%1$s</xliff:g></string>

    <!-- Title shown for the phone number when the number tries to call on a device that it not a phone [CHAR LIMIT=30] -->
    <string name="non_phone_caption">Phone number</string>

    <!-- Button to add a phone number to contacts [CHAR LIMIT=25] -->
    <string name="non_phone_add_to_contacts">Add to contacts</string>

    <!-- Title of the activity that allows the user to confirm the addition of a detail to 1 existing contact [CHAR LIMIT=25] -->
    <string name="activity_title_confirm_add_detail">Add to contact</string>

    <!-- Button to close without add a phone number to contacts [CHAR LIMIT=25] -->
    <string name="non_phone_close">Close</string>

    <!-- Format string that combines the name and the phonetic name for the widget. if the phonetic name is empty, only the display name is used instead [CHAR LIMIT=25] -->
    <string name="widget_name_and_phonetic"><xliff:g id="display_name" example="John Huber">%1$s</xliff:g> (<xliff:g id="phonetic_name">%2$s</xliff:g>)</string>

    <!-- Checkbox whether to provide a year for a birthday [CHAR LIMIT=30] -->
    <string name="date_year_toggle">Provide a year</string>

    <!-- Label for the widget that shows picture and social status of a contact [CHAR LIMIT=20] -->
    <string name="social_widget_label">Contact</string>

    <!-- Message of widget while it is loading data [CHAR LIMIT=20] -->
    <string name="social_widget_loading">Loading\u2026</string>

    <!-- Button shown on the main contacts screen when there are no contacts on the device.
    Creates a new contact. [CHAR LIMIT=128] -->
    <string name="contacts_unavailable_create_contact">Create a new contact</string>

    <!-- Button shown on the main contacts screen when there are no contacts on the device.
    Navigates to account setup [CHAR LIMIT=128] -->
    <string name="contacts_unavailable_add_account">Sign in to an account</string>

    <!-- Button shown on the main contacts screen when there are no contacts on the device.
    Initiates a contact import dialog [CHAR LIMIT=128] -->
    <string name="contacts_unavailable_import_contacts">Import contacts</string>

    <!-- Title of the dialog that allows creation of a contact group [CHAR LIMIT=128] -->
    <string name="create_group_dialog_title">Create new group</string>

    <!-- An item in the popup list of groups that triggers creation of a contact group [CHAR LIMIT=128] -->
    <string name="create_group_item_label">Create new group</string>

    <!-- Shows how many groups are from the specified account [CHAR LIMIT=15] -->
    <plurals name="num_groups_in_account">
        <item quantity="one">1 group</item>
        <item quantity="other"><xliff:g id="count">%0$d</xliff:g> groups</item>
    </plurals>

    <!-- Confirmation message of the dialog that allows deletion of a contact group  [CHAR LIMIT=256] -->
    <string name="delete_group_dialog_message">Delete the group
      \"<xliff:g id="group_label" example="Friends">%1$s</xliff:g>\"?
      (Contacts themselves will not be deleted.)
    </string>

    <!-- Subtitle of the group detail page that describes how many people are in the current group [CHAR LIMIT=30] -->
    <plurals name="num_contacts_in_group">
        <item quantity="one"><xliff:g id="count">%1$d</xliff:g> person from <xliff:g id="account_type">%2$s</xliff:g></item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> people from <xliff:g id="account_type">%2$s</xliff:g></item>
    </plurals>

    <!-- Subtitle of a group (in the group list) that describes how many people are in the current group [CHAR LIMIT=30] -->
    <plurals name="group_list_num_contacts_in_group">
        <item quantity="one"><xliff:g id="count">%1$d</xliff:g> person</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> people</item>
    </plurals>

    <!-- Toast displayed when the user creates a new contact and attempts to join it
      with another before entering any data  [CHAR LIMIT=256] -->
    <string name="toast_join_with_empty_contact">Type contact name before joining
      with another.
    </string>

    <!-- Option displayed in context menu to copy long pressed item to clipboard [CHAR LIMIT=64] -->
    <string name="copy_text">Copy to clipboard</string>

    <!-- Option displayed in context menu to set long pressed item as default contact method [CHAR LIMIT=64] -->
    <string name="set_default">Set default</string>

    <!-- Option displayed in context menu to clear long pressed item as default contact method [CHAR LIMIT=64] -->
    <string name="clear_default">Clear default</string>

    <!-- Toast shown when text is copied to the clipboard [CHAR LIMIT=64] -->
    <string name="toast_text_copied">Text copied</string>

    <!-- Contents of the alert dialog when the user hits the Cancel button in the editor [CHAR LIMIT=128] -->
    <string name="cancel_confirmation_dialog_message">Discard your changes?</string>

    <!-- Description of a call log entry, made of a call type and a date -->
    <string name="call_type_and_date">
        <xliff:g id="call_type" example="Friends">%1$s</xliff:g>  <xliff:g id="call_short_date" example="Friends">%2$s</xliff:g>
    </string>

    <!-- Text displayed in place of the display name for the contact that represents the user's
      personal profile entry [CHAR LIMIT=64] -->
    <string name="profile_display_name">Set up my profile</string>

    <!-- Label to instruct the user to type in a contact's name to add the contact as a member of the current group. [CHAR LIMIT=64] -->
    <string name="enter_contact_name">Type person\'s name</string>

    <!-- Hint text in the group name box in the edit group view. [CHAR LIMIT=20]-->
    <string name="group_name_hint">Group\'s name</string>

    <!-- Header label in the contact editor for a profile that is local to the device only (and not associated with any account) [CHAR LIMIT=25] -->
    <string name="local_profile_title">My local profile</string>

    <!-- Header label in the contact editor for a profile that comes from an external third-party app whose name is given by source [CHAR LIMIT=20] -->
    <string name="external_profile_title">My <xliff:g id="external_source">%1$s</xliff:g> profile</string>

    <!-- Toast shown when the app starts showing all contacts regardless of its current
         contact filter state. [CHAR LIMIT=64] -->
    <string name="toast_displaying_all_contacts">Displaying all contacts</string>

    <!-- Message in the standard "no account" prompt that encourages the user to add a Google account before continuing to use the People app [CHAR LIMIT=NONE] -->
    <string name="no_account_prompt">Contacts works better with a Google Account.\n\n\u2022 Access from any web browser.\n\u2022 Back up your contacts securely.</string>

    <!-- Message in the standard "no account" prompt that encourages the user to add any account (non Google-specific) before continuing to use the People app [CHAR LIMIT=NONE] -->
    <string name="generic_no_account_prompt">Keep your contacts safe even if you lose your phone: synchronize with an online service.</string>

    <!-- Title of the screen that encourages the user to add any account (non Google-specific) for a better Contacts app experience [CHAR LIMIT=20] -->
    <string name="generic_no_account_prompt_title">Add an account</string>

    <!-- Message in the contact editor prompt that notifies the user that the newly created contact will not be saved to any account, and prompts addition of an account [CHAR LIMIT=NONE] -->
    <string name="contact_editor_prompt_zero_accounts">Your new contact won\'t be backed up. Add an account that backs up contacts online?</string>

    <!-- Message in the contact editor prompt that asks the user if it's okay to save the newly created contact to the account shown. [CHAR LIMIT=NONE] -->
    <string name="contact_editor_prompt_one_account">Your new contact will be synchronized with <xliff:g id="account_name">%1$s</xliff:g>.</string>

    <!-- Message in the contact editor prompt that asks the user which account they want to save the newly created contact to. [CHAR LIMIT=NONE] -->
    <string name="contact_editor_prompt_multiple_accounts">You can synchronize your new contact with one of the following accounts. Which do you want to use?</string>

    <!-- Title of the ContactEditorActivity when creating a new contact. The char
         limit is short and cannot be increased, since this needs to be displayed in a single line
         at a pre-determined text size. [CHAR LIMIT=20] -->
    <string name="contact_editor_title_new_contact">Add new contact</string>

    <!-- Title of the ContactEditorActivity when editing a contact that already exists. The char
         limit is short and cannot be increased, since this needs to be displayed in a single line
         at a pre-determined text size. [CHAR LIMIT=20] -->
    <string name="contact_editor_title_existing_contact">Edit contact</string>

    <!-- Button label to indicate that the user wants to save the newly created contact locally (instead of backing it up online) [CHAR LIMIT=20] -->
    <string name="keep_local">Keep local</string>

    <!-- Button label to prompt the user to add an account (when there are 0 existing accounts on the device) [CHAR LIMIT=30] -->
    <string name="add_account">Add account</string>

    <!-- Button label to prompt the user to add another account (when there are already existing accounts on the device) [CHAR LIMIT=30] -->
    <string name="add_new_account">Add new account</string>

    <!-- Menu item shown only when the special debug mode is enabled, which is used to send all contacts database files via email.  [CHAR LIMI=NONE] -->
    <string name="menu_export_database">Export database files</string>

    <!-- Content description for the button that adds a new contact
         [CHAR LIMIT=NONE] -->
    <string name="action_menu_add_new_contact_button">add new contact</string>
    <!-- Button Label to see more on an ExpandingEntryCardView [CHAR LIMIT=40] -->
    <string name="expanding_entry_card_view_see_more">See more</string>
    <!-- Button Label to see less on an ExpandingEntryCardView [CHAR LIMIT=40] -->
    <string name="expanding_entry_card_view_see_less">See less</string>
    <!-- Button Label to see all on an ExpandingEntryCardView [CHAR LIMIT=40] -->
    <string name="expanding_entry_card_view_see_all">See all</string>

    <!-- Title of recent card. [CHAR LIMIT=60] -->
    <string name="recent_card_title">Recent</string>

    <!-- Title of recent card. [CHAR LIMIT=40] -->
    <string name="about_card_title">About</string>

    <!-- Title of sms action entry. [CHAR LIMIT=60] -->
    <string name="send_message">Send message</string>

    <!-- Toast that appears when you are copying a directory contact into your personal contacts -->
    <string name="toast_making_personal_copy">Creating a personal copy...</string>
    <!-- Timestamp string for interactions from yesterday. [CHAR LIMIT=40] -->
    <string name="yesterday">Yesterday</string>
    <string name="tomorrow">Tomorrow</string>
    <!-- Timestamp string for interactions from today. [CHAR LIMIT=40] -->
    <string name="today">Today</string>
    <!-- Text for an event starting on the current day with a start and end time.
         For ex, "Today at 5:00pm-6:00pm" [CHAR LIMIT=NONE] -->
    <string name="today_at_time_fmt">"Today at <xliff:g id="time_interval">%s</xliff:g>"</string>
    <!-- Text for an event starting on the next day with a start and end time.
         For ex, "Tomorrow at 5:00pm-6:00pm" [CHAR LIMIT=NONE] -->
    <string name="tomorrow_at_time_fmt">"Tomorrow at <xliff:g id="time_interval">%s</xliff:g>"</string>
    <!-- Format string for a date and time description.  For ex:
         "April 19, 2012, 3:00pm - 4:00pm" [CHAR LIMIT=NONE] -->
    <string name="date_time_fmt">"<xliff:g id="date">%s</xliff:g>, <xliff:g id="time_interval">%s</xliff:g>"</string>
    <!-- Title for untitled calendar interactions [CHAR LIMIT=40] -->
    <string name="untitled_event">(Untitled event)</string>

    <!-- Name of the button in the date/time picker to accept the date/time change [CHAR LIMIT=15] -->
    <string name="date_time_set">Set</string>

    <!-- Header for the IM entry [CHAR LIMIT=40] -->
    <string name="header_im_entry">IM</string>
    <!-- Header for the Organization entry [CHAR LIMIT=40] -->
    <string name="header_organization_entry">Organization</string>
    <!-- Header for the Nickname entry [CHAR LIMIT=40] -->
    <string name="header_nickname_entry">Nickname</string>
    <!-- Header for the Note entry [CHAR LIMIT=40] -->
    <string name="header_note_entry">Note</string>
    <!-- Header for the Website entry [CHAR LIMIT=40] -->
    <string name="header_website_entry">Website</string>
    <!-- Header for the Event entry [CHAR LIMIT=40] -->
    <string name="header_event_entry">Event</string>
    <!-- Header for the Relation entry [CHAR LIMIT=40] -->
    <string name="header_relation_entry">Relation</string>
    <!-- Content description for the account field header image. Example accounts listed in this field: Google, Hotmail and Exchange. [CHAR LIMIT=NONE] -->
    <string name="header_account_entry">Account</string>
    <!-- Content description for the name fields header entry [CHAR LIMIT=NONE] -->
    <string name="header_name_entry">Name</string>
    <!-- Content description for the email fields header entry [CHAR LIMIT=NONE] -->
    <string name="header_email_entry">Email</string>
    <!-- Content description for the phone fields header entry [CHAR LIMIT=NONE] -->
    <string name="header_phone_entry">Phone</string>
    <!-- Content description for the camera icon beside the photo section in the Raw Contact Editor [CHAR LIMIT=NONE] -->
    <string name="header_photo_entry">Photo</string>

    <!-- Content description for the expand button inside the raw contact editor's header. [CHAR LIMIT=NONE] -->
    <string name="content_description_expand_editor">Click to expand contact editor.</string>
    <!-- Content description for the collapse button inside the raw contact editor's header. [CHAR LIMIT=NONE] -->
    <string name="content_description_collapse_editor">Click to collapse contact editor.</string>

    <!-- Content description for directions secondary button [CHAR LIMIT=NONE] -->
    <string name="content_description_directions">directions to location</string>

    <!-- Content description for recent sms interaction [CHAR LIMIT=NONE] -->
    <string name="content_description_recent_sms">recent sms. <xliff:g id="message_body">%s</xliff:g>. <xliff:g id="phone_number">%s</xliff:g>. <xliff:g id="date">%s</xliff:g>. click to respond</string>

    <!-- Header for the Relation entry [CHAR LIMIT=NONE] -->
    <string name="content_description_recent_call_type_incoming">incoming</string>
    <!-- Header for the Relation entry [CHAR LIMIT=NONE] -->
    <string name="content_description_recent_call_type_outgoing">outgoing</string>
    <!-- Header for the Relation entry [CHAR LIMIT=NONE] -->
    <string name="content_description_recent_call_type_missed">missed</string>

    <!-- Content description for recent sms interaction [CHAR LIMIT=NONE] -->
    <string name="content_description_recent_call">recent call. <xliff:g id="call_type">%s</xliff:g>. <xliff:g id="phone_number">%s</xliff:g>. <xliff:g id="date">%s</xliff:g>. click to call back</string>

    <!-- Prefix for messages that you sent [CHAR LIMIT=40] -->
    <string name="message_from_you_prefix">You: <xliff:g id="sms_body">%s</xliff:g></string>

    <!-- File Authority for the photo picker -->
    <string name="photo_file_provider_authority" translatable="false">com.android.contacts.files</string>

    <!-- When a user tries to create an IM Hangouts field, an alert dialog pops up displaying this message. We don't want users entering email addresses of phone numbers into the IM field. [CHAR LIMIT=200] -->
    <string name="contact_editor_hangouts_im_alert">Hangouts works better when you enter the person\'s Hangouts identifier into the email field or phone field.</string>

    <!-- Button to expand the compact contact editor to show all available input fields. [CHAR LIMIT=60] -->
    <string name="compact_editor_more_fields">More Fields</string>

    <!-- Content description for the compact contact editor photo overlay which, when clicked, shows a dialog with the options for changing the contact photo. [CHAR LIMIT=30] -->
    <string name="compact_editor_change_photo_content_description">Change photo</string>

    <!-- Quick contact display name with phonetic name -->
    <string name="quick_contact_display_name_with_phonetic"><xliff:g id="display_name">%s</xliff:g> (<xliff:g id="phonetic_name">%s</xliff:g>)</string>
</resources>
