<?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">
    <!-- Title for the activity that dials the phone.  This is the name
         used in the Launcher icon. -->
    <string name="launcherDialer">Phone</string>

    <!-- Title for the activity that opens the People app.  This is the name
         used in the Launcher icon. -->
    <string name="people">People</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 selecting a contact.  [CHAR LIMIT=128] -->
    <string name="contactPickerActivityTitle">Choose a 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
         viewing a contact. This string represents the built in way to view the contact. -->
    <string name="viewContactDesription">View contact</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 to search contacts -->
    <string name="menu_search">Search</string>

    <!-- Menu item to create a new contact -->
    <string name="menu_newContact">New contact</string>

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

    <!-- Menu item used to call a contact, containing the number of the contact to call -->
    <string name="menu_callNumber">Call <xliff:g id="number">%s</xliff:g></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>

    <!-- 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 to copy something [CHAR_LIMIT=10] -->
    <string name="menu_copy">Copy</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">Join</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 -->
    <string name="contactsJoinedMessage">Contacts joined</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 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 are done editing a contact and want to save the changes you've made -->
    <string name="menu_done">Done</string>

    <!-- Menu item to indicate you want to cancel the current editing process and NOT save the changes you've made [CHAR LIMIT=12] -->
    <string name="menu_doNotSave">Cancel</string>

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

    <!-- The label describing the Notes field of a contact. This field allows free form text entry about a contact -->
    <string name="label_notes">Notes</string>

    <!-- The label describing the SIP address field of a contact. [CHAR LIMIT=20] -->
    <string name="label_sip_address">Internet call</string>

    <!-- Hint text for the organization name when editing -->
    <string name="ghostData_company">Company</string>

    <!-- Hint text for the organization title when editing -->
    <string name="ghostData_title">Title</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>

    <!-- Header that expands to list all of the types of phone numbers when editing or creating a phone number for a contact [CHAR LIMIT=20] -->
    <string name="phoneLabelsGroup">Phone</string>

    <!-- Header that expands to list all of the types of email addresses when editing or creating an email address for a contact [CHAR LIMIT=20] -->
    <string name="emailLabelsGroup">Email</string>

    <!-- Header that expands to list all of the types of IM account when editing or creating an IM account for a contact [CHAR LIMIT=20] -->
    <string name="imLabelsGroup">IM</string>

    <!-- Header that expands to list all of the types of postal addresses when editing or creating an postal address for a contact [CHAR LIMIT=20] -->
    <string name="postalLabelsGroup">Address</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 the contacts list is empty while displaying results after searching contacts -->
    <string name="noMatchingContacts">No matching contacts found.</string>

    <!-- The text displayed when the contacts list is empty while displaying only contacts that have phone numbers -->
    <string name="noContactsWithPhoneNumbers">No contacts with phone numbers.</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>

    <!-- Displayed in a spinner dialog as user changes to display options are saved -->
    <string name="savingDisplayGroups">Saving display options\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 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 visible when "Only contacts with phones" not selected -->
    <plurals name="listTotalAllContacts">
        <item quantity="one">1 contact</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> contacts</item>
    </plurals>

    <!-- Displayed at the top of the contacts showing the zero total number of contacts visible when "All contacts" is selected  [CHAR LIMIT=64]-->
    <string name="listTotalAllContactsZero">No contacts.</string>

    <!-- Displayed at the top of the contacts showing the zero total number of contacts visible when "Custom" is selected  [CHAR LIMIT=64]-->
    <string name="listTotalAllContactsZeroCustom">No visible contacts.</string>

    <!-- Displayed at the top of the contacts showing the zero total number of contacts visible when starred contact list is selected  [CHAR LIMIT=64]-->
    <string name="listTotalAllContactsZeroStarred">No favorites.</string>

    <!-- Displayed at the top of the contacts showing the zero total number of contacts visible when a group or account is selected  [CHAR LIMIT=64]-->
    <string name="listTotalAllContactsZeroGroup">No contacts in <xliff:g id="name" example="Friends">%s</xliff:g></string>

    <!-- Displayed at the top of the contacts showing the account filter selected  [CHAR LIMIT=64] -->
    <string name="listAllContactsInAccount">Contacts in <xliff:g id="name" example="abc@gmail.com">%s</xliff:g></string>

    <!-- Displayed at the top of the contacts showing single contact. [CHAR LIMIT=64] -->
    <string name="listSingleContact">Single contact</string>

    <!-- Displayed at the top of the contacts showing single contact. [CHAR LIMIT=64] -->
    <string name="listCustomView">Contacts in custom view</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 search results indicating that more contacts were found than shown [CHAR LIMIT=64] -->
    <string name="foundTooManyContacts">More than <xliff:g id="count">%d</xliff:g> found.</string>

    <!-- 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 content description for the "all contacts" tab.

         Note: AccessibilityServices use this attribute to announce what the view represents.
         This is especially valuable for views without textual representation like ImageView.

         [CHAR LIMIT=NONE] -->
    <string name="contactsAllLabel">All contacts</string>

    <!-- The content description text for the groups tab.

         Note: AccessibilityServices use this attribute to announce what the view represents.
         This is especially valuable for views without textual representation like ImageView.

         [CHAR LIMIT=NONE] -->
    <string name="contactsGroupsLabel">Groups</string>

    <!-- The description text for the favorites tab.

         Note: AccessibilityServices use this attribute to announce what the view represents.
         This is especially valuable for views without textual representation like ImageView.

         [CHAR LIMIT=NONE] -->
    <string name="contactsFavoritesLabel">Favorites</string>

    <!-- The description text for the favorites and all contacts tab in the phone app.
         [CHAR LIMIT=NONE] -->
    <string name="dialerAllContactsLabel">Favorites and all contacts</string>

    <!-- The description text for the dialer tab.

         Note: AccessibilityServices use this attribute to announce what the view represents.
         This is especially valuable for views without textual representation like ImageView.

         [CHAR LIMIT=NONE] -->
    <string name="dialerIconLabel">Phone</string>

    <!-- The description text for the call log tab.

         Note: AccessibilityServices use this attribute to announce what the view represents.
         This is especially valuable for views without textual representation like ImageView.

         [CHAR LIMIT=NONE] -->
    <string name="recentCallsIconLabel">Call log</string>

    <!-- Menu item used to send an SMS or MMS message to a phone number  -->
    <string name="menu_sendTextMessage">Send text message</string>

    <!-- Menu item used to call a contact from the call log -->
    <string name="recentCalls_callNumber">Call <xliff:g id="name">%s</xliff:g></string>

    <!-- Menu item used to copy a number from the call log to the dialer so it can be edited before calling it -->
    <string name="recentCalls_editNumberBeforeCall">Edit number before call</string>

    <!-- Menu item used to add a number from the call log to contacts -->
    <string name="recentCalls_addToContact">Add to contacts</string>

    <!-- Menu item used to remove a single call from the call log -->
    <string name="recentCalls_removeFromRecentList">Remove from call log</string>

    <!-- Menu item used to remove all calls from the call log -->
    <string name="recentCalls_deleteAll">Clear call log</string>

    <!-- Menu item used to delete a voicemail. [CHAR LIMIT=30] -->
    <string name="recentCalls_trashVoicemail">Delete voicemail</string>

    <!-- Menu item used to share a voicemail. [CHAR LIMIT=30] -->
    <string name="recentCalls_shareVoicemail">Share voicemail</string>

    <!-- Text displayed when the call log is empty -->
    <string name="recentCalls_empty">Call log is empty.</string>

    <!-- Title of the confirmation dialog for clearing the call log. [CHAR LIMIT=37]  -->
    <string name="clearCallLogConfirmation_title">Clear call log?</string>

    <!-- Confirmation dialog for clearing the call log. [CHAR LIMIT=NONE]  -->
    <string name="clearCallLogConfirmation">All your call records will be deleted.</string>

    <!-- Title of the "Clearing call log" progress-dialog [CHAR LIMIT=35] -->
    <string name="clearCallLogProgress_title">Clearing call log\u2026</string>

    <!-- Title of the confirmation dialog for clearing frequents. [CHAR LIMIT=37] -->
    <string name="clearFrequentsConfirmation_title">Clear frequently contacted?</string>

    <!-- Confirmation dialog for clearing frequents. [CHAR LIMIT=NONE] -->
    <string name="clearFrequentsConfirmation">You\'ll clear the frequently contacted list in the People and Phone apps, and force email apps to learn your addressing preferences from scratch.</string>

    <!-- Title of the "Clearing frequently contacted" progress-dialog [CHAR LIMIT=35] -->
    <string name="clearFrequentsProgress_title">Clearing frequently contacted\u2026</string>

    <!-- The title of a dialog that displays the IMEI of the phone -->
    <string name="imei">IMEI</string>

    <!-- The title of a dialog that displays the MEID of the CDMA phone -->
    <string name="meid">MEID</string>

    <!-- String used for displaying calls to the voicemail number in the call log -->
    <string name="voicemail">Voicemail</string>

    <!-- String used to display calls from unknown numbers in the call log -->
    <string name="unknown">Unknown</string>

    <!-- String used to display calls from private numbers in the call log -->
    <string name="private_num">Private number</string>

    <!-- String used to display calls from pay phone in the call log -->
    <string name="payphone">Pay phone</string>

    <!-- Displayed in the text entry box in the dialer when in landscape mode to guide the user
         to dial using the physical keyboard -->
    <string name="dialerKeyboardHintText">Use keyboard to dial</string>

    <!-- Hint text displayed in the "digits" field above the dialer's
         dialpad, if there's already a call in progress.  (This hint
         reminds the user that the dialer will add a new call, as opposed
         to sending DTMF tones over the current call.)
         [CHAR LIMIT=40] -->
    <string name="dialerDialpadHintText">Dial to add a call</string>

    <!-- Dialog text displayed when loading a phone number from the SIM card for speed dial -->
    <string name="simContacts_emptyLoading">Loading from SIM card\u2026</string>

    <!-- Dialog title displayed when loading a phone number from the SIM card for speed dial -->
    <string name="simContacts_title">SIM card contacts</string>

    <!-- Displayed full screen when the user want to create a shortcut, but there is no contacts, and contact syncing is enabled -->
    <string name="noContactsHelpTextWithSyncForCreateShortcut">"You don't have any contacts to display. (If you just added an account, it can take a few minutes to sync contacts.)"</string>

    <!-- Displayed full screen when the user want to create a shortcut, but there is no contacts -->
    <string name="noContactsHelpTextForCreateShortcut">"You don't have any contacts to display."</string>

    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is disabled.  [CHAR LIMIT=NONE] -->
    <string name="noContactsHelpText" product="tablet">"You don't have any contacts to display.\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the tablet\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/export</b></font> to import contacts from your SIM or SD card\n</li>"
    </string>
    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is disabled.  [CHAR LIMIT=NONE] -->
    <string name="noContactsHelpText" product="default">"You don't have any contacts to display.\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the phone\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SIM or SD card\n</li>"
    </string>

    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is enabled.  [CHAR LIMIT=NONE] -->
    <string name="noContactsHelpTextWithSync" product="tablet">"You don't have any contacts to display. (If you just added an account, it can take a few minutes to sync contacts.)\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the tablet\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Display options</b></font> to change which contacts are visible\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SIM or SD card\n</li>"
    </string>
    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is enabled.  [CHAR LIMIT=NONE] -->
    <string name="noContactsHelpTextWithSync" product="default">"You don't have any contacts to display. (If you just added an account, it can take a few minutes to sync contacts.)\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the phone\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Display options</b></font> to change which contacts are visible\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SIM or SD card\n</li>"
    </string>

    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is disabled, and there is no sim card (cdma).  [CHAR LIMIT=NONE]-->
    <string name="noContactsNoSimHelpText" product="tablet">"You don't have any contacts to display.\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the tablet\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SD card\n</li>"
    </string>
    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is disabled, and there is no sim card (cdma).  [CHAR LIMIT=NONE]-->
    <string name="noContactsNoSimHelpText" product="default">"You don't have any contacts to display.\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the phone\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SD card\n</li>"
    </string>

    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is enabled, and there is no sim card (cdma).  [CHAR LIMIT=NONE] -->
    <string name="noContactsNoSimHelpTextWithSync" product="tablet">"You don't have any contacts to display. (If you just added an account, it can take a few minutes to sync contacts.)\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the tablet\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Display options</b></font> to change which contacts are visible\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SD card\n</li>"
    </string>
    <!-- Displayed full screen when the user has no contacts and they are displaying the My Contacts group, and contact syncing is enabled, and there is no sim card (cdma).  [CHAR LIMIT=NONE] -->
    <string name="noContactsNoSimHelpTextWithSync" product="default">"You don't have any contacts to display. (If you just added an account, it can take a few minutes to sync contacts.)\n\nTo add contacts, touch <font fgcolor="#ffffffff"><b>Menu</b></font>, then touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or set up an account with contacts you can sync to the phone\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Display options</b></font> to change which contacts are visible\n</li>
        \n<li><font fgcolor="#ffffffff"><b>New contact</b></font> to create a new contact from scratch\n</li>
        \n<li><font fgcolor="#ffffffff"><b>Import/Export</b></font> to import contacts from your SD card\n</li>"
    </string>

    <!-- Displayed full screen when the user has no favorites and they are displaying the favorites tab. [CHAR LIMIT=NONE] -->
    <string name="noFavoritesHelpText">"You don't have any favorites.\n\nTo add a contact to your list of favorites:\n
        <li>Touch the <b>Contacts</b> tab\n</li>
        \n<li>Touch the contact you want to add to your favorites\n</li>
        \n<li>Touch the star next to the contact\'s name\n</li>"
    </string>

    <!-- Item label: jump to the in-call DTMF dialpad.
         (Part of a list of options shown in the dialer when another call
         is already in progress.) -->
    <string name="dialer_useDtmfDialpad">Use touch tone keypad</string>

    <!-- Item label: jump to the in-call UI.
         (Part of a list of options shown in the dialer when another call
         is already in progress.) -->
    <string name="dialer_returnToInCallScreen">Return to call in progress</string>

    <!-- Item label: use the Dialer's dialpad to add another call.
         (Part of a list of options shown in the dialer when another call
         is already in progress.) -->
    <string name="dialer_addAnotherCall">Add call</string>

    <!-- Title bar for call detail screen -->
    <string name="callDetailTitle">Call details</string>

    <!-- Toast for call detail screen when couldn't read the requested details -->
    <string name="toast_call_detail_error">Couldn\'t read details for the requested call.</string>

    <!-- Title for incoming call details screen -->
    <string name="type_incoming">Incoming call</string>

    <!-- Title for outgoing call details screen -->
    <string name="type_outgoing">Outgoing call</string>

    <!-- Title for missed call details screen -->
    <string name="type_missed">Missed call</string>

    <!-- Title for voicemail details screen -->
    <string name="type_voicemail">Voicemail</string>

    <!-- Description for incoming calls going to voice mail vs. not -->
    <string name="actionIncomingCall">Incoming calls</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>

    <!-- A nicely formatted call duration displayed when viewing call details. For example "42 mins 28 secs" -->
    <string name="callDetailsDurationFormat"><xliff:g id="minutes" example="42">%s</xliff:g> mins <xliff:g id="seconds" example="28">%s</xliff:g> secs</string>

    <!-- The text displayed on the divider for the Favorites tab in People app indicating that items below it are frequently contacted [CHAR LIMIT = 39] -->
    <string name="favoritesFrequentContacted">Frequently contacted</string>

    <!-- The text displayed on the divider for the Favorites tab in Phone app indicating that items below it are frequently called as opposed to starred contacts [CHAR LIMIT = 39] -->
    <string name="favoritesFrequentCalled">Frequently called</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 image on ImageButton one

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_one">one</string>

    <!-- String describing the image on ImageButton two

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_two">two</string>

    <!-- String describing the image on ImageButton three

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_three">three</string>

    <!-- String describing the image on ImageButton four

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_four">four</string>

    <!-- String describing the image on ImageButton five

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_five">five</string>

    <!-- String describing the image on ImageButton six

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_six">six</string>

    <!-- String describing the image on ImageButton seven

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_seven">seven</string>

    <!-- String describing the image on ImageButton eight

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_eight">eight</string>

    <!-- String describing the image on ImageButton nine

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_nine">nine</string>

    <!-- String describing the image on ImageButton star

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_star">star</string>

    <!-- String describing the image on ImageButton zero

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_zero">zero</string>

    <!-- String describing the image on ImageButton pound

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_image_button_pound">pound</string>

    <!-- String describing the Voicemail ImageButton

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

    <!-- String describing the Search ImageButton

         Used by AccessibilityService to announce the purpose of the button.
         [CHAR LIMIT=NONE]
    -->
    <string name="description_search_button">search</string>

    <!-- String describing the Dial ImageButton

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

    <!-- String describing the Delete/Backspace ImageButton

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

    <!-- String describing the digits text box containing the number to dial.

         Used by AccessibilityService to announce the purpose of the view.
    -->
    <string name="description_digits_edittext">number to dial</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 Minus button

         Used by AccessibilityService to announce the purpose of the button.

         [CHAR LIMIT=NONE]
    -->
    <string name="description_minus_button">delete</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>

    <!-- String describing a contact picture that introduces users to the contact detail screen.

         Used by AccessibilityService to announce the purpose of the button.

         [CHAR LIMIT=NONE]
      -->
    <string name="description_view_contact_detail" msgid="2795575601596468581">View contact</string>

    <!-- Dialog message shown when (USB) storage does not exist [CHAR LIMIT=30] -->
    <string name="no_sdcard_message" product="nosdcard">No storage was found.</string>
    <!-- Dialog message shown when SDcard does not exist. [CHAR LIMIT=30] -->
    <string name="no_sdcard_message" product="default">No SD card was found.</string>

    <!-- Action string for selecting SIM for importing contacts -->
    <string name="import_from_sim">Import from SIM card</string>

    <!-- Action string for selecting (USB) storage for importing contacts [CHAR LIMIT=25] -->
    <string name="import_from_sdcard" product="default">Import from storage</string>

    <!-- Action that exports all contacts to (USB) storage [CHAR LIMIT=25] -->
    <string name="export_to_sdcard" product="default">Export to storage</string>

    <!-- Action that shares visible contacts -->
    <string name="share_visible_contacts">Share visible contacts</string>

    <!-- One of alternatives shown when the system allows a user to select how many vCard files
         should be imported. This message shows only when the system is certain that there's more
         than one vCard files available in the system. -->
    <string name="import_one_vcard_string">Import one vCard file</string>

    <!-- One of alternatives shown when the system allows a user to select how many vCard files
         should be imported. This message shows only when the system is certain that there's more
         than one vCard files available in the system. -->
    <string name="import_multiple_vcard_string">Import multiple vCard files</string>

    <!-- One of alternatives shown when the system allows a user to select how many vCard files
         should be imported. This message shows only when the system is certain that there's more
         than one vCard files available in the system. -->
    <string name="import_all_vcard_string">Import all vCard files</string>

    <!-- Dialog message shown when searching VCard data from (USB) storage [CHAR LIMIT=NONE] -->
    <string name="searching_vcard_message" product="nosdcard">Searching for vCard data in storage\u2026</string>
    <!-- Dialog message shown when searching VCard data from SD Card. [CHAR LIMIT=NONE] -->
    <string name="searching_vcard_message" product="default">Searching for vCard data on SD card\u2026</string>

    <!-- Dialog message shown when searching VCard data failed.
         An exact reason for the failure should [CHAR LIMIT=NONE] -->
    <string name="scanning_sdcard_failed_message" product="nosdcard">The storage couldn\'t be scanned. (Reason: \"<xliff:g id="fail_reason">%s</xliff:g>\")</string>
    <!-- Dialog message shown when searching VCard data failed.
         An exact reason for the failure should [CHAR LIMIT=NONE] -->
    <string name="scanning_sdcard_failed_message" product="default">The SD card couldn\'t be scanned. (Reason: \"<xliff:g id="fail_reason">%s</xliff:g>\")</string>

    <!-- The failed reason shown when Contacts app (especially vCard importer/exporter)
         emitted some I/O error. Exact reason will be appended by the system. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_io_error">I/O error</string>

    <!-- Failure reason show when Contacts app (especially vCard importer) encountered
         low memory problem and could not proceed its import procedure. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_low_memory_during_import">Not enough memory. The file may be too large.</string>

    <!-- The failed reason shown when vCard parser was not able to be parsed by the current vCard
         implementation. This might happen even when the input vCard is completely valid, though
         we believe it is rather rare in the actual world. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_vcard_parse_error">Couldn\'t parse vCard for an unexpected reason.</string>

    <!-- The failed reason shown when vCard importer doesn't support the format.
         This may be shown when the vCard is corrupted [CHAR LIMIT=40] -->
    <string name="fail_reason_not_supported">The format isn\'t supported.</string>

    <!-- Message used when vCard import has failed. [CHAR LIMIT=40] -->
    <string name="vcard_import_failed">Couldn\'t import vCard.</string>

    <!-- The failure message shown when the system could not find any vCard file.
         (with extension ".vcf" in (USB) storage.)
         [CHAR LIMIT=128] -->
    <string name="import_failure_no_vcard_file" product="nosdcard">No vCard file found in storage.</string>
    <!-- The failure message shown when the system could not find any vCard file.
         (with extension ".vcf" in SDCard.)
         [CHAR LIMIT=128] -->
    <string name="import_failure_no_vcard_file" product="default">No vCard file found on the SD card.</string>

    <!-- Fail reason shown when vCard importer failed to look over meta information stored in vCard file(s). -->
    <string name="fail_reason_failed_to_collect_vcard_meta_info">Couldn\'t collect meta information of given vCard file(s).</string>

    <!-- The failed reason shown when the import of some of vCard files failed during multiple vCard
         files import. It includes the case where all files were failed to be imported. -->
    <string name="fail_reason_failed_to_read_files">One or more files couldn\'t be imported (%s).</string>

    <!-- The failed reason which should not be shown but it may in some buggy condition. [CHAR LIMIT=40] -->
    <string name="fail_reason_unknown">Unknown error.</string>

    <!-- Dialog title shown when a user is asked to select vCard file. [CHAR LIMIT=25] -->
    <string name="select_vcard_title">Choose vCard file</string>

    <!-- The title shown when vCard importer is caching files to be imported into local temporary
         data storage.  [CHAR LIMIT=40] -->
    <string name="caching_vcard_title">Caching</string>

    <!-- The message shown when vCard importer is caching files to be imported into local temporary
         data storage. [CHAR LIMIT=NONE] -->
    <string name="caching_vcard_message">Caching vCard(s) to local temporary storage. The actual import will start soon.</string>

    <!-- The message shown while importing vCard(s).
         First argument is current index of contacts to be imported.
         Second argument is the total number of contacts.
         Third argument is the name of a contact which is being read.
         [CHAR LIMIT=20] -->
    <string name="progress_notifier_message">Importing <xliff:g id="current_number">%s</xliff:g>/<xliff:g id="total_number">%s</xliff:g>: <xliff:g id="name" example="Joe Due">%s</xliff:g></string>

    <!-- Description shown when importing vCard data.
         The argument is the name of a contact which is being read.
         [CHAR LIMIT=20] -->
    <string name="importing_vcard_description">Importing <xliff:g id="name" example="Joe Due">%s</xliff:g></string>

    <!-- Dialog title shown when reading vCard data failed [CHAR LIMIT=40] -->
    <string name="reading_vcard_failed_title">Couldn\'t read vCard data</string>

    <!-- The title shown when reading vCard is canceled (probably by a user)
         [CHAR LIMIT=40] -->
    <string name="reading_vcard_canceled_title">Reading vCard data canceled</string>

    <!-- The title shown when reading vCard finished
         The argument is file name the user imported.
         [CHAR LIMIT=40] -->
    <string name="importing_vcard_finished_title">Finished importing vCard <xliff:g id="filename" example="import.vcf">%s</xliff:g></string>

    <!-- The title shown when importing vCard is canceled (probably by a user)
         The argument is file name the user canceled importing.
         [CHAR LIMIT=40] -->
    <string name="importing_vcard_canceled_title">Importing <xliff:g id="filename" example="import.vcf">%s</xliff:g> canceled</string>

    <!-- The message shown when vCard import request is accepted. The system may start that work soon, or do it later
         when there are already other import/export requests.
         The argument is file name the user imported.
         [CHAR LIMIT=40] -->
    <string name="vcard_import_will_start_message"><xliff:g id="filename" example="import.vcf">%s</xliff:g> will be imported shortly.</string>
    <!-- The message shown when vCard import request is accepted. The system may start that work soon, or do it later when there are already other import/export requests.
         "The file" is what a user selected for importing.
         [CHAR LIMIT=40] -->
    <string name="vcard_import_will_start_message_with_default_name">The file will be imported shortly.</string>
    <!-- The message shown when a given vCard import request is rejected by the system. [CHAR LIMIT=NONE] -->
    <string name="vcard_import_request_rejected_message">vCard import request was rejected. Try again later.</string>
    <!-- The message shown when vCard export request is accepted. The system may start that work soon, or do it later
         when there are already other import/export requests.
         The argument is file name the user exported.
         [CHAR LIMIT=40] -->
    <string name="vcard_export_will_start_message"><xliff:g id="filename" example="import.vcf">%s</xliff:g> will be exported shortly.</string>
    <!-- The message shown when a given vCard export request is rejected by the system. [CHAR LIMIT=NONE] -->
    <string name="vcard_export_request_rejected_message">vCard export request was rejected. Try again later.</string>
    <!-- Used when file name is unknown in vCard processing. It typically happens
         when the file is given outside the Contacts app. [CHAR LIMIT=30] -->
    <string name="vcard_unknown_filename">contact</string>

    <!-- The percentage, used for expressing the progress of vCard import/export. -->
    <string name="percentage"><xliff:g id="percentage" example="50">%s</xliff:g><xliff:g id="percentsign" example="%">%%</xliff:g></string>

    <!-- Dialog title shown when a user confirms whether he/she export Contact data. [CHAR LIMIT=32] -->
    <string name="confirm_export_title">Export contacts?</string>

    <!-- Dialog message shown when a user confirms whether he/she export Contact data [CHAR LIMIT=NONE] -->
    <string name="confirm_export_message">Your contact list will be exported to file: <xliff:g id="vcard_filename">%s</xliff:g>.</string>

    <!-- Dialog title shown when exporting Contact data failed. [CHAR LIMIT=20] -->
    <string name="exporting_contact_failed_title">Couldn\'t export</string>

    <!-- Dialog message shown when exporting Contact data failed. [CHAR LIMIT=NONE] -->
    <string name="exporting_contact_failed_message">The contact data wasn\'t exported.\nReason: \"<xliff:g id="fail_reason">%s</xliff:g>\"</string>

    <!-- The failed reason shown when there's no contact which is allowed to be exported.
         Note that user may have contacts data but all of them are probably not allowed to be
         exported because of security/permission reasons. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_no_exportable_contact">There is no exportable contact.</string>

    <!-- The failed reason shown when vCard exporter could not create a file for the vCard since
         there are too many files relevant to vCard. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_too_many_vcard" product="nosdcard">Too many vCard files are in the storage.</string>
    <!-- The failed reason shown when vCard exporter could not create a file for the vCard since
         there are too many files relevant to vCard. -->
    <string name="fail_reason_too_many_vcard" product="default">Too many vCard files are on the SD card.</string>

    <!-- The failed reason shown when the given file name is too long for the system.
         The length limit of each file is different in each Android device, so we don't need to
         mention it here. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_too_long_filename">Required filename is too long (\"<xliff:g id="filename">%s</xliff:g>\").</string>

    <!-- The title shown when exporting vCard is successfuly finished [CHAR LIMIT=40] -->
    <string name="exporting_vcard_finished_title">Finished exporting <xliff:g id="filename" example="export.vcf">%s</xliff:g>.</string>

    <!-- The title shown when exporting vCard is canceled (probably by a user)
         The argument is file name the user canceled importing.
         [CHAR LIMIT=40] -->
    <string name="exporting_vcard_canceled_title">Exporting <xliff:g id="filename" example="export.vcf">%s</xliff:g> canceled.</string>

    <!-- Dialog title shown when the application is exporting contact data outside. [CHAR LIMIT=NONE] -->
    <string name="exporting_contact_list_title">Exporting contact data</string>

    <!-- Message shown when the application is exporting contact data outside -->
    <string name="exporting_contact_list_message">Your contact data is being exported to: <xliff:g id="file_name">%s</xliff:g>.</string>

    <!-- The failed reason shown when contacts exporter fails to be initialized.
         Some exact reason must follow this. [CHAR LIMIT=NONE]-->
    <string name="fail_reason_could_not_initialize_exporter">Couldn\'t start the exporter: \"<xliff:g id="exact_reason">%s</xliff:g>\".</string>

    <!-- The failed reason shown when some error happend during contacts export.
         Some exact reason must follow this. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_error_occurred_during_export">An error occurred during export: \"<xliff:g id="exact_reason">%s</xliff:g>\".</string>

    <!-- The error reason the vCard composer "may" emit when database is corrupted or
         something is going wrong. Usually users should not see this text. [CHAR LIMIT=NONE] -->
    <string name="composer_failed_to_get_database_infomation">Couldn\'t get database information.</string>

    <!-- This error message shown when the user actually have no contact
         (e.g. just after data-wiping), or, data providers of the contact list prohibits their
         contacts from being exported to outside world via vcard exporter, etc. [CHAR LIMIT=NONE] -->
    <string name="composer_has_no_exportable_contact" product="tablet">There are no exportable contacts. If you do have contacts on your tablet, some data providers may not allow the contacts to be exported from the tablet.</string>
    <!-- This error message shown when the user actually have no contact
         (e.g. just after data-wiping), or, data providers of the contact list prohibits their
         contacts from being exported to outside world via vcard exporter, etc. [CHAR LIMIT=NONE] -->
    <string name="composer_has_no_exportable_contact" product="default">There are no exportable contacts. If you do have contacts on your phone, some data providers may not allow the contacts to be exported from the phone.</string>

    <!-- The error reason the vCard composer may emit when vCard composer is not initialized
         even when needed.
         Users should not usually see this error message. [CHAR LIMIT=NONE] -->
    <string name="composer_not_initialized">The vCard composer didn\'t start properly.</string>

    <!-- The failed reason shown when vCard importer/exporter could not open the file
         specified by a user. The file name should be in the message. [CHAR LIMIT=NONE] -->
    <string name="fail_reason_could_not_open_file">Couldn\'t open \"<xliff:g id="file_name">%s</xliff:g>\": <xliff:g id="exact_reason">%s</xliff:g>.</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>

    <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard import.
         The argument is file name for the vCard import the user wants to cancel.
         [CHAR LIMIT=128] -->
    <string name="cancel_import_confirmation_message">Cancel import of <xliff:g id="filename" example="import.vcf">%s</xliff:g>?</string>

    <!-- Message shown in a Dialog confirming a user's cancel request toward existing vCard export.
         The argument is file name for the vCard export the user wants to cancel.
         [CHAR LIMIT=128] -->
    <string name="cancel_export_confirmation_message">Cancel export of <xliff:g id="filename" example="export.vcf">%s</xliff:g>?</string>

    <!-- Title shown in a Dialog telling users cancel vCard import/export operation is failed. [CHAR LIMIT=40] -->
    <string name="cancel_vcard_import_or_export_failed">Couldn\'t cancel vCard import/export</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>

    <!-- Menu items for dialpad options as part of Pause and Wait ftr -->
    <string name="add_2sec_pause">Add 2-sec pause</string>
    <string name="add_wait">Add wait</string>

    <!-- Title for the call disambiguation dialog -->
    <string name="call_disambig_title">Choose number</string>

    <!-- Menu item label for call settings [CHAR LIMIT=30] -->
    <string name="call_settings">Settings</string>

    <!-- Title for the sms disambiguation dialog -->
    <string name="sms_disambig_title">Choose number</string>

    <!-- Message next to disamgiguation dialog check box -->
    <string name="make_primary">Remember this choice</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>

    <!-- Shown as the display name for a person when the name is missing or unknown. [CHAR LIMIT=18]-->
    <string name="missing_name">(No name)</string>

    <!-- The menu item to open the list of accounts -->
    <string name="menu_accounts">Accounts</string>

    <!--  The menu item to clear frequents [CHAR LIMIT=30] -->
    <string name="menu_clear_frequents">Clear frequents</string>

    <!-- The menu item to filter the list of contacts displayed -->
    <string name="menu_contacts_filter">Contacts to display</string>

    <!-- The menu item to bulk import or bulk export contacts from SIM card or SD card.  [CHAR LIMIT=30]-->
    <string name="menu_import_export">Import/export</string>

    <!-- Dialog title when selecting the bulk operation to perform from a list. [CHAR LIMIT=36] -->
    <string name="dialog_import_export">Import/export contacts</string>

    <!-- Dialog title when importing contacts from an external source. [CHAR LIMIT=36] -->
    <string name="dialog_import">Import contacts</string>

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

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

    <!-- Toast indicating that sharing a contact has failed. [CHAR LIMIT=NONE]  -->
    <string name="share_error">This contact can\'t be shared.</string>

    <!-- Header that expands to list all name types when editing a structured name of a contact [CHAR LIMIT=20] -->
    <string name="nameLabelsGroup">Name</string>
    <!-- Header that expands to list all nickname types when editing a nickname of a contact [CHAR LIMIT=20] -->
    <string name="nicknameLabelsGroup">Nickname</string>
    <!-- Header that expands to list all organization types when editing an organization of a contact [CHAR LIMIT=20] -->
    <string name="organizationLabelsGroup">Organization</string>
    <!-- Header that expands to list all website types when editing a website of a contact [CHAR LIMIT=20] -->
    <string name="websiteLabelsGroup">Website</string>
    <!-- Header that expands to list all event types when editing an event of a contact [CHAR LIMIT=20] -->
    <string name="eventLabelsGroup">Events</string>
    <!-- Header for the list of all relationships for a contact [CHAR LIMIT=20] -->
    <string name="relationLabelsGroup">Relationship</string>
    <!-- Header for the list of all groups for a contact [CHAR LIMIT=20] -->
    <string name="groupsLabel">Groups</string>

    <string name="dialog_new_contact_account">Create contact under account</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>

    <string name="menu_sync_remove">Remove sync group</string>
    <string name="dialog_sync_add">Add sync group</string>
    <string name="display_more_groups">More groups\u2026</string>

    <!-- List title for a special contacts group that covers all contacts. [CHAR LIMIT=25] -->
    <string name="display_ungrouped">All other contacts</string>

    <!-- List title for a special contacts group that covers all contacts that
         aren't members of any other group. [CHAR LIMIT=25] -->
    <string name="display_all_contacts">All contacts</string>

    <!-- Warning message given to users just before they remove a currently syncing
         group that would also cause all ungrouped contacts to stop syncing.  [CHAR LIMIT=NONE] -->
    <string name="display_warn_remove_ungrouped">Removing \"<xliff:g id="group" example="Starred">%s</xliff:g>\" from sync will also remove any ungrouped contacts from sync.</string>

    <!-- Title for data source when creating or editing a contact that doesn't
         belong to a specific account.  This contact will only exist on the phone
         and will not be synced. -->
    <string name="account_phone" product="tablet">Tablet-only, unsynced</string>
    <!-- Title for data source when creating or editing a contact that doesn't
         belong to a specific account.  This contact will only exist on the phone
         and will not be synced. -->
    <string name="account_phone" product="default">Phone-only, unsynced</string>

    <!-- Action string for calling a custom phone number -->
    <string name="call_custom">Call <xliff:g id="custom">%s</xliff:g></string>
    <!-- Action string for calling a home phone number -->
    <string name="call_home">Call home</string>
    <!-- Action string for calling a mobile phone number -->
    <string name="call_mobile">Call mobile</string>
    <!-- Action string for calling a work phone number -->
    <string name="call_work">Call work</string>
    <!-- Action string for calling a work fax phone number -->
    <string name="call_fax_work">Call work fax</string>
    <!-- Action string for calling a home fax phone number -->
    <string name="call_fax_home">Call home fax</string>
    <!-- Action string for calling a pager phone number -->
    <string name="call_pager">Call pager</string>
    <!-- Action string for calling an other phone number -->
    <string name="call_other">Call</string>
    <!-- Action string for calling a callback number -->
    <string name="call_callback">Call callback</string>
    <!-- Action string for calling a car phone number -->
    <string name="call_car">Call car</string>
    <!-- Action string for calling a company main phone number -->
    <string name="call_company_main">Call company main</string>
    <!-- Action string for calling a ISDN phone number -->
    <string name="call_isdn">Call ISDN</string>
    <!-- Action string for calling a main phone number -->
    <string name="call_main">Call main</string>
    <!-- Action string for calling an other fax phone number -->
    <string name="call_other_fax">Call fax</string>
    <!-- Action string for calling a radio phone number -->
    <string name="call_radio">Call radio</string>
    <!-- Action string for calling a Telex phone number -->
    <string name="call_telex">Call telex</string>
    <!-- Action string for calling a TTY/TDD phone number -->
    <string name="call_tty_tdd">Call TTY/TDD</string>
    <!-- Action string for calling a work mobile phone number -->
    <string name="call_work_mobile">Call work mobile</string>
    <!-- Action string for calling a work pager phone number -->
    <string name="call_work_pager">Call work pager</string>
    <!-- Action string for calling an assistant phone number -->
    <string name="call_assistant">Call <xliff:g id="assistant">%s</xliff:g></string>
    <!-- Action string for calling a MMS phone number -->
    <string name="call_mms">Call MMS</string>

    <!-- Action string for sending an SMS to a custom phone number -->
    <string name="sms_custom">Text <xliff:g id="custom">%s</xliff:g></string>
    <!-- Action string for sending an SMS to a home phone number -->
    <string name="sms_home">Text home</string>
    <!-- Action string for sending an SMS to a mobile phone number -->
    <string name="sms_mobile">Text mobile</string>
    <!-- Action string for sending an SMS to a work phone number -->
    <string name="sms_work">Text work</string>
    <!-- Action string for sending an SMS to a work fax phone number -->
    <string name="sms_fax_work">Text work fax</string>
    <!-- Action string for sending an SMS to a home fax phone number -->
    <string name="sms_fax_home">Text home fax</string>
    <!-- Action string for sending an SMS to a pager phone number -->
    <string name="sms_pager">Text pager</string>
    <!-- Action string for sending an SMS to an other phone number -->
    <string name="sms_other">Text</string>
    <!-- Action string for sending an SMS to a callback number -->
    <string name="sms_callback">Text callback</string>
    <!-- Action string for sending an SMS to a car phone number -->
    <string name="sms_car">Text car</string>
    <!-- Action string for sending an SMS to a company main phone number -->
    <string name="sms_company_main">Text company main</string>
    <!-- Action string for sending an SMS to a ISDN phone number -->
    <string name="sms_isdn">Text ISDN</string>
    <!-- Action string for sending an SMS to a main phone number -->
    <string name="sms_main">Text main</string>
    <!-- Action string for sending an SMS to an other fax phone number -->
    <string name="sms_other_fax">Text fax</string>
    <!-- Action string for sending an SMS to a radio phone number -->
    <string name="sms_radio">Text radio</string>
    <!-- Action string for sending an SMS to a Telex phone number -->
    <string name="sms_telex">Text telex</string>
    <!-- Action string for sending an SMS to a TTY/TDD phone number -->
    <string name="sms_tty_tdd">Text TTY/TDD</string>
    <!-- Action string for sending an SMS to a work mobile phone number -->
    <string name="sms_work_mobile">Text work mobile</string>
    <!-- Action string for sending an SMS to a work pager phone number -->
    <string name="sms_work_pager">Text work pager</string>
    <!-- Action string for sending an SMS to an assistant phone number -->
    <string name="sms_assistant">Text <xliff:g id="assistant">%s</xliff:g></string>
    <!-- Action string for sending an SMS to a MMS phone number -->
    <string name="sms_mms">Text MMS</string>

    <!-- Generic action string for text messaging a contact. Used by AccessibilityService to announce the purpose of the view. [CHAR LIMIT=NONE] -->
    <string name="sms">Text message</string>

    <!-- Action string for sending an email to a home email address -->
    <string name="email_home">Email home</string>
    <!-- Action string for sending an email to a mobile email address -->
    <string name="email_mobile">Email mobile</string>
    <!-- Action string for sending an email to a work email address -->
    <string name="email_work">Email work</string>
    <!-- Action string for sending an email to an other email address -->
    <string name="email_other">Email</string>
    <!-- Action string for sending an email to a custom email address -->
    <string name="email_custom">Email <xliff:g id="custom">%s</xliff:g></string>

    <!-- Generic action string for sending an email -->
    <string name="email">Email</string>

    <!-- Action string for viewing a home postal address -->
    <string name="map_home">View home address</string>
    <!-- Action string for viewing a work postal address -->
    <string name="map_work">View work address</string>
    <!-- Action string for viewing an other postal address -->
    <string name="map_other">View address</string>
    <!-- Action string for viewing a custom postal address -->
    <string name="map_custom">View <xliff:g id="custom">%s</xliff:g> address</string>

    <!-- Action string for starting an IM chat with the AIM protocol -->
    <string name="chat_aim">Chat using AIM</string>
    <!-- Action string for starting an IM chat with the MSN or Windows Live protocol -->
    <string name="chat_msn">Chat using Windows Live</string>
    <!-- Action string for starting an IM chat with the Yahoo protocol -->
    <string name="chat_yahoo">Chat using Yahoo</string>
    <!-- Action string for starting an IM chat with the Skype protocol -->
    <string name="chat_skype">Chat using Skype</string>
    <!-- Action string for starting an IM chat with the QQ protocol -->
    <string name="chat_qq">Chat using QQ</string>
    <!-- Action string for starting an IM chat with the Google Talk protocol -->
    <string name="chat_gtalk">Chat using Google Talk</string>
    <!-- Action string for starting an IM chat with the ICQ protocol -->
    <string name="chat_icq">Chat using ICQ</string>
    <!-- Action string for starting an IM chat with the Jabber protocol -->
    <string name="chat_jabber">Chat using Jabber</string>

    <!-- Generic action string for starting an IM chat -->
    <string name="chat">Chat</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>

    <!-- Field title for the full postal address of a contact [CHAR LIMIT=64]-->
    <string name="postal_address">Address</string>
    <!-- Field title for the street of a structured postal address of a contact -->
    <string name="postal_street">Street</string>
    <!-- Field title for the PO box of a structured postal address of a contact -->
    <string name="postal_pobox">PO box</string>
    <!-- Field title for the neighborhood of a structured postal address of a contact -->
    <string name="postal_neighborhood">Neighborhood</string>
    <!-- Field title for the city of a structured postal address of a contact -->
    <string name="postal_city">City</string>
    <!-- Field title for the region, or state, of a structured postal address of a contact -->
    <string name="postal_region">State</string>
    <!-- Field title for the postal code of a structured postal address of a contact -->
    <string name="postal_postcode">ZIP code</string>
    <!-- Field title for the country of a structured postal address of a contact -->
    <string name="postal_country">Country</string>

    <!-- Field title for the full name of a contact [CHAR LIMIT=64]-->
    <string name="full_name">Name</string>
    <!-- Field title for the given name of a contact -->
    <string name="name_given">Given name</string>
    <!-- Field title for the family name of a contact -->
    <string name="name_family">Family name</string>
    <!-- Field title for the prefix name of a contact -->
    <string name="name_prefix">Name prefix</string>
    <!-- Field title for the middle name of a contact -->
    <string name="name_middle">Middle name</string>
    <!-- Field title for the suffix name of a contact -->
    <string name="name_suffix">Name suffix</string>
    <!-- Field title for the phonetic given name of a contact -->
    <string name="name_phonetic_given">Phonetic given name</string>
    <!-- Field title for the phonetic middle name of a contact -->
    <string name="name_phonetic_middle">Phonetic middle name</string>
    <!-- Field title for the phonetic family name of a contact -->
    <string name="name_phonetic_family">Phonetic family name</string>
    <!-- Field title for the phonetic name of a contact [CHAR LIMIT=64]-->
    <string name="name_phonetic">Phonetic name</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 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>

    <!-- Checkbox asking the user if they want to display a particular photo for a contact -->
    <string name="use_photo_as_primary">Use this photo</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 describing that a contact has no information available other than name and photo. [CHAR LIMIT=60] -->
    <string name="no_contact_details">No additional information for this contact.</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>

    <!-- Label of the "sort list by" display option -->
    <string name="display_options_sort_list_by">Sort list by</string>

    <!-- An allowable value for the "sort list by" contact display option  -->
    <string name="display_options_sort_by_given_name">Given name</string>

    <!-- An allowable value for the "sort list by" contact display option  -->
    <string name="display_options_sort_by_family_name">Family name</string>

    <!-- Label of the "view names as" display option -->
    <string name="display_options_view_names_as">View contact names as</string>

    <!-- An allowable value for the "view names as" contact display option  -->
    <string name="display_options_view_given_name_first">Given name first</string>

    <!-- An allowable value for the "view names as" contact display option  -->
    <string name="display_options_view_family_name_first">Family name first</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 from Gallery</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 from Gallery</string>

    <!-- Text shown in the contacts app while the background process updates contacts after a locale change [CHAR LIMIT=300] -->
    <string name="locale_change_in_progress">Contact list is being updated to reflect the change of language.</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>

    <!-- Text shown in the contacts app if the background process updating contacts fails because of memory shortage [CHAR LIMIT=300] -->
    <string name="upgrade_out_of_memory">Contacts are in the process of being upgraded.
    \n\nThe upgrade process requires approximately <xliff:g id="size_in_megabytes">%s</xliff:g>
    MB of internal storage.\n\nChoose one of the following options:</string>

    <!-- Button shown in the contacts app if the background process updating contacts fails because of memory shortage [CHAR LIMIT=50] -->
    <string name="upgrade_out_of_memory_uninstall">Uninstall some applications</string>

    <!-- Button shown in the contacts app if the background process updating contacts fails because of memory shortage [CHAR LIMIT=50] -->
    <string name="upgrade_out_of_memory_retry">Retry upgrade</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 text displayed when the contacts list is empty while displaying only selected contacts in multiple picker -->
    <string name="no_contacts_selected">"No contacts selected."</string>

    <!-- The add field button shown in the editor under each editable Raw Contact [CHAR LIMIT=30] -->
    <string name="add_field">Add another field</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>

    <!-- Attbution of a contact status update, when the time of update is unknown -->
    <string name="contact_status_update_attribution">via <xliff:g id="source" example="Google Talk">%1$s</xliff:g></string>

    <!-- Attbution of a contact status update, when the time of update is known -->
    <string name="contact_status_update_attribution_with_date"><xliff:g id="date" example="3 hours ago">%1$s</xliff:g> via <xliff:g id="source" example="Google Talk">%2$s</xliff:g></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 name of the invisible local contact directory -->
    <string name="local_invisible_directory">Other</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_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>

    <!-- The label in section header in the contact list for a contact directory [CHAR LIMIT=128] -->
    <string name="directory_search_label">Directory</string>

    <!-- The label in section header in the contact list for a local contacts [CHAR LIMIT=128] -->
    <string name="local_search_label">All contacts</string>

    <!-- Toast shown when creating a personal copy of a contact [CHAR LIMIT=100] -->
    <string name="toast_making_personal_copy">Creating a personal copy\u2026</string>

    <!-- Contact list filter label indicating that the list is showing all available accounts [CHAR LIMIT=64] -->
    <string name="list_filter_all_accounts">All contacts</string>

    <!-- Contact list filter label indicating that the list is showing all starred contacts [CHAR LIMIT=64] -->
    <string name="list_filter_all_starred">Starred</string>

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

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

    <!-- Contact list filter selection indicating that the list shows all contacts with phone numbers [CHAR LIMIT=64] -->
    <string name="list_filter_phones">All contacts with phone numbers</string>

    <!-- Contact list filter selection indicating that the list shows only the selected contact [CHAR LIMIT=64] -->
    <string name="list_filter_single">Contact</string>

    <!-- Title of the activity that allows the user to customize filtering of contact list [CHAR LIMIT=128] -->
    <string name="custom_list_filter">Define custom view</string>

    <!-- Message that appears in the favorites tab of the Phone app when the contact list has not fully loaded yet (below the favorite and frequent contacts) [CHAR LIMIT=20] -->
    <string name="contact_list_loading">Loading\u2026</string>

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

    <!-- Title of the activity that allows the uesr to filter the list of contacts displayed according to account [CHAR LIMIT=25] -->
    <string name="activity_title_contacts_filter">Contacts to display</string>

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

    <!-- Menu item for invoking contextual help [CHAR LIMIT=64] -->
    <string name="menu_help">Help</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>

    <!-- Query hint displayed inside the search field [CHAR LIMIT=64] -->
    <string name="hint_findContacts">Find contacts</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>

    <!-- Button to view the updates from the current group on the group detail page [CHAR LIMIT=25] -->
    <string name="view_updates_from_group">View updates</string>

    <!-- Title of the notification of new voicemails. [CHAR LIMIT=30] -->
    <plurals name="notification_voicemail_title">
        <item quantity="one">Voicemail</item>
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> Voicemails</item>
    </plurals>

    <!-- Used in the notification of a new voicemail for the action to play the voicemail. -->
    <string name="notification_action_voicemail_play">Play</string>

    <!-- Used to build a list of names or phone numbers, to indicate the callers who left
         voicemails.
         The first argument may be one or more callers, the most recent ones.
         The second argument is an additional callers.
         This string is used to build a list of callers.

         [CHAR LIMIT=10]
     -->
    <string name="notification_voicemail_callers_list"><xliff:g id="newer_callers">%1$s</xliff:g>, <xliff:g id="older_caller">%2$s</xliff:g></string>

    <!-- Text used in the ticker to notify the user of the latest voicemail. [CHAR LIMIT=30] -->
    <string name="notification_new_voicemail_ticker">New voicemail from <xliff:g id="caller">%1$s</xliff:g></string>

    <!-- Message to show when there is an error playing back the voicemail. [CHAR LIMIT=40] -->
    <string name="voicemail_playback_error">Couldn\'t play voicemail.</string>

    <!-- Message to display before we have prepared the media player, i.e. before we know duration. [CHAR LIMIT=40] -->
    <string name="voicemail_buffering">Buffering\u2026</string>

    <!-- Message to display whilst we are waiting for the content to be fetched. [CHAR LIMIT=40] -->
    <string name="voicemail_fetching_content">Fetching voicemail\u2026</string>

    <!-- Message to display if we fail to get content within a suitable time period. [CHAR LIMIT=40] -->
    <string name="voicemail_fetching_timout">Couldn\'t fetch voicemail.</string>

    <!-- The header in the call log used to identify missed calls and voicemail that have not yet been consumed [CHAR LIMIT=10] -->
    <string name="call_log_new_header">New</string>

    <!-- The header in the call log used to identify items that have been already consumed [CHAR LIMIT=10] -->
    <string name="call_log_old_header">Older</string>

    <!-- The header to show that call log is only showing voicemail calls. [CHAR LIMIT=40] -->
    <string name="call_log_voicemail_header">Calls with voicemail only</string>

    <!-- The header to show that call log is only showing incoming calls. [CHAR LIMIT=40] -->
    <string name="call_log_incoming_header">Incoming calls only</string>

    <!-- The header to show that call log is only showing outgoing calls. [CHAR LIMIT=40] -->
    <string name="call_log_outgoing_header">Outgoing calls only</string>

    <!-- The header to show that call log is only showing missed calls. [CHAR LIMIT=40] -->
    <string name="call_log_missed_header">Missed calls only</string>

    <!--  Voicemail status message shown at the top of call log to notify the user that no new
