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

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

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

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

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