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