voicemails are currently available. This can happen when both notification as well as data
connection to the voicemail server is lost. [CHAR LIMIT=64] -->
    <string name="voicemail_status_voicemail_not_available">Can\'t connect to voicemail server.</string>
    <!--  Voicemail status message shown at the top of call log to notify the user that there is no
      data connection to the voicemail server, but there are new voicemails waiting on the server.
      [CHAR LIMIT=64] -->
    <string name="voicemail_status_messages_waiting">Can\'t connect to voicemail server. New voicemails are waiting.</string>
   <!--  Voicemail status message shown at the top of call log to invite the user to configure
      visual voicemail. [CHAR LIMIT=64] -->
    <string name="voicemail_status_configure_voicemail">Set up your voicemail.</string>
   <!--  Voicemail status message shown at the top of call details screen to notify the user that
      the audio of this voicemail is not available. [CHAR LIMIT=64] -->
    <string name="voicemail_status_audio_not_available">Audio not available.</string>

   <!--  User action prompt shown next to a voicemail status message to let the user configure
   visual voicemail. [CHAR LIMIT=20] -->
    <string name="voicemail_status_action_configure">Set up</string>
   <!--  User action prompt shown next to a voicemail status message to let the user call voicemail
   server directly to listen to the voicemails. [CHAR LIMIT=20] -->
    <string name="voicemail_status_action_call_server">Call voicemail</string>

    <!-- The slowest voicemail playback speed. [CHAR LIMIT=30] -->
    <string name="voicemail_speed_slowest">Slowest speed</string>
    <!-- Slower than normal voicemail playback speed. [CHAR LIMIT=30] -->
    <string name="voicemail_speed_slower">Slow speed</string>
    <!--  Normal voicemail playback speed. [CHAR LIMIT=30] -->
    <string name="voicemail_speed_normal">Normal speed</string>
    <!--  Faster than normal pvoicemail playback speed. [CHAR LIMIT=30] -->
    <string name="voicemail_speed_faster">Fast speed</string>
    <!--  Fastest voicemail playback speed. [CHAR LIMIT=30] -->
    <string name="voicemail_speed_fastest">Fastest speed</string>

    <!-- The counter for calls in a group and the date of the latest call as shown in the call log [CHAR LIMIT=15] -->
    <string name="call_log_item_count_and_date">(<xliff:g id="count">%1$d</xliff:g>) <xliff:g id="date">%2$s</xliff:g></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>

    <!-- The "file name" displayed for vCards received directly via NFC [CHAR LIMIT=16] -->
    <string name="nfc_vcard_file_name">Contact received over NFC</string>

    <!-- Menu item used to show only outgoing in the call log. [CHAR LIMIT=30] -->
    <string name="menu_show_outgoing_only">Show outgoing only</string>

    <!-- Menu item used to show only incoming in the call log. [CHAR LIMIT=30] -->
    <string name="menu_show_incoming_only">Show incoming only</string>

    <!-- Menu item used to show only missed in the call log. [CHAR LIMIT=30] -->
    <string name="menu_show_missed_only">Show missed only</string>

    <!-- Menu item used to show only voicemails in the call log. [CHAR LIMIT=30] -->
    <string name="menu_show_voicemails_only">Show voicemails only</string>

    <!-- Menu item used to show all calls in the call log. [CHAR LIMIT=30] -->
    <string name="menu_show_all_calls">Show all calls</string>

    <!--  Used to display as default status when the contact is available for chat [CHAR LIMIT=19] -->
    <string name="status_available">Available</string>

    <!--  Used to display as default status when the contact is away or idle for chat [CHAR LIMIT=19] -->
    <string name="status_away">Away</string>

    <!--  Used to display as default status when the contact is busy or Do not disturb for chat [CHAR LIMIT=19] -->
    <string name="status_busy">Busy</string>

    <!-- String describing the icon in the call log used to play a voicemail.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_call_log_play_button">Play voicemail</string>

    <!-- String describing the icon in the call log used to represent an incoming call.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_call_log_incoming_call">Incoming call</string>

    <!-- String describing the icon in the call log used to represent an outgoing call.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->

    <string name="description_call_log_outgoing_call">Outgoing call</string>

    <!-- String describing the icon in the call log used to represent a missed call.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->

    <string name="description_call_log_missed_call">Missed call</string>

    <!-- String describing the icon in the call log used to represent a voicemail left to the user.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_call_log_voicemail">Voicemail</string>

    <!-- String describing the button to add a contact for the current number.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_add_contact">Add contact</string>

    <!-- String describing the button to view the contact for the current number.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_view_contact">View contact <xliff:g id="name">%1$s</xliff:g></string>

    <!-- String describing the button to call a number or contact.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_call">Call <xliff:g id="name">%1$s</xliff:g></string>

    <!-- String describing the button to SMS a number or contact.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
              [CHAR LIMIT=NONE]
    -->
    <string name="description_send_text_message">Send text message to <xliff:g id="name">%1$s</xliff:g></string>

    <!-- String describing the icon in the call log used to represent an unheard voicemail left to
         the user.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
              [CHAR LIMIT=NONE]
    -->
    <string name="description_call_log_unheard_voicemail">Unheard voicemail</string>

    <!-- String describing the button to send a text message on quick contact.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
              [CHAR LIMIT=NONE]
    -->
    <string name="description_send_message">Send message to <xliff:g id="name">%1$s</xliff:g></string>

    <!-- String describing the text for a phone number in quick contact.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_dial_phone_number">Dial phone <xliff:g id="name">%1$s</xliff:g></string>

    <!-- String describing the text for photo of a contact in a contacts list.

        Note: AccessibilityServices use this attribute to announce what the view represents.
              This is especially valuable for views without textual representation like ImageView.
    -->
    <string name="description_quick_contact_for">Quick contact for <xliff:g id="name">%1$s</xliff:g></string>

    <!-- The string used to represent an unknown location for a phone number in the call log [CHAR LIMIT=3] -->
    <string name="call_log_empty_gecode">-</string>

    <!-- String describing the text on the header of the profile contact in the contacts list
         This may be programatically capitalized. [CHAR LIMIT=20] -->
    <string name="user_profile_contacts_list_header" msgid="9154761216179882405">Me</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">People 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 People 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>

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

    <!-- Dialog message which is shown when the user tries to make a phone call
         to prohibited phone numbers [CHAR LIMIT=NONE] -->
    <string name="dialog_phone_call_prohibited_message" msgid="4313552620858880999">Call not sent</string>

    <!-- Dialog message which is shown when the user tries to check voicemail
         while the system isn't ready for the access. [CHAR LIMIT=NONE] -->
    <string name="dialog_voicemail_not_ready_message">To set up voicemail, go to Menu &gt; Settings.</string>

    <!-- Dialog message which is shown when the user tries to check voicemail
         while the system is in airplane mode. The user cannot access to
         voicemail service in Airplane mode. [CHAR LIMI=NONE] -->
    <string name="dialog_voicemail_airplane_mode_message">To call voicemail, first turn off Airplane mode.</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 fake action menu overflow button.
         This should be same as the description for the real action menu
         overflow button available in ActionBar.
         [CHAR LIMIT=NONE] -->
    <string name="action_menu_overflow_description" msgid="2295659037509008453">More options</string>

    <!-- Content description for the expand or collapse name fields button.
         Clicking this button causes the name editor to toggle between showing
         a single field where the entire name is edited at once, or multiple
         fields corresponding to each part of the name (Name Prefix, First Name,
         Middle Name, Last Name, Name Suffix).
         [CHAR LIMIT=NONE] -->
    <string name="expand_collapse_name_fields_description">Expand or collapse name fields</string>
</resources>
