<?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 Telecomm/Phone app, as seen in "Manage Applications"
         and other settings UIs. This is the "app name" used in notification, recents,
         and app info screens. -->
    <string name="telecommAppLabel" product="default">Call Management</string>

    <!-- Title used for the activity for placing a call. This name appears
         in activity disambig dialogs -->
    <string name="userCallActivityLabel" product="default">Phone</string>

    <!-- Name for an "unknown" caller. -->
    <string name="unknown">Unknown</string>

    <!-- Notification strings -->
    <!-- Missed call notification label, used when there's exactly one missed call -->
    <string name="notification_missedCallTitle">Missed call</string>
    <!-- Missed work call notification label, used when there's exactly one missed call [CHAR LIMIT=NONE] -->
    <string name="notification_missedWorkCallTitle">Missed work 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>
    <!-- Message for "call back" Action, which is displayed in the missed call notificaiton.
         The user will be able to call back to the person or the phone number.
         [CHAR LIMIT=18] -->
    <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=18] -->
    <string name="notification_missedCall_message">Message</string>

    <!-- Disconnected call notification label, used when the call has been automatically
         disconnected by telecom to make room for a higher priority call, such as an emergency
         call.-->
    <string name="notification_disconnectedCall_title">Disconnected call</string>
    <!-- Body of the notification presented when an ongoing call is disconnected in favor of placing
         an emergency call. This is required by some carriers. [CHAR LIMIT=NONE] -->
    <string name="notification_disconnectedCall_body">The call to <xliff:g id="caller">%s</xliff:g> has been disconnected due to an emergency call being placed.</string>
    <!-- Body of the notification presented when an ongoing call is disconnected in favor of placing
         an emergency call. This version is used when the call that was disconnected was also an
         emergency call. In this case, we want to hide the exact number dialed in order to protect
         user privacy. [CHAR LIMIT=NONE] -->
    <string name="notification_disconnectedCall_generic_body">
        Your call has been disconnected due to an emergency call being placed.
    </string>

    <!-- Title for the persistent notification presented when an app has requested that a call
         be put into the background so that the app can access the audio from the call
         [CHAR LIMIT=40] -->
    <string name="notification_audioProcessing_title">Background call</string>
    <!-- Body of the persistent notification presented when an app requests
         that a call be put into the background so that the app can access the audio from the call.
         [CHAR LIMIT=NONE] -->
    <string name="notification_audioProcessing_body">
        <xliff:g id="audio_processing_app_name">%s</xliff:g> has placed a call into the
        background. This app may be accessing and playing audio over the call.
    </string>

    <!-- Crashed in call service notification label, used when the in call service has crashed and
         the system fall back to use system dialer. [CHAR LIMIT=NONE] -->
    <string name="notification_incallservice_not_responding_title">
        <xliff:g id="in_call_service_app_name">%s</xliff:g> stopped responding
    </string>
    <!-- Body of the notification presented when an in call service crashed. [CHAR LIMIT=NONE] -->
    <string name="notification_incallservice_not_responding_body">
        Your call used the phone app that came with your device
    </string>

    <!-- Content description of the call muted notification icon for
         accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_call_muted">Call muted.</string>

    <!-- Content description of the speakerphone enabled notification icon for
         accessibility (not shown on the screen). [CHAR LIMIT=NONE] -->
    <string name="accessibility_speakerphone_enabled">Speakerphone enabled.</string>

    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_1">Can\'t talk now. What\'s up?</string>
    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_2">I\'ll call you right back.</string>
    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_3">I\'ll call you later.</string>
    <!-- Canned response for the "Respond via SMS" feature for incoming calls. [CHAR LIMIT=35] -->
    <string name="respond_via_sms_canned_response_4">Can\'t talk now. Call me later?</string>

    <!-- Title of settings screen for managing the "Respond via SMS" feature. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_setting_title">Quick responses</string>
    <!-- Slightly more verbose title of settings screen for managing the
         "Respond via SMS" feature. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_setting_title_2">Edit quick responses</string>
    <!-- Settings summary string for the "Respond via SMS" feature. [CHAR LIMIT=40] -->
    <string name="respond_via_sms_setting_summary"></string>
    <!-- Dialog title when changing a string for the "Respond via SMS" feature. [CHAR LIMIT=30] -->
    <string name="respond_via_sms_edittext_dialog_title">Quick response</string>

    <!-- "Respond via SMS": Confirmation message shown after sending
        a text response. [CHAR LIMIT=40] -->
    <string name="respond_via_sms_confirmation_format">Message sent to <xliff:g id="phone_number">%s</xliff:g>.</string>

    <!-- "Respond via SMS": Error toast shown after failing to send
        a text response. [CHAR LIMIT=40] -->
    <string name="respond_via_sms_failure_format">Message failed to send to <xliff:g id="phone_number">%s</xliff:g>.</string>

    <!-- Title of settings screen that allows user to enable and disable phone-accounts.
         Each method for placing a call (SIM1, SIM2, SIP account, etc) has a phone-account.
         Phone-accounts that are created by third party apps can be disabled and enabled by user.
         [CHAR LIMIT=30] -->
    <string name="enable_account_preference_title">Calling accounts</string>

    <!-- Message indicating that the user is not allowed to make non-emergency outgoing phone calls
         due to a user restriction -->
    <string name="outgoing_call_not_allowed_user_restriction">Only emergency calls are allowed.</string>

    <!-- Message indicating that the user is not allowed to make non-emergency outgoing phone calls
         due to the lack of the CALL_PHONE permission -->
    <string name="outgoing_call_not_allowed_no_permission">This application cannot make outgoing calls without the Phone permission.</string>

    <!-- Call failure message displayed in an error dialog used to indicate that a phone number was not provided -->
    <string name="outgoing_call_error_no_phone_number_supplied">To place a call, enter a valid number.</string>

    <!-- Message shown when the user tries to make a video call when already in a video call. -->
    <string name ="duplicate_video_call_not_allowed">Call cannot be added at this time.</string>

    <!-- missing voicemail number -->
    <!-- Title of the "Missing voicemail number" dialog -->
    <string name="no_vm_number">Missing voicemail number</string>
    <!-- Body text of the "Missing voicemail number" dialog -->
    <string name="no_vm_number_msg">No voicemail number is stored on the SIM card.</string>
    <!-- Button label on the "Missing voicemail number" dialog -->
    <string name="add_vm_number_str">Add number</string>

    <!-- Title of dialog used to confirm whether the user intends to change the default dialer
            application [CHAR LIMIT=55]-->
    <string name="change_default_dialer_dialog_title">Make <xliff:g id="new_app">%s</xliff:g> your default Phone app?</string>
    <!-- Confirmation text that a user taps on to change the Default Phone App-->
    <string name="change_default_dialer_dialog_affirmative">Set Default</string>
    <!-- Cancel text that a user taps on to not change the Default Phone App-->
    <string name="change_default_dialer_dialog_negative">Cancel</string>
    <!-- Warning message indicating what may happen if a user allows a 3rd party app to become the default dialer.-->
    <string name="change_default_dialer_warning_message"><xliff:g id="new_app">%s</xliff:g> will be able to place and control all aspects of calls. Only apps you trust should be set as the default Phone app.</string>

    <!-- Title of dialog used to confirm whether the user intends to change the default call screening
            application [CHAR LIMIT=55]-->
    <string name="change_default_call_screening_dialog_title">Make <xliff:g id="new_app">%s</xliff:g> your default call screening app?</string>
    <!-- Warning message indicating the old call screening app will no longer be able to screen calls.-->
    <string name="change_default_call_screening_warning_message_for_disable_old_app"><xliff:g id="old_app">%s</xliff:g> will no longer be able to screen calls.</string>
    <!-- Warning message indicating what may happen if a user allows a 3rd party app to become the default call screening.-->
    <string name="change_default_call_screening_warning_message"><xliff:g id="new_app">%s</xliff:g> will be able to see information about callers not in your contacts and will be able to block these calls. Only apps you trust should be set as the default call screening app.</string>
    <!-- Confirmation text that a user taps on to change the Default call screening App-->
    <string name="change_default_call_screening_dialog_affirmative">Set Default</string>
    <!-- Cancel text that a user taps on to not change the Default call screening App-->
    <string name="change_default_call_screening_dialog_negative">Cancel</string>

    <!-- Blocked numbers -->
    <string name="blocked_numbers">Blocked numbers</string>
    <!-- Text shown at the beginning of the blocked numbers screen to explain what the screen is about. -->
    <string name="blocked_numbers_msg">You won\'t receive calls or texts from blocked numbers.</string>
    <!-- Button to add a blocked number. -->
    <string name="block_number">Add a number</string>
    <!-- Body of dialog to confirm unblocking a number. -->
    <string name="unblock_dialog_body">Unblock <xliff:g id="number_to_block">%1$s</xliff:g>?</string>
    <!-- Button to unblock a number. -->
    <string name="unblock_button">Unblock</string>
    <!-- Body of dialog to block a number.  -->
    <string name="add_blocked_dialog_body">Block calls and texts from</string>
    <!-- Hint shown in the edit text box for adding a blocked number -->
    <string name="add_blocked_number_hint">Phone number</string>
    <!-- Button to block a number. -->
    <string name="block_button">Block</string>
    <!-- String shown to users unable to manage blocked numbers because they are not owners of the
        device. -->
    <string name="non_primary_user">Only the device owner can view and manage blocked numbers.</string>
    <!-- Description of icon to delete blocked number. -->
    <string name="delete_icon_description">Unblock</string>
    <!-- Title for butter bar shown when call blocking is disabled. -->
    <string name="blocked_numbers_butter_bar_title">Blocking temporarily off</string>
    <!-- Explanation for butter bar shown when call blocking is disabled. -->
    <string name="blocked_numbers_butter_bar_body">After you dial or text an emergency number, blocking is turned off to ensure that emergency services can contact you.</string>
    <!-- Button to re-enable blocking shown in butter bar shown when call blocking is disabled. -->
    <string name="blocked_numbers_butter_bar_button">Re-enable now</string>
    <!-- Message to show when a number is blocked. -->
    <string name="blocked_numbers_number_blocked_message"><xliff:g id="blocked_number">%1$s</xliff:g> blocked</string>
    <!-- Message to show when a number is unblocked. -->
    <string name="blocked_numbers_number_unblocked_message"><xliff:g id="unblocked_number">%1$s</xliff:g> unblocked</string>
    <!-- Message to show when a number cannot be blocked because it is associated with emergency services.. -->
    <string name="blocked_numbers_block_emergency_number_message">Unable to block emergency number.</string>
    <!-- Message to show when a number is already blocked. -->
    <string name="blocked_numbers_number_already_blocked_message"><xliff:g id="blocked_number">%1$s</xliff:g> is already blocked.</string>

    <!-- DO NOT TRANSLATE. Label for test Subscription 0. -->
    <string name="test_account_0_label">Q Mobile</string>
    <!-- DO NOT TRANSLATE. Label for test Subscription 1. -->
    <string name="test_account_1_label">Market Wireless</string>
    <!-- DO NOT TRANSLATE. Label for test Subscription 2. -->
    <string name="test_account_2_label">Sonoma Circles Talk Plus</string>
    <!-- DO NOT TRANSLATE. Label for test Subscription 3. -->
    <string name="test_account_3_label">Bay Voice Chat Pro</string>

    <!-- DO NOT TRANSLATE. Short description for test Subscription 0. -->
    <string name="test_account_0_short_description">Account with Q Mobile</string>
    <!-- DO NOT TRANSLATE. Short description for test Subscription 1. -->
    <string name="test_account_1_short_description">Account with Market Wireless</string>
    <!-- DO NOT TRANSLATE. Short description for test Subscription 2. -->
    <string name="test_account_2_short_description">Talk to everyone in your Circles!</string>
    <!-- DO NOT TRANSLATE. Short description for test Subscription 3. -->
    <string name="test_account_3_short_description">Chat with Chat Network users</string>

    <!-- DO NOT TRANSLATE. Hardcoded number used for restricted incoming phone numbers. -->
    <string name="handle_restricted">RESTRICTED</string>

    <string name="toast_personal_call_msg">Using the personal dialer to make the call</string>

    <!-- The "label" of the Notification for an incoming ringing call.
         call_via refers to the name of the app the incoming call is coming from.
         Example: Duo call from John Smith[CHAR LIMIT=60] -->
    <string name="notification_incoming_call"><xliff:g id="call_via">%1$s</xliff:g> call from <xliff:g id="call_from">%2$s</xliff:g></string>

    <!-- The "label" of the Notification for an incoming ringing video call.
         call_via refers to the name of the app the incoming video call is coming from.
         Example: Duo video call from John Smith[CHAR LIMIT=60] -->
    <string name="notification_incoming_video_call"><xliff:g id="call_via">%1$s</xliff:g> video call from <xliff:g id="call_from">%2$s</xliff:g></string>

    <!-- The "details" of a Notification for an incoming call which will cause an ongoing call to be
         disconnected.  This message is the part of the notification that informs the user that
         answering the current ringing call will cause a call from another app to be disconnected.
         Example: Answering will end your Duo call [CHAR LIMIT=60] -->
    <string name="answering_ends_other_call">Answering will end your <xliff:g id="call_via">%1$s</xliff:g> call</string>

    <!-- The "details" of a Notification for an incoming call which will cause other ongoing calls
         to be disconnected.  This message is the part of the notification that informs the user
         answering the current ringing call will cause calls from another app to be disconnected.
         Example: Answering will end your Duo call [CHAR LIMIT=60] -->
    <string name="answering_ends_other_calls">Answering will end your <xliff:g id="call_via">%1$s</xliff:g> calls</string>

    <!-- The "details" of a Notification for an incoming call which will cause an ongoing video call
         to be disconnected.  This message is the part of the notification that informs the user
         that answering the current ringing call will cause a video call from another app to be
         disconnected.
         Example: Answering will end your Duo video call [CHAR LIMIT=60] -->
    <string name="answering_ends_other_video_call">Answering will end your <xliff:g id="call_via">%1$s</xliff:g> video call</string>

    <!-- The "details" of a Notification for an incoming call which will cause an ongoing call
         to be disconnected.  This message is the part of the notification that informs the user
         that answering the current ringing call will cause an ongoing call to be disconnected.
         Similar to answering_ends_other_call, except does not specify which app.
         [CHAR LIMIT=60] -->
    <string name="answering_ends_other_managed_call">Answering will end your ongoing call</string>

    <!-- The "details" of a Notification for an incoming call which will cause an ongoing call
         to be disconnected.  This message is the part of the notification that informs the user
         that answering the current ringing call will cause an ongoing call to be disconnected.
         Similar to answering_ends_other_call, except does not specify which app.
         [CHAR LIMIT=60] -->
    <string name="answering_ends_other_managed_calls">Answering will end your ongoing calls</string>

    <!-- The "details" of a Notification for an incoming call which will cause an ongoing video call
         to be disconnected.  This message is the part of the notification that informs the user
         that answering the current ringing call will cause an ongoing video call to be
         disconnected.
         Similar to answering_ends_other_video_call, except does not specify which app.
         [CHAR LIMIT=60] -->
    <string name="answering_ends_other_managed_video_call">Answering will end your ongoing video call</string>

    <!-- The "answer" button for an incoming call. [CHAR LIMIT=60] -->
    <string name="answer_incoming_call">Answer</string>

    <!-- The "decline" button for an incoming call. [CHAR LIMIT=60] -->
    <string name="decline_incoming_call">Decline</string>

    <!-- Error message shown to the user when an outgoing call cannot be placed because there no
         calling service is present on the device which supports this call type.
         This is typically encountered when the user tries to dial a SIP/VOIP call, but there are
         no calling services present which support SIP calling. [CHAR LIMIT=none] -->
    <string name="cant_call_due_to_no_supported_service">Call cannot be placed because there are no calling accounts which support calls of this type.</string>

    <!-- Error message shown to the user when an outgoing call cannot be placed due to an ongoing
         phone call in a third-party app.  For example:
         Call cannot be placed due to your Duo call. [CHAR LIMIT=none] -->
    <string name="cant_call_due_to_ongoing_call">Call cannot be placed due to your <xliff:g id="other_call">%1$s</xliff:g> call.</string>

    <!-- Error message shown to the user when an outgoing call cannot be placed due to ongoing
         phone calls in a third-party app.  For example:
         Call cannot be placed due to your Duo calls. [CHAR LIMIT=none] -->
    <string name="cant_call_due_to_ongoing_calls">Call cannot be placed due to your <xliff:g id="other_call">%1$s</xliff:g> calls.</string>

    <!-- Error message shown to the user when an outgoing call cannot be placed due to an ongoing
         phone call in a third-party app.  Unlike cant_call_due_to_ongoing_call, this is used when
         the name of the other app is not known. [CHAR LIMIT=none] -->
    <string name="cant_call_due_to_ongoing_unknown_call">Call cannot be placed due to a call in another app.</string>

    <!-- Notification channel name for a channel containing incoming call notifications. -->
    <string name="notification_channel_incoming_call">Incoming calls</string>
    <!-- Notification channel name for a channel containing missed call notifications. -->
    <string name="notification_channel_missed_call">Missed calls</string>
    <!-- Notification channel name for a channel containing call blocking notifications. -->
    <string name="notification_channel_call_blocking">Call Blocking</string>
    <!-- Notification channel name for a channel containing background call notifications. -->
    <string name="notification_channel_background_calls">Background calls</string>
    <!-- Notification channel name for a channel containing disconnected call notifications. -->
    <string name="notification_channel_disconnected_calls">Disconnected calls</string>
    <!-- Notification channel name for a channel containing crashed phone apps service notifications. -->
    <string name="notification_channel_in_call_service_crash">Crashed phone apps</string>

    <!-- Alert dialog content used to inform the user that placing a new outgoing call will end the
         ongoing call in the app "other_app". -->
    <string name="alert_outgoing_call">Placing this call will end your <xliff:g id="other_app">%1$s</xliff:g> call.</string>

    <!-- Alert dialog content used to ask the user to confirm if they want to place a new outgoing call redirected by the app "other_app". -->
    <string name="alert_redirect_outgoing_call_or_not">Choose how to place this call</string>

    <!-- A button in the alert dialog "alert_redirect_outgoing_call" to place the call with the redirected number provided by App. -->
    <string name="alert_place_outgoing_call_with_redirection">Redirect call using <xliff:g id="other_app">%1$s</xliff:g></string>

    <!-- A button in the alert dialog "alert_redirect_outgoing_call" to place the call without the redirected number provided by App. -->
    <string name="alert_place_unredirect_outgoing_call">Call using my phone number</string>

    <!-- Alert dialog content used to tell the user the call is canceled because no response from the call redirection app "other_app". -->
    <string name="alert_redirect_outgoing_call_timeout">Call can\'t be placed by <xliff:g id="other_app">%1$s</xliff:g>. Try using a different call redirecting app or contacting the developer for help.</string>

    <!-- The name of a feature available under the Call settings. -->
    <string name="phone_settings_call_blocking_txt">Call Blocking</string>
    <!-- Call type to be blocked. See the explanatory text "phone_settings_number_not_in_contact_summary_txt". -->
    <string name="phone_settings_number_not_in_contact_txt">Numbers not in Contacts</string>
    <!-- Explanatory text under the call type "phone_settings_number_not_in_contact_txt". -->
    <string name="phone_settings_number_not_in_contact_summary_txt">Block numbers that are not listed in your Contacts</string>
    <!-- Call type to be blocked. See the explanatory text "phone_settings_private_num_summary_txt". This is also called Anonymous or Withheld depending on region. -->
    <string name="phone_settings_private_num_txt">Private</string>
    <!-- Explanatory text under the call type "phone_settings_payphone_summary_txt". -->
    <string name="phone_settings_private_num_summary_txt">Block callers that do not disclose their number</string>
    <!-- Call type to be blocked. See the explanatory text "phone_settings_private_num_summary_txt".  -->
    <string name="phone_settings_payphone_txt">Pay phone</string>
    <!-- Explanatory text under the call type "phone_settings_payphone_txt". -->
    <string name="phone_settings_payphone_summary_txt">Block calls from pay phones</string>
    <!-- Call type to be blocked. See the explanatory text "phone_settings_unknown_summary_txt".  -->
    <string name="phone_settings_unknown_txt">Unknown</string>
    <!-- Explanatory text under the call type "phone_settings_unknown_txt". This occurs when no caller ID information unavailable (e.g., international calls, IP phones that operators cannot identify the caller) -->
    <string name="phone_settings_unknown_summary_txt">Block calls from unidentified callers</string>
    <!-- Notification. Make this translation consistent with "phone_settings_call_blocking_txt". -->
    <string name="phone_strings_call_blocking_turned_off_notification_title_txt">Call Blocking</string>
    <!-- Notification that appears when the feature Call Blocking has been disabled. -->
    <string name="phone_strings_call_blocking_turned_off_notification_text_txt">Call Blocking disabled</string>
    <!-- Title of the dialog "phone_strings_emergency_call_made_dialog_text_txt". -->
    <string name="phone_strings_emergency_call_made_dialog_title_txt">Emergency call made</string>
    <!-- Notification details that appear when the user taps the notification "phone_strings_call_blocking_turned_off_notification_text_txt". -->
    <string name="phone_strings_emergency_call_made_dialog_call_blocking_text_txt">Call Blocking has been disabled to allow emergency responders to contact you.</string>
    <!-- Window title used for the Telecom Developer Menu -->
    <string name="developer_title">Telecom Developer Menu</string>
    <!-- Some carriers allow an "external" call that has been placed on another device (another
    tablet, phone, etc...) to be transferred to this device and taken as a call. In
    the situation that we are already in an emergency call, notify the user that the call can not
    be taken at this time.-->
    <string name="toast_emergency_can_not_pull_call">Calls can not be taken while in an emergency call.</string>
    <!-- Label for a switch in the Telecom Developer Menu which is used to enable the enhanced call
         blocking functionality (for test purposes).
         DO NOT TRANSLATE -->
    <string name="developer_enhanced_call_blocking" translatable="false">Enhanced Call Blocking</string>
    <!-- Button label for generic cancel action [CHAR LIMIT=20] -->
    <string name="cancel">Cancel</string>
</resources>
