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

    <!-- Title displayed SIP settings coming after other call settings in the call features screen. [CHAR LIMIT=NONE] -->
    <string name="sip_settings">SIP settings</string>
    <!-- Title displayed SIP account settings in the sip settings category. [CHAR LIMIT=NONE] -->
    <string name="sip_accounts">SIP accounts</string>
    <!-- Title displayed SIP account settings in the sip settings category. [CHAR LIMIT=NONE] -->
    <string name="sip_accounts_title">Accounts</string>
    <!-- Title displayed for the button of receiving incoming SIP calls flag. Enabled for receiving calls. [CHAR LIMIT=NONE] -->
    <string name="sip_receive_calls">Receive incoming calls</string>
    <!-- Help user to understand that it will require more battery usage if the 'receiving incoming call' is enabled. [CHAR LIMIT=NONE] -->
    <string name="sip_receive_calls_summary">Uses more battery life</string>
    <!-- Title for the dialog of selecting the way we handle an outgoing call. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_title">Use SIP calling</string>
    <!-- Title for the dialog of selecting the way we handle an outgoing call (Wi-Fi only). [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_wifi_only_title">Use SIP calling (Wi-Fi only)</string>

    <!-- Item of the SIP call option dialog: for routing all outgoing calls via SIP. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_entry_1">For all calls when data network is available</string>
    <!-- Item of the SIP call option dialog: for routing a outgoing call via SIP if the destination is a SIP URI. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_entry_2">Only for SIP calls</string>
    <!-- Item of the SIP call (Wi-Fi only) option dialog: for routing all outgoing calls via SIP. [CHAR LIMIT=NONE] -->
    <string name="sip_call_options_wifi_only_entry_1">For all calls</string>

    <!-- Title for the button to add a new sip account. [CHAR LIMIT=NONE] -->
    <string name="add_sip_account">Add account</string>
    <!-- Title for the button to remove a sip account. [CHAR LIMIT=NONE] -->
    <string name="remove_sip_account">Remove account</string>
    <!-- String of the category which lists all sip accounts. [CHAR LIMIT=NONE] -->
    <string name="sip_account_list">SIP accounts</string>
    <!-- Toast message to indicate that the system is saving the account. [CHAR LIMIT=NONE] -->
    <string name="saving_account">Saving the account\u2026</string>
    <!-- Toast message to indicate that the system is removing the account. [CHAR LIMIT=NONE] -->
    <string name="removing_account">Removing the account\u2026</string>

    <!-- Menu item when the menu button is pressed in the sip account editor. [CHAR LIMIT=NONE] -->
    <string name="sip_menu_save">Save</string>
    <!-- Menu item when the menu button is pressed in the sip account editor. [CHAR LIMIT=NONE] -->
    <string name="sip_menu_discard">Discard</string>

    <!-- Title of the alert dialog. [CHAR LIMIT=NONE] -->
    <string name="alert_dialog_close">Close the profile</string>
    <!-- Title of the button to show in a alert dialog. [CHAR LIMIT=NONE] -->
    <string name="alert_dialog_ok">OK</string>
    <!-- Title of the button to show in a alert dialog. [CHAR LIMIT=NONE] -->
    <string name="close_profile">Close</string>

    <!-- Text of SIP-call registration status, checking current registration status with SIP service [CHAR LIMIT=NONE] -->
    <string name="registration_status_checking_status">Checking status...</string>
    <!-- Text of SIP-call registration status, registering with SIP server in order to receive calls on this account [CHAR LIMIT=NONE] -->
    <string name="registration_status_registering">Registering\u2026</string>
    <!-- Text of SIP-call registration status, still trying to register with SIP server [CHAR LIMIT=NONE] -->
    <string name="registration_status_still_trying">Still trying\u2026</string>
    <!-- Text of SIP-call registration status, currently not receiving calls on this account [CHAR LIMIT=NONE] -->
    <string name="registration_status_not_receiving">Not receiving calls.</string>
    <!-- Text of SIP-call registration status, no data connection [CHAR LIMIT=NONE] -->
    <string name="registration_status_no_data">Account registration stopped because there is no Internet connection.</string>
    <!-- Text of SIP-call registration status, no Wi-Fi connection [CHAR LIMIT=NONE] -->
    <string name="registration_status_no_wifi_data">Account registration stopped because there is no Wi-Fi connection.</string>
    <!-- Text of SIP-call registration status, registration process is not running due to some error [CHAR LIMIT=NONE] -->
    <string name="registration_status_not_running">Account registration unsuccessful.</string>
    <!-- Text of SIP-call registration status, currently we can receive calls on this account [CHAR LIMIT=NONE] -->
    <string name="registration_status_done">Receiving calls.</string>
    <!-- Text of SIP-call registration status, registration failed with a reason; will try again later [CHAR LIMIT=NONE] -->
    <string name="registration_status_failed_try_later">Account registration unsuccessful: (<xliff:g id="registration_error_message" example="timed out">%s</xliff:g>); will try later</string>
    <!-- Text of SIP-call registration status, registration failed due to invalid credentials [CHAR LIMIT=NONE] -->
    <string name="registration_status_invalid_credentials">Account registration unsuccessful: Incorrect username or password.</string>
    <!-- Text of SIP-call registration status, registration failed due to unknown host exception [CHAR LIMIT=NONE] -->
    <string name="registration_status_server_unreachable">Account registration unsuccessful: Check the server name.</string>
    <!-- Text for describing the account's owner and status. For example, 'Active, in use by Google Talk', it means that the account managed by SIP service was registered by the application 'Google Talk' and the status is active. [CHAR LIMIT=NONE] -->
    <string name="third_party_account_summary">This account is currently in use by the <xliff:g id="account_owner" example="Google Talk">%s</xliff:g> app.</string>


    <!-- Title of the sip editor screen. [CHAR LIMIT=NONE] -->
    <string name="sip_edit_title">SIP account details</string>
    <!-- Title of the sip editor screen. [CHAR LIMIT=NONE] -->
    <string name="sip_edit_new_title">SIP account details</string>

    <!-- Text of the domain address preference. [CHAR LIMIT=NONE] -->
    <string name="domain_address_title">Server</string>
    <!-- Text of the username preference. [CHAR LIMIT=NONE] -->
    <string name="username_title">Username</string>
    <!-- Text of the password preference. [CHAR LIMIT=NONE] -->
    <string name="password_title">Password</string>
    <!-- Text of the display name preference. [CHAR LIMIT=NONE] -->
    <string name="display_name_title">Display name</string>
    <!-- Text of the outbound proxy address preference. [CHAR LIMIT=NONE] -->
    <string name="proxy_address_title">Outbound proxy address</string>
    <!-- Text of the sip server/proxy port number. [CHAR LIMIT=NONE] -->
    <string name="port_title">Port number</string>
    <!-- Text of the transport type preference. [CHAR LIMIT=NONE] -->
    <string name="transport_title">Transport type</string>
    <!-- Text of the keepalive preference. [CHAR LIMIT=NONE] -->
    <string name="send_keepalive_title">Send keep-alive</string>
    <!-- Text of the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings">Optional settings</string>
    <!-- Text of the username used in authentication. [CHAR LIMIT=NONE] -->
    <string name="auth_username_title">Authentication username</string>
    <!-- Help text of the auth_username field. [CHAR LIMIT=NONE] -->
    <string name="auth_username_summary">Username used for authentication</string>

    <!-- Initial status of the username preference is '<Not set>'. [CHAR LIMIT=NONE] -->
    <string name="default_preference_summary_username">&lt;Not set&gt;</string>
    <!-- Initial status of the password preference is '<Not set>'. [CHAR LIMIT=NONE] -->
    <string name="default_preference_summary_password">&lt;Not set&gt;</string>
    <!-- Initial status of the domain address preference is '<Not set>'. [CHAR LIMIT=NONE] -->
    <string name="default_preference_summary_domain_address">&lt;Not set&gt;</string>
    <!-- Default value for the display-name preference summary. [CHAR LIMIT=NONE] -->
    <string name="display_name_summary">&lt;Same as username&gt;</string>
    <!-- Default value for the outbound-proxy-address preference summary. [CHAR LIMIT=NONE] -->
    <string name="optional_summary">&lt;Optional&gt;</string>

    <!-- Default sip server/proxy port number. -->
    <string translatable="false" name="default_port">5060</string>
    <!-- Default sip server/proxy transport protocol. -->
    <string translatable="false" name="default_transport">UDP</string>


    <!-- Hint to show the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings_show">▷ Touch to show all</string>
    <!-- Hint to hide the advanced settings section. [CHAR LIMIT=NONE] -->
    <string name="advanced_settings_hide">▽ Touch to hide all</string>

    <!-- Text in an alert dialog telling the user that all input fields can not be left blank. [CHAR LIMIT=NONE] -->
    <string name="all_empty_alert">Enter details of new SIP account.</string>
    <!-- Text in an alert dialog telling the user that some input field (name of which is also part of the strings being translated above) is required and can not be left blank. [CHAR LIMIT=NONE] -->
    <string name="empty_alert"><xliff:g id="input_field_name" example="Username, Password...">%s</xliff:g> is required and can\'t be left blank.</string>
    <!-- Showing that port number is out of range in an alert dialog. [CHAR LIMIT=NONE] -->
    <string name="not_a_valid_port">Port number should be within 1000 and 65534.</string>

    <!-- Message of the alert dialog to notify user that there is no Internet connectivity. [CHAR LIMIT=NONE] -->
    <string name="no_internet_available">To place a SIP call, check your Internet connection first.</string>
    <!-- Message of the alert dialog to notify user that there is no Wi-Fi connectivity. [CHAR LIMIT=NONE] -->
    <string name="no_wifi_available">You need to be connected to a Wi-Fi network for SIP calls (use the Wireless &amp; Network settings).</string>
    <!-- Message of the alert dialog to notify user that SIP call is not supported. [CHAR LIMIT=NONE] -->
    <string name="no_voip">SIP calling not supported</string>

    <!-- Option for whether the SIP service should send keepalive messages. [CHAR LIMIT=40] -->
    <string translatable="true" name="sip_system_decide">Automatic</string>
    <!-- Option for whether the SIP service should send keepalive messages. [CHAR LIMIT=40] -->
    <string translatable="true" name="sip_always_send_keepalive">Always send</string>

    <!-- Do not translate the following strings. Used for the SIP call options. Need to be in-sync with Settings.System.SIP_ strings. -->
    <string translatable="false" name="sip_always">SIP_ALWAYS</string>
    <string translatable="false" name="sip_address_only">SIP_ADDRESS_ONLY</string>

    <!-- Do not translate the following strings. Used for the preference keys -->
    <string translatable="false" name="domain_address">SipDomain</string>
    <string translatable="false" name="username">UserName</string>
    <string translatable="false" name="password">Password</string>
    <string translatable="false" name="display_name">DisplayName</string>
    <string translatable="false" name="proxy_address">ProxyAddress</string>
    <string translatable="false" name="port">Port</string>
    <string translatable="false" name="transport">Protocol</string>
    <string translatable="false" name="send_keepalive">SendKeepAlive</string>
    <string translatable="false" name="advanced_settings_container">advanced settings container</string>
    <string translatable="false" name="auth_username">AuthUserName</string>

    <!-- Label for SIP connection service. -->
    <string name="sip_connection_service_label">Built-in SIP calling</string>
</resources>
