<?xml version="1.0" encoding="utf-8"?>
<!--
/*
 * Copyright (C) 2010, 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">
    <string name="app_name">LoaderApp</string>
    <string name="app_name_normal">LoaderApp Normal</string>
    <string name="app_name_xlarge">LoaderApp XLarge</string>
    <string name="app_name_xlarge_groups">LoaderApp Groups</string>

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

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

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

    <!-- 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 name of the contact to call -->
    <string name="menu_callNumber">Call <xliff:g id="name">%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 contact</string>

    <!-- Menu item used to delete a specific contact -->
    <string name="menu_deleteContact">Delete contact</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 used to send an email message to a specific email address -->
    <string name="menu_sendEmail">Send email</string>

    <!-- Menu item used to view a contact's address on a map -->
    <string name="menu_viewAddress">Map address</string>

    <!-- Menu item that makes a phone the default for a contact. The default number used when you
         try to call a contact without specifying a specific number. -->
    <string name="menu_makeDefaultNumber">Make default number</string>

    <!-- Menu item that makes an email address the default for a contact. The default email used
         when you try to email a contact without specifying a specific address. -->
    <string name="menu_makeDefaultEmail">Make default email</string>

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

    <!-- Toast shown after a contact has been split from an aggregate by a user action -->
    <string name="contactsSplitMessage">Contacts separated</string>

    <!-- Title of the confirmation dialog for separating contacts into multiple instances  -->
    <string name="splitConfirmation_title">Separate Contact</string>

    <!-- Confirmation dialog for separating contacts into multiple instances  -->
    <string name="splitConfirmation">Are you sure you want to separate this single contact
        into multiple contacts: one for each set of contact information that was joined into it?
    </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 -->
    <string name="blurbJoinContactDataWith">Select 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 -->
    <string name="menu_contactOptions">Options</string>

    <!-- Title for the Options activity for a given contact -->
    <string name="contactOptionsTitle">Options</string>

    <!-- Confirmation dialog title after users selects to delete a contact. -->
    <string name="deleteConfirmation_title">Delete</string>

    <!-- Warning dialog contents after users selects to delete a ReadOnly contact. -->
    <string name="readOnlyContactWarning">You cannot 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 stop editing a contact and NOT save the changes you've made -->
    <string name="menu_doNotSave">Revert</string>

    <!-- The title of the activity that edits and existing contact -->
    <string name="editContact_title_edit">Edit contact</string>

    <!-- The title of the activity that creates a new contact -->
    <string name="editContact_title_insert">New contact</string>

    <!-- The label describing the phonetic pronunciation/reading of a contact name -->
    <string name="label_phonetic_name">Phonetic</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 custom ringtone for a contact -->
    <string name="label_ringtone">Ringtone</string>

    <!-- Hint text for the contact name when editing -->
    <string name="ghostData_name">First and Last</string>

    <!-- Hint text for the phonetic reading of the contact name when editing -->
    <string name="ghostData_phonetic_name">Phonetic name</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. -->
    <string name="invalidContactMessage">The contact does not exist.</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>

    <!-- Dialog title when you select a label when creating or edit a contact -->
    <string name="selectLabel">Select label</string>

    <!-- Header that expands to list all of the types of phone numbers when editing or creating a phone number for a contact -->
    <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 -->
    <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 -->
    <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 -->
    <string name="postalLabelsGroup">Postal 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. -->
    <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">No pictures are available on the phone.</string>

    <!-- Description of the activity used to set a photo in the pictures application as the icon for a contact -->
    <string name="attachToContact">Contact icon</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>

    <!-- The menu item to open the list of groups to display -->
    <string name="menu_displayGroup">Display options</string>

    <!-- Title of activity that lets user pick which contact groups to display -->
    <string name="displayGroups">Display options</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>

    <!-- String used to indicate that a contact doesn't have a custom ringtone -->
    <string name="default_ringtone">Default</string>

    <!-- The button/menu item that allows you to change an existing contact picture -->
    <string name="changePicture">Change icon</string>

    <!-- The menu item that allows you to remove a picture from a contact -->
    <string name="removePicture">Remove icon</string>

    <!-- The text displayed when the contacts list is empty while displaying all contacts -->
    <string name="noContacts">No contacts.</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 title of the filter to only show contacts with phone numbers -->
    <string name="showFilterPhones">Only contacts with phones</string>

    <!-- The description of the filter to only show contacts with phone numbers -->
    <string name="showFilterPhonesDescrip">Only display contacts that have phone numbers</string>

    <!-- The header over the list of all contacts groups -->
    <string name="headerContactGroups">Choose contacts to display</string>

    <!-- The description of a group with the total number of contacts -->
    <plurals name="groupDescrip">
        <item quantity="other"><xliff:g id="count">%0$d</xliff:g> contacts</item>
    </plurals>

    <!-- The description of a group with the total number of contacts, and the total number of contacts with phone numbers -->
    <plurals name="groupDescripPhones">
        <item quantity="other"><xliff:g id="count">%1$d</xliff:g> contacts, <xliff:g id="countWithPhones">%2$d</xliff:g> with phones</item>
    </plurals>

    <!-- 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 -->
    <string name="contactSavedToast">Contact saved.</string>

    <!-- Toast displayed when saving a contact failed -->
    <string name="contactSavedErrorToast">Error, unable to save contact 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">Displaying 1 contact with phone number</item>
        <item quantity="other">Displaying <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 -->
    <string name="listTotalPhoneContactsZero">No visible 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">Displaying 1 contact</item>
        <item quantity="other">Displaying <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 "Only contacts with phones" not selected -->
    <string name="listTotalAllContactsZero">No visible contacts</string>

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

    <!-- Displayed at the top of the contacts showing the zero total number of contacts found when "Only contacts with phones" not selected -->
    <string name="listFoundAllContactsZero">Contact not found</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 contact</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> contacts</item>
    </plurals>

    <!-- The description text for the contacts tab. Space is limited for this string, so the shorter the better -->
    <string name="contactsIconLabel">Contacts</string>

    <!-- The description text for the favorites tab. Space is limited for this string, so the shorter the better -->
    <string name="contactsFavoritesLabel">Favorites</string>

    <!-- The description text for the dialer tab. Space is limited for this string, so the shorter the better -->
    <string name="dialerIconLabel">Phone</string>

    <!-- The description text for the call log tab. Space is limited for this string, so the shorter the better -->
    <string name="recentCallsIconLabel">Call log</string>
    <string name="liveFolderAll">All contacts</string>
    <string name="liveFolderFavorites">Starred contacts</string>
    <string name="liveFolderPhone">Contacts with phone numbers</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>

    <!-- 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  -->
    <string name="clearCallLogConfirmation_title">Clear call log</string>

    <!-- Confirmation dialog for clearing the call log  -->
    <string name="clearCallLogConfirmation">Are you sure you want to clear the call log?</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.) -->
    <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 -->
    <string name="noContactsHelpText">"You don't have any contacts to display.\n\nTo add contacts, press <font fgcolor="#ffffffff"><b>Menu</b></font> and touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or configure 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>\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 -->
    <string name="noContactsHelpTextWithSync">"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, press <font fgcolor="#ffffffff"><b>Menu</b></font> and touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or configure 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>\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)-->
    <string name="noContactsNoSimHelpText">"You don't have any contacts to display.\n\nTo add contacts, press <font fgcolor="#ffffffff"><b>Menu</b></font> and touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or configure 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>\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) -->
    <string name="noContactsNoSimHelpTextWithSync">"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, press <font fgcolor="#ffffffff"><b>Menu</b></font> and touch:\n
        \n<li><font fgcolor="#ffffffff"><b>Accounts</b></font> to add or configure 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>\n</li>"
    </string>

    <!-- Displayed full screen when the user has no favorites and they are displaying the favorites tab -->
    <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>

    <!-- Activity title for the activity that lets the user choose which groups of contacts to sync from the server -->
    

    <!-- Live folder label for all contacts -->
    <string name="liveFolder_all_label">All contacts</string>

    <!-- Live folder label for only starred contacts -->
    <string name="liveFolder_favorites_label">Starred</string>

    <!-- Live folder label for all contacts with phone numbers -->
    <string name="liveFolder_phones_label">Phones</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>

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

    <!-- A list separator for the Favorites tab indicating that items below it are frequently contacted contacts rather than starred contacts -->
    <string name="favoritesFrquentSeparator">Frequently contacted</string>

    <!-- Dialog title when prompting before creating a contact -->
    <string name="add_contact_dlg_title">Add contact</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>

    <!-- Label for the all data tab in the view and edit card -->
    <string name="all_tab_label">All</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 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.
    -->
    <string name="description_minus_button">minus</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>

    <!-- Dialog title shown when SD Card does not exist -->
    <string name="no_sdcard_title">No SD card</string>

    <!-- Dialog message shown when SDcard does not exist -->
    <string name="no_sdcard_message">No SD card detected</string>

    <!-- Dialog title shown when searching VCard data from SD Card -->
    <string name="searching_vcard_title">Searching for vCard</string>

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

    <!-- Action string for selecting SD Card for importing contacts -->
    <string name="import_from_sdcard">Import from SD card</string>

    <!-- Action that exports all contacts to SD Card -->
    <string name="export_to_sdcard">Export to SD card</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 SD Card -->
    <string name="searching_vcard_message">Searching for vCard data on SD card</string>

    <!-- Dialog title shown when scanning VCard data failed. -->
    <string name="scanning_sdcard_failed_title">Scanning SD card failed</string>

    <!-- Dialog message shown when searching VCard data failed.
         An exact reason for the failure should -->
    <string name="scanning_sdcard_failed_message">Scanning SD card failed (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. -->
    <string name="fail_reason_io_error">I/O Error</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. -->
    <string name="fail_reason_vcard_parse_error">Failed to parse vCard for unexpected reason</string>

    <!-- The failed reason shown when the current vCard importer cannot parse the file since the
         parser is incomplete (actually, there's missing part in the current vCard parser, though
         our understanding is that the functionality missed by the current vCard parser
         is rarely needed in the actual vCard...). -->
    <string name="fail_reason_vcard_not_supported_error">Failed to parse vCard though it seems in valid format, since the current implementation does not support it</string>

    <!-- The failed reason shown when the system could not find any vCard file
         (with extension ".vcf" in SDCard.) -->
    <string name="fail_reason_no_vcard_file">No vCard file found on the SD card</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 failed to be imported (%s).</string>

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

    <!-- Dialog title shown when a user is asked to select VCard file -->
    <string name="select_vcard_title">Select vCard file</string>

    <!-- The message shown while reading a vCard file/entry. The first argument is like
    "Reading VCard" or "Reading VCard files" and the second is the display name of the current
    data being parsed -->
    <string name="progress_shower_message"><xliff:g id="action" example="Reading VCard">%s</xliff:g>\n<xliff:g id="filename" example="foo.vcf">%s</xliff:g></string>

    <!-- Dialog title shown when reading VCard data -->
    <string name="reading_vcard_title">Reading vCard</string>

    <!-- Dialog message shown when reading a VCard file -->
    <string name="reading_vcard_message">Reading vCard file(s)</string>

    <!-- Dialog title shown when reading VCard data failed -->
    <string name="reading_vcard_failed_title">Reading of vCard data has failed</string>

    <!-- Message while reading one vCard 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="reading_vcard_contacts"><xliff:g id="current_number">%s</xliff:g> of <xliff:g id="total_number">%s</xliff:g> contacts</string>

    <!-- Message while reading multiple vCard files "(current number) of (total number) files" The order of "current number" and "total number" cannot be changed (like "total: (total number), current: (current number)")-->
    <string name="reading_vcard_files"><xliff:g id="current_number">%s</xliff:g> of <xliff:g id="total_number">%s</xliff:g> files</string>

    <!-- Dialog title shown when a user confirms whether he/she export Contact data -->
    <string name="confirm_export_title">Confirm export</string>

    <!-- Dialog message shown when a user confirms whether he/she export Contact data -->
    <string name="confirm_export_message">Are you sure you want to export your contact list to \"<xliff:g id="vcard_filename">%s</xliff:g>\"?</string>

    <!-- Dialog title shown when exporting Contact data failed -->
    <string name="exporting_contact_failed_title">Failed to export contact data</string>

    <!-- Dialog message shown when exporting Contact data failed -->
    <string name="exporting_contact_failed_message">Failed to export contact data.\nReason for failure: \"<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. -->
    <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. -->
    <string name="fail_reason_too_many_vcard">Too many vCard files 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. -->
    <string name="fail_reason_too_long_filename">Required filename is too long (\"<xliff:g id="filename">%s</xliff:g>\")</string>

    <!-- Dialog title shown when the application is exporting contact data outside -->
    <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">Exporting contact data 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. -->
    <string name="fail_reason_could_not_initialize_exporter">Could not initialize 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. -->
    <string name="fail_reason_error_occurred_during_export">Error occured 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. -->
    <string name="composer_failed_to_get_database_infomation">Failed to 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. -->
    <string name="composer_has_no_exportable_contact">There is no exportable contact. If you have actualy have contacts on your phone, all the contacts may be prohibited from being exported to outside the phone by some data provider.</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. -->
    <string name="composer_not_initialized">The vCard composer is not correctly initialized</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. -->
    <string name="fail_reason_could_not_open_file">Could not 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>

    <!-- 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">Call using</string>

    <!-- Title for the sms disambiguation dialog -->
    <string name="sms_disambig_title">Text using</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 Fast-Track icon, and no application
         was found that could perform the selected action -->
    <string name="quickcontact_missing_app">No application found to handle this action</string>

    <!-- Shown as the checkbox label that, when checked, will store remember the
         selected choice and shortcut to it in the future.  For example, this would
         make a selected phone number the default. -->
    <string name="quickcontact_remember_choice">Remember this choice</string>

    <!-- Shown as the header name for a person when the name is missing or unknown. -->
    <string name="quickcontact_missing_name">Unknown</string>

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

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

    <!-- Dialog title when selecting the bulk operation to perform from a list. -->
    <string name="dialog_import_export">Import/Export contacts</string>

    <!-- The menu item to share the currently viewed contact -->
    <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. -->
    <string name="share_error">This contact cannot be shared.</string>

    <!-- Header that expands to list all name types when editing a structured name of a contact -->
    <string name="nameLabelsGroup">Name</string>
    <!-- Header that expands to list all nickname types when editing a nickname of a contact -->
    <string name="nicknameLabelsGroup">Nickname</string>
    <!-- Header that expands to list all organization types when editing an organization of a contact -->
    <string name="organizationLabelsGroup">Organization</string>
    <!-- Header that expands to list all website types when editing a website of a contact -->
    <string name="websiteLabelsGroup">Website</string>
    <!-- Header that expands to list all event types when editing an event of a contact -->
    <string name="eventLabelsGroup">Event</string>

    <!-- Single-character overlay for home phone numbers when creating desktop shortcuts -->
    <string name="type_short_home">H</string>
    <!-- Single-character overlay for mobile phone numbers when creating desktop shortcuts -->
    <string name="type_short_mobile">M</string>
    <!-- Single-character overlay for work phone numbers when creating desktop shortcuts -->
    <string name="type_short_work">W</string>
    <!-- Single-character overlay for pager phone numbers when creating desktop shortcuts -->
    <string name="type_short_pager">P</string>
    <!-- Single-character overlay for other phone numbers when creating desktop shortcuts -->
    <string name="type_short_other">O</string>

    <!-- In edit dialog, shown if the contact is marked as being read-only -->
    <string name="edit_read_only">This contact is read-only</string>

    <!-- Shown as the header title over a collapsible section that, by default, hides
         secondary contact detail edit fields, such as birthday. -->
    <string name="edit_secondary_collapse">More</string>

    <string name="dialog_primary_name">Primary name</string>
    <string name="dialog_new_contact_account">Create contact 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.-->
    <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. -->
    <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. -->
    <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">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>

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

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

    <!-- 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">from <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 since the data is read only -->
    <string name="contact_read_only"><xliff:g id="source" example="Gmail">%1$s</xliff:g> contact information is not editable on this device.</string>

    <!-- Text describing that a contact has no information available other than name and photo -->
    <string name="no_contact_details">No additional information for this contact</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>
    
    <!-- Gray hint displayed in the search field in Contacts when empty -->
    <string name="search_bar_hint">Search contacts</string>
    
    <!-- Button displayed underneath the list of filtered visible contacts -->
    <string name="search_for_all_contacts">Search for all contacts</string>

    <!-- An option in the 'change photo' or 'pick photo' dialog -->
    <string name="take_photo">Take photo</string>

    <!-- An option in the 'change photo' or 'pick photo' dialog -->
    <string name="pick_photo">Select photo from Gallery</string>

    <!-- Text shown in the contacts app while the background process updates contacts after a locale change -->
    <string name="locale_change_in_progress">Contact list is being updated to reflect the change of language.\n\nPlease wait...</string>

    <!-- Text shown in the contacts app while the background process updates contacts after a system upgrade -->
    <string name="upgrade_in_progress">Contact list is being updated.\n\nPlease wait...</string>

    <!-- Text shown in the contacts app if the background process updating contacts fails because of memory shortage -->
    <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">%d</xliff:g>Mb of 
    internal phone 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 -->
    <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 -->
    <string name="upgrade_out_of_memory_retry">Retry upgrade</string>

    <!-- Title shown in the search result activity of contacts app -->
    <string name="search_results_for">Search results for: <xliff:g id="query">%s</xliff:g></string>

    <!-- Title shown in the search result activity of contacts app while searching -->
    <string name="search_results_searching">Searching...</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>
</resources>
