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

    <!-- Official label of the phone app, as seen in "Manage Applications"
         and other settings UIs. -->
    <string name="phoneAppLabel" product="default">Phone</string>

    <!-- Official label for the in-call UI. DO NOT TRANSLATE. -->
    <string name="inCallLabel" translate="false">InCallUI</string>

    <!-- Call status -->

    <!-- In-call screen: status label for a call that's on hold -->
    <string name="onHold">On hold</string>

    <!-- Incoming call screen, name of "unknown" caller -->
    <string name="unknown">Unknown</string>
    <!-- Incoming call screen, string when number hidden -->
    <string name="private_num">Private number</string>
    <!-- Incoming call screen, string when called from a pay phone -->
    <string name="payphone">Payphone</string>

    <!-- In-call screen: status label for a conference call -->
    <string name="confCall">Conference call</string>
    <!-- In-call screen: call lost dialog text -->
    <string name="call_lost">Call dropped</string>

    <!-- MMI dialog strings -->
    <!-- Dialog label when an MMI code starts running -->

    <!-- "Audio mode" popup menu: Item label to select the speakerphone [CHAR LIMIT=25] -->
    <string name="audio_mode_speaker">Speaker</string>
    <!-- "Audio mode" popup menu: Item label to select the handset earpiece [CHAR LIMIT=25] -->
    <string name="audio_mode_earpiece">Handset earpiece</string>
    <!-- "Audio mode" popup menu: Item label to select the wired headset [CHAR LIMIT=25] -->
    <string name="audio_mode_wired_headset">Wired headset</string>
    <!-- "Audio mode" popup menu: Item label to select the bluetooth headset [CHAR LIMIT=25] -->
    <string name="audio_mode_bluetooth">Bluetooth</string>

    <!-- post dial -->
    <!-- In-call screen: body text of the dialog that appears when we encounter
         the "wait" character in a phone number to be dialed; this dialog asks the
         user if it's OK to send the numbers following the "wait". -->
    <string name="wait_prompt_str">Send the following tones?\n</string>
    <!-- In-call screen: body text of the dialog that appears when we encounter
         the "PAUSE" character in a phone number to be dialed; this dialog gives
         informative message to the user to show the sending numbers following the "Pause". -->
    <string name="pause_prompt_str">Sending tones\n</string>
    <!-- In-call screen: button label on the "wait" prompt dialog -->
    <string name="send_button">Send</string>
    <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
    <string name="pause_prompt_yes">Yes</string>
    <!-- In-call screen: button label on the "wait" prompt dialog in CDMA Mode-->
    <string name="pause_prompt_no">No</string>
    <!-- In-call screen: on the "wild" character dialog, this is the label
         for a text widget that lets the user enter the digits that should
         replace the "wild" character. -->
    <string name="wild_prompt_str">Replace wild character with</string>

    <!-- In-call screen: status label for a conference call -->
    <string name="caller_manage_header">Conference call <xliff:g id="conf_call_time">%s</xliff:g></string>

    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
    <string name="fake_phone_activity_phoneNumber_text" translatable="false">(650) 555-1234</string>
    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
    <string name="fake_phone_activity_infoText_text" translatable="false">Incoming phone number</string>
    <!-- Used in FakePhoneActivity test code.  DO NOT TRANSLATE. -->
    <string name="fake_phone_activity_placeCall_text" translatable="false">Fake Incoming Call</string>

    <!-- Call settings screen, Set voicemail dialog title -->
    <string name="voicemail_settings_number_label">Voicemail number</string>

    <!-- Card titles -->
    <!-- In-call screen: status label for a call in the "dialing" state [CHAR LIMIT=25] -->
    <string name="card_title_dialing">Dialing</string>
    <!-- In-call screen: status label for a re-dialing call [CHAR LIMIT=25] -->
    <string name="card_title_redialing">Redialing</string>
    <!-- In-call screen: status label for a conference call [CHAR LIMIT=25] -->
    <string name="card_title_conf_call">Conference call</string>
    <!-- In-call screen: status label for an incoming call [CHAR LIMIT=25] -->
    <string name="card_title_incoming_call">Incoming call</string>
    <!-- In-call screen: status label displayed briefly after a call ends [CHAR LIMIT=25] -->
    <string name="card_title_call_ended">Call ended</string>
    <!-- In-call screen: status label for call that's on hold [CHAR LIMIT=25] -->
    <string name="card_title_on_hold">On hold</string>
    <!-- In-call screen: status label for a call that's in the process of hanging up [CHAR LIMIT=25] -->
    <string name="card_title_hanging_up">Hanging up</string>
    <!-- In-call screen: status label for a call that's in CDMA flash mode [CHAR LIMIT=25] -->
    <string name="card_title_in_call">In call</string>
    <!-- In-call screen: special status label that shows your own phone
         number during emergency callback mode (ECM) [CHAR LIMIT=30] -->
    <string name="card_title_my_phone_number">My number is <xliff:g id="my_phone_number">%s</xliff:g></string>
    <!-- In-call screen: status label when connecting video. -->
    <string name="card_title_video_call_connecting">Connecting video</string>
    <!-- In-call screen: status label when in a video call. -->
    <string name="card_title_video_call">Video call</string>
    <!-- In-call screen: status label when requesting video. -->
    <string name="card_title_video_call_requesting">Requesting video</string>
    <!-- In-call screen: status label when there is a problem connecting a video call. -->
    <string name="card_title_video_call_error">Can\'t connect video call</string>
    <!-- In-call screen: status label when the remote party rejects a video call request. -->
    <string name="card_title_video_call_rejected">Video request rejected</string>

    <!-- In-call screen: string shown to the user when their outgoing number is different than the
         number reported by TelephonyManager#getLine1Number() -->
    <string name="card_title_callback_number">Your callback number\n
        <xliff:g id="dark_number">%1$s</xliff:g>
    </string>

    <!-- In-call screen: string shown to the user when their outgoing number is different than the
         number reported by TelephonyManager#getLine1Number() and they're calling emergency
         services. -->
    <string name="card_title_callback_number_emergency">Your emergency callback number\n
        <xliff:g id="dark_number">%1$s</xliff:g>
    </string>

    <!-- Notification strings -->
    <!-- The "label" of the in-call Notification for a dialing call, used
         as the format string for a Chronometer widget. [CHAR LIMIT=60] -->
    <string name="notification_dialing">Dialing</string>
    <!-- Missed call notification label, used when there's exactly one missed call -->
    <string name="notification_missedCallTitle">Missed call</string>
    <!-- Missed call notification label, used when there are two or more missed calls -->
    <string name="notification_missedCallsTitle">Missed calls</string>
    <!-- Missed call notification message used when there are multiple missed calls -->
    <string name="notification_missedCallsMsg"><xliff:g id="num_missed_calls">%s</xliff:g> missed calls</string>
    <!-- Missed call notification message used for a single missed call, including
         the caller-id info from the missed call -->
    <string name="notification_missedCallTicker">Missed call from <xliff:g id="missed_call_from">%s</xliff:g></string>
    <!-- The "label" of the in-call Notification for an ongoing call. [CHAR LIMIT=60] -->
    <string name="notification_ongoing_call">Ongoing call</string>
    <!-- The "label" of the in-call Notification for an ongoing call, which is being made over
         Wi-Fi. [CHAR LIMIT=60] -->
    <string name="notification_ongoing_call_wifi">Ongoing Wi-Fi call</string>
    <!-- The "label" of the in-call Notification for a call that's on hold -->
    <string name="notification_on_hold">On hold</string>
    <!-- The "label" of the in-call Notification for an incoming ringing call. [CHAR LIMIT=60] -->
    <string name="notification_incoming_call">Incoming call</string>
    <!-- The "label" of the in-call Notification for an incoming ringing call,
         which is being made over Wi-Fi. [CHAR LIMIT=60] -->
    <string name="notification_incoming_call_wifi">Incoming Wi-Fi call</string>
    <!-- The "label" of the in-call Notification for an incoming ringing video call. -->
    <string name="notification_incoming_video_call">Incoming video call</string>
    <!-- The "label" of the in-call Notification for upgrading an existing call to a video call. -->
    <string name="notification_requesting_video_call">Incoming video request</string>
    <!-- Label for the "Voicemail" notification item, when expanded. -->
    <string name="notification_voicemail_title">New voicemail</string>
    <!-- Label for the expanded "Voicemail" notification item,
         including a count of messages. -->
    <string name="notification_voicemail_title_count">New voicemail (<xliff:g id="count">%d</xliff:g>)</string>
    <!-- Message displayed in the "Voicemail" notification item, allowing the user
         to dial the indicated number. -->
    <string name="notification_voicemail_text_format">Dial <xliff:g id="voicemail_number">%s</xliff:g></string>
    <!-- Message displayed in the "Voicemail" notification item,
         indicating that there's no voicemail number available -->
    <string name="notification_voicemail_no_vm_number">Voicemail number unknown</string>
    <!-- Label for the "No service" notification item, when expanded. -->
    <string name="notification_network_selection_title">No service</string>
    <!-- Label for the expanded "No service" notification item, including the
         operator name set by user -->
    <string name="notification_network_selection_text">Selected network (<xliff:g id="operator_name">%s</xliff:g>) unavailable</string>
    <!-- Label for the "Answer call" action. This is the displayed label for the action that answers
         an incoming call. [CHAR LIMIT=12] -->
    <string name="notification_action_answer">Answer</string>
    <!-- Label for "end call" Action.
         It is displayed in the "Ongoing call" notification, which is shown
         when the user is outside the in-call screen while the phone call is still
         active. [CHAR LIMIT=12] -->
    <string name="notification_action_end_call">Hang up</string>
    <!-- Label for "Video Call" notification action. This is a displayed on the notification for an
         incoming video call, and answers the call as a video call. [CHAR LIMIT=12] -->
    <string name="notification_action_answer_video">Video</string>
    <!-- Label for "Voice" notification action. This is a displayed on the notification for an
         incoming video call, and answers the call as an audio call. [CHAR LIMIT=12] -->
    <string name="notification_action_answer_voice">Voice</string>
    <!-- Label for "Accept" notification action. This is somewhat generic, and may refer to
         scenarios such as accepting an incoming call or accepting a video call request.
         [CHAR LIMIT=12] -->
    <string name="notification_action_accept">Accept</string>
    <!-- Label for "Dismiss" notification action. This is somewhat generic, and may refer to
         scenarios such as declining an incoming call or declining a video call request.
         [CHAR LIMIT=12] -->
    <string name="notification_action_dismiss">Dismiss</string>

    <!-- Message for "call back" Action, which is displayed in the missed call notification.
         The user will be able to call back to the person or the phone number.
         [CHAR LIMIT=12] -->
    <string name="notification_missedCall_call_back">Call back</string>
    <!-- Message for "reply via sms" action, which is displayed in the missed call notification.
         The user will be able to send text messages using the phone number.
         [CHAR LIMIT=12] -->
    <string name="notification_missedCall_message">Message</string>

    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_power_off">To place a call, first turn off Airplane mode.</string>
    <!-- In-call screen: call failure message displayed in an error dialog.
         This string is currently unused (see comments in InCallActivity.java.) -->
    <string name="incall_error_emergency_only">Not registered on network.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_out_of_service">Cellular network not available.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_no_phone_number_supplied">To place a call, enter a valid number.</string>
    <!-- In-call screen: call failure message displayed in an error dialog -->
    <string name="incall_error_call_failed">Can\'t call.</string>
    <!-- In-call screen: status message displayed in a dialog when starting an MMI -->
    <string name="incall_status_dialed_mmi">Starting MMI sequence\u2026</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_unknown">Service not supported.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_switch">Can\'t switch calls.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_separate">Can\'t separate call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_transfer">Can\'t transfer.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_conference">Can\'t conference.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_reject">Can\'t reject call.</string>
    <!-- In-call screen: message displayed in an error dialog -->
    <string name="incall_error_supp_service_hangup">Can\'t release call(s).</string>

    <!-- In-call screen: "call type" indication for a SIP call [CHAR LIMIT=30]  -->
    <string name="incall_call_type_label_sip">SIP call</string>

    <!-- Dialog title for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_title">Emergency call</string>
    <!-- Status message for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_message">Turning on radio\u2026</string>
    <!-- Status message for the "radio enable" UI for emergency calls -->
    <string name="emergency_enable_radio_dialog_retry">No service. Trying again\u2026</string>

    <!-- Dialer text on Emergency Dialer -->
    <!-- Emergency dialer: message displayed in an error dialog -->
    <string name="dial_emergency_error">Can\'t call. <xliff:g id="non_emergency_number">%s</xliff:g> is not an emergency number.</string>
    <!-- Emergency dialer: message displayed in an error dialog -->
    <string name="dial_emergency_empty_error">Can\'t call. Dial an emergency number.</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>

    <!-- Text for the onscreen "Hold" button when it is not selected. Pressing it will put
         the call on hold. -->
    <string name="onscreenHoldText_unselected">Hold Call</string>
    <!-- Text for the onscreen "Hold" button when it is selected. Pressing it will resume
         the call from a previously held state. -->
    <string name="onscreenHoldText_selected">Resume Call</string>
    <!-- Text for the onscreen "End call" button -->
    <string name="onscreenEndCallText">End Call</string>
    <!-- Text for the onscreen "Show Dialpad" button -->
    <string name="onscreenShowDialpadText">Dialpad</string>
    <!-- Text for the onscreen "Mute" button -->
    <string name="onscreenMuteText">Mute</string>
    <!-- Text for the onscreen "Add call" button -->
    <string name="onscreenAddCallText">Add call</string>
    <!-- Text for the onscreen "Merge calls" button -->
    <string name="onscreenMergeCallsText">Merge calls</string>
    <!-- Text for the onscreen "Swap calls" button -->
    <string name="onscreenSwapCallsText">Swap</string>
    <!-- Text for the onscreen "Manage calls" button -->
    <string name="onscreenManageCallsText">Manage calls</string>
    <!-- Text for the onscreen "Manage conference" button [CHAR LIMIT=30] -->
    <string name="onscreenManageConferenceText">Manage conference call</string>
    <!-- Text for the onscreen "Audio" button that lets you switch
         between speaker / bluetooth / earpiece [CHAR LIMIT=10] -->
    <string name="onscreenAudioText">Audio</string>
    <!-- Text for the onscreen "Video call" button used to change a voice call
         to a video call. [CHAR LIMIT=10] -->
    <string name="onscreenVideoCallText">Video call</string>
    <!-- Text for the onscreen "Change to voice" button. When clicked, this downgrades a video call
         to a voice call. -->
    <string name="onscreenChangeToVoiceText">Change to voice call</string>
    <!-- Text for the onscreen "Switch camera" button. When clicked, this switches the user's camera
         for video calling between the front-facing camera and the back-facing camera. -->
    <string name="onscreenSwitchCameraText">Switch camera</string>
    <!-- Text for the onscreen "Pause video" button. -->
    <string name="onscreenPauseVideoText">Pause video</string>
    <!-- Text for the onscreen overflow button, to see additional actions which can be done. -->
    <string name="onscreenOverflowText">More options</string>

    <!-- Message indicating that Video Started flowing for IMS-VT calls -->
    <string name="player_started">Player Started</string>
    <!-- Message indicating that Video Stopped flowing for IMS-VT calls -->
    <string name="player_stopped">Player Stopped</string>
    <!-- Message indicating that camera failure has occurred for the selected camera and
         as result camera is not ready -->
    <string name="camera_not_ready">Camera not ready</string>
    <!-- Message indicating that camera is ready/available -->
    <string name="camera_ready">Camera ready</string>
    <!-- Message indicating unknown call session event -->
    <string name="unknown_call_session_event">"Unkown call session event"</string>

    <!-- For incoming calls, this is a string we can get from a CDMA network instead of
         the actual phone number, to indicate there's no number present.  DO NOT TRANSLATE. -->
    <string-array name="absent_num" translatable="false">
        <item>ABSENT NUMBER</item>
        <item>ABSENTNUMBER</item>
    </string-array>

    <!-- Preference for Voicemail service provider under "Voicemail" settings.
         [CHAR LIMIT=40] -->
    <string name="voicemail_provider">Service</string>

    <!-- Preference for Voicemail setting of each provider.
         [CHAR LIMIT=40] -->
    <string name="voicemail_settings">Setup</string>

    <!-- String to display in voicemail number summary when no voicemail num is set -->
    <string name="voicemail_number_not_set">&lt;Not set&gt;</string>

    <!-- Title displayed above settings coming after voicemail in the call features screen -->
    <string name="other_settings">Other call settings</string>

    <!-- Title displayed in the overlay for outgoing calls which include the name of the provider.
         [CHAR LIMIT=40] -->
    <string name="calling_via_template">Calling via <xliff:g id="provider_name">%s</xliff:g></string>
    <!-- Title displayed in the overlay for incoming calls which include the name of the provider.
         [CHAR LIMIT=40] -->
    <string name="incoming_via_template">Incoming via <xliff:g id="provider_name">%s</xliff:g></string>

    <!-- Use this as a default to describe the contact photo; currently for screen readers through accessibility. -->
    <string name="contactPhoto">contact photo</string>
    <!-- Use this to describe the separate conference call button; currently for screen readers through accessibility. -->
    <string name="goPrivate">go private</string>
    <!--  Use this to describe the select contact button in EditPhoneNumberPreference; currently for screen readers through accessibility. -->
    <string name="selectContact">select contact</string>

    <!-- "Respond via SMS" option that lets you compose a custom response. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_custom_message">Write your own...</string>
    <!-- "Custom Message" Cancel alert dialog button -->
    <string name="custom_message_cancel">Cancel</string>
    <!-- "Custom Message" Send alert dialog button -->
    <string name="custom_message_send">Send</string>

    <!-- Description of the answer target in the Slide unlock screen of Phone. [CHAR LIMIT=NONE] -->
    <string name="description_target_answer">Answer</string>
    <!-- Description of the send_sms target in the Slide unlock screen of Phone. [CHAR LIMIT=NONE] -->
    <string name="description_target_send_sms">Send SMS</string>
    <!-- Description of the decline target in the Slide unlock screen. [CHAR LIMIT=NONE] -->
    <string name="description_target_decline">Decline</string>
    <!-- Description of the target to answer a call as a video call in the Slide unlock screen.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_answer_video_call">Answer as video call</string>
    <!-- Description of the target to answer a call as an audio call in the Slide unlock screen.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_answer_audio_call">Answer as audio call</string>
    <!-- Description of the target to accept a request to upgrade from an audio call to a video call.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_accept_upgrade_to_video_request">Accept video request</string>
    <!-- Description of the target to decline a request to upgrade from an audio call to a video call.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_decline_upgrade_to_video_request">Decline video request</string>
    <!-- Description of the target to accept a request to upgrade from any call to a video transmit call.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_accept_upgrade_to_video_transmit_request">Accept video transmit request</string>
    <!-- Description of the target to decline a request to upgrade from any call to a video transmit call.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_decline_upgrade_to_video_transmit_request">Decline video transmit request</string>
        <!-- Description of the target to accept a request to upgrade from any call to a video receive call.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_accept_upgrade_to_video_receive_request">Accept video receive request</string>
    <!-- Description of the target to decline a request to upgrade from any call to a video receive call.
         [CHAR LIMIT=NONE] -->
    <string name="description_target_decline_upgrade_to_video_receive_request">Decline video receive request</string>

    <!-- Description of the up direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
    <string name="description_direction_up">Slide up for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
    <!-- Description of the left direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
    <string name="description_direction_left">"Slide left for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
    <!-- Description of the right direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
    <string name="description_direction_right">Slide right for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>
    <!-- Description of the down direction in which one can to slide the handle in the phone answer screen. [CHAR LIMIT=NONE] -->
    <string name="description_direction_down">Slide down for <xliff:g id="target_description" example="Unlock">%s</xliff:g>.</string>

    <!-- Dialog title for the vibration settings for voicemail notifications [CHAR LIMIT=40] -->
    <string name="voicemail_notification_vibrate_when_title" msgid="8731372580674292759">Vibrate</string>
    <!-- Dialog title for the vibration settings for voice mail notifications [CHAR LIMIT=40]-->
    <string name="voicemail_notification_vibarte_when_dialog_title" msgid="8995274609647451109">Vibrate</string>

    <!-- Voicemail ringtone title. The user clicks on this preference to select
         which sound to play when a voicemail notification is received.
         [CHAR LIMIT=30] -->
    <string name="voicemail_notification_ringtone_title">Sound</string>

    <!--  The string used to describe a notification if it is the default one in the system. For
          example, if the user selects the default notification, it will appear as something like
          Default sound(Capella) in the notification summary.
          [CHAR LIMIT=40] -->
    <string name="default_notification_description">Default sound (<xliff:g id="default_sound_title">%1$s</xliff:g>)</string>

    <!-- The default value value for voicemail notification. -->
    <string name="voicemail_notification_vibrate_when_default" translatable="false">never</string>

    <!-- Actual values used in our code for voicemail notifications. DO NOT TRANSLATE -->
    <string-array name="voicemail_notification_vibrate_when_values" translatable="false">
        <item>always</item>
        <item>silent</item>
        <item>never</item>
    </string-array>

    <!-- Setting option name to pick ringtone (a list dialog comes up). [CHAR LIMIT=30] -->
    <string name="ringtone_title" msgid="5379026328015343686">Phone ringtone</string>

    <!-- Setting option name to enable or disable vibration when ringing
         the phone.
         [CHAR LIMIT=30] -->
    <string name="vibrate_on_ring_title">Vibrate when ringing</string>

    <!-- Title for the category "ringtone", which is shown above ringtone and vibration
         related settings.
         [CHAR LIMIT=30] -->
    <string name="preference_category_ringtone">Ringtone &amp; Vibrate</string>

    <!-- Label for "Manage conference call" panel [CHAR LIMIT=40] -->
    <string name="manageConferenceLabel">Manage conference call</string>

    <!-- This can be used in any application wanting to disable the text "Emergency number" -->
    <string name="emergency_call_dialog_number_for_display">Emergency number</string>

    <!-- Phrase describing a time duration using seconds [CHAR LIMIT=16] -->
    <plurals name="duration_seconds">
        <item quantity="one">1 second</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> seconds</item>
    </plurals>
    <!-- Phrase describing a time duration using minutes [CHAR LIMIT=16] -->
    <plurals name="duration_minutes">
        <item quantity="one">1 minute</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> minutes</item>
    </plurals>
    <!-- Phrase describing a time duration using hours [CHAR LIMIT=16] -->
    <plurals name="duration_hours">
        <item quantity="one">1 hour</item>
        <item quantity="other"><xliff:g id="count">%d</xliff:g> hours</item>
    </plurals>

    <!-- Description of the profile photo shown when the device's camera is disabled udring a video
        call. [CHAR LIMIT=NONE] -->
    <string name="profile_photo_description">Profile photo</string>

    <!-- Description of the "camera off" icon displayed when the device's camera is disabled during
         a video call. [CHAR LIMIT=NONE] -->
    <string name="camera_off_description">Camera off</string>

    <!-- Used to inform the user that a call was received via a number other than the primary
        phone number associated with their device. [CHAR LIMIT=16] -->
    <string name="child_number">via <xliff:g id="child_number" example="650-555-1212">%s</xliff:g></string>

    <!-- Used to inform the user that the note associated with an outgoing call has been sent.
         [CHAR LIMIT=32] -->
    <string name="note_sent">Note sent</string>
</resources>
