<?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:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="sip_settings" msgid="3768482698061677257">"Nastavitve SIP"</string>
    <string name="sip_accounts" msgid="85559497282185405">"Računi SIP"</string>
    <string name="sip_accounts_title" msgid="2082527045326874519">"Računi"</string>
    <string name="sip_receive_calls" msgid="426678617137462173">"Sprejmi dohodne klice"</string>
    <string name="sip_receive_calls_summary" msgid="946161517528227523">"Poraba akumulatorja je večja"</string>
    <string name="sip_call_options_title" msgid="8421210494703869806">"Uporaba klicanja SIP"</string>
    <string name="sip_call_options_wifi_only_title" msgid="5112579243580893890">"Uporaba klicanja SIP (samo v omrežju Wi-Fi)"</string>
    <string name="sip_call_options_entry_1" msgid="7217659161237099900">"Za vse klice, ko podatkovno omrežje ni na voljo"</string>
    <string name="sip_call_options_entry_2" msgid="1815335903940609729">"Samo za klice SIP"</string>
    <string name="sip_call_options_wifi_only_entry_1" msgid="1358513095551847314">"Za vse klice"</string>
    <string name="add_sip_account" msgid="800843669753980091">"Dodajanje računa"</string>
    <string name="remove_sip_account" msgid="1367664438506503690">"Odstrani račun"</string>
    <string name="sip_account_list" msgid="5610858485304821480">"Računi SIP"</string>
    <string name="saving_account" msgid="5336529880235177448">"Shranjevanje računa ..."</string>
    <string name="removing_account" msgid="5537351356808985756">"Odstranjevanje računa ..."</string>
    <string name="sip_menu_save" msgid="7882219814563869225">"Shrani"</string>
    <string name="sip_menu_discard" msgid="2350421645423888438">"Zavrzi"</string>
    <string name="alert_dialog_close" msgid="1326011828713435134">"Zapiranje profila"</string>
    <string name="alert_dialog_ok" msgid="4752048404605388940">"V redu"</string>
    <string name="close_profile" msgid="3122414058856309881">"Zapri"</string>
    <string name="registration_status_checking_status" msgid="6136793741862200337">"Preverjanje stanja ..."</string>
    <string name="registration_status_registering" msgid="2677183977796278749">"Registriranje ..."</string>
    <string name="registration_status_still_trying" msgid="7648151061205513458">"Še vedno poskušamo ..."</string>
    <string name="registration_status_not_receiving" msgid="7620333886153361090">"Ne sprejema klicev."</string>
    <string name="registration_status_no_data" msgid="2541999976218192413">"Registracija računa je bila prekinjena, ker ni internetne povezave."</string>
    <string name="registration_status_no_wifi_data" msgid="9154717387473039546">"Registracija računa je bila prekinjena, ker ni povezave Wi-Fi."</string>
    <string name="registration_status_not_running" msgid="514205414303796800">"Registracija računa ni uspela."</string>
    <string name="registration_status_done" msgid="3264961069247314253">"Sprejemanje klicev."</string>
    <string name="registration_status_failed_try_later" msgid="2199970021756384317">"Registracija računa ni uspela: (<xliff:g id="REGISTRATION_ERROR_MESSAGE">%s</xliff:g>). Pozneje sledi vnovičen poskus."</string>
    <string name="registration_status_invalid_credentials" msgid="8406872554323334182">"Registracija računa ni uspela: napačno uporabniško ime ali geslo."</string>
    <string name="registration_status_server_unreachable" msgid="7710275557045148634">"Registracija računa ni uspela: preverite ime strežnika."</string>
    <string name="third_party_account_summary" msgid="9041060473615403041">"Ta račun trenutno uporablja aplikacija <xliff:g id="ACCOUNT_OWNER">%s</xliff:g>."</string>
    <string name="sip_edit_title" msgid="1967247832635750410">"Podrobnosti o računu SIP"</string>
    <string name="sip_edit_new_title" msgid="266414118302574305">"Podrobnosti o računu SIP"</string>
    <string name="domain_address_title" msgid="1968479941328225423">"Strežnik"</string>
    <string name="username_title" msgid="6770064611005663470">"Uporabniško ime"</string>
    <string name="password_title" msgid="5289013731515564295">"Geslo"</string>
    <string name="display_name_title" msgid="579241787583079773">"Prikazno ime"</string>
    <string name="proxy_address_title" msgid="6890163365640631841">"Naslov strežnika proxy za odhodne klice"</string>
    <string name="port_title" msgid="6693965912656593862">"Številka vrat"</string>
    <string name="transport_title" msgid="889155457465372527">"Vrsta transporta"</string>
    <string name="send_keepalive_title" msgid="599627072150501159">"Pošlji ohranjanje povezave"</string>
    <string name="advanced_settings" msgid="6622996380747040711">"Izbirne nastavitve"</string>
    <string name="auth_username_title" msgid="8262491689004708265">"Uporabniško ime za preverjanje pristnosti"</string>
    <string name="auth_username_summary" msgid="941160241371436473">"Uporabniško ime za preverjanje pristnosti"</string>
    <string name="default_preference_summary_username" msgid="8404717434312826082">"&lt;Ni nastavljeno&gt;"</string>
    <string name="default_preference_summary_password" msgid="4464464672997027904">"&lt;Ni nastavljeno&gt;"</string>
    <string name="default_preference_summary_domain_address" msgid="4871971710197441673">"&lt;Ni nastavljeno&gt;"</string>
    <string name="display_name_summary" msgid="7155076491675565407">"&lt;Enako kot uporabniško ime&gt;"</string>
    <string name="optional_summary" msgid="2363105560396317624">"&lt;Izbirno&gt;"</string>
    <string name="advanced_settings_show" msgid="7838761602853998622">"▷ Dotaknite se, da prikažete vse"</string>
    <string name="advanced_settings_hide" msgid="3480554978705290228">"▽ Dotaknite se, če želite skriti vse"</string>
    <string name="all_empty_alert" msgid="4087734950375192387">"Vnesite podrobnosti novega računa SIP."</string>
    <string name="empty_alert" msgid="6659484914371384024">"Polje <xliff:g id="INPUT_FIELD_NAME">%s</xliff:g> je obvezno in ne sme biti prazno."</string>
    <string name="not_a_valid_port" msgid="7931422555587011830">"Številka vrat mora biti med 1000 in 65534."</string>
    <string name="no_internet_available" msgid="5523747991760017298">"Če želite opraviti klic SIP, najprej preverite internetno povezavo."</string>
    <string name="no_wifi_available" msgid="1955023904229673488">"Za klice SIP morate biti povezani v omrežje Wi-Fi (uporabite nastavitve »Brezžično in omrežja«)."</string>
    <string name="no_voip" msgid="3038021971231952704">"Klicanje SIP ni podprto"</string>
    <string name="sip_system_decide" msgid="5577696249416700671">"Samodejno"</string>
    <string name="sip_always_send_keepalive" msgid="4773022409239823318">"Vedno pošlji"</string>
    <string name="sip_connection_service_label" msgid="6935325004265884453">"Vgrajeno klicanje SIP"</string>
</resources>
