<?xml version="1.0" encoding="UTF-8"?>
<!-- 
/* //device/apps/common/assets/res/any/strings.xml
**
** Copyright 2006, 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="byteShort" msgid="8340973892742019101">"B"</string>
    <string name="kilobyteShort" msgid="5973789783504771878">"kB"</string>
    <string name="megabyteShort" msgid="6355851576770428922">"MB"</string>
    <string name="gigabyteShort" msgid="3259882455212193214">"GB"</string>
    <string name="terabyteShort" msgid="231613018159186962">"TB"</string>
    <string name="petabyteShort" msgid="5637816680144990219">"PB"</string>
    <string name="fileSizeSuffix" msgid="7670819340156489359">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="untitled" msgid="6071602020171759109">"&lt;bez názvu&gt;"</string>
    <string name="ellipsis" msgid="7899829516048813237">"…"</string>
    <string name="emptyPhoneNumber" msgid="7694063042079676517">"(žádné telefonní číslo)"</string>
    <string name="unknownName" msgid="2277556546742746522">"(Neznámé)"</string>
    <string name="defaultVoiceMailAlphaTag" msgid="2660020990097733077">"Hlasová schránka"</string>
    <string name="defaultMsisdnAlphaTag" msgid="2850889754919584674">"MSISDN1"</string>
    <string name="mmiError" msgid="5154499457739052907">"Problém s připojením nebo neplatný kód MMI."</string>
    <string name="serviceEnabled" msgid="8147278346414714315">"Služba byla zapnuta."</string>
    <string name="serviceEnabledFor" msgid="6856228140453471041">"Služba byla zapnuta pro:"</string>
    <string name="serviceDisabled" msgid="1937553226592516411">"Služba byla vypnuta."</string>
    <string name="serviceRegistered" msgid="6275019082598102493">"Registrace byla úspěšná."</string>
    <string name="serviceErased" msgid="1288584695297200972">"Smazaní proběhlo úspěšně."</string>
    <string name="passwordIncorrect" msgid="7612208839450128715">"Nesprávné heslo."</string>
    <string name="mmiComplete" msgid="8232527495411698359">"Funkce MMI byla dokončena."</string>
    <string name="badPin" msgid="5085454289896032547">"Původní kód PIN byl zadán nesprávně."</string>
    <string name="badPuk" msgid="5702522162746042460">"Kód PUK byl zadán nesprávně."</string>
    <string name="mismatchPin" msgid="3695902225843339274">"Zadané kódy PIN se neshodují."</string>
    <string name="invalidPin" msgid="3850018445187475377">"Zadejte kód PIN o délce 4-8 číslic."</string>
    <string name="needPuk" msgid="919668385956251611">"Karta SIM je blokována pomocí kódu PUK. Odblokujete ji zadáním kódu PUK."</string>
    <string name="needPuk2" msgid="4526033371987193070">"Chcete-li odblokovat kartu SIM, zadejte kód PUK2."</string>
    <string name="ClipMmi" msgid="6952821216480289285">"Příchozí identifikace volajícího"</string>
    <string name="ClirMmi" msgid="7784673673446833091">"Odchozí identifikace volajícího"</string>
    <string name="CfMmi" msgid="5123218989141573515">"Přesměrování hovorů"</string>
    <string name="CwMmi" msgid="9129678056795016867">"Další hovor na lince"</string>
    <string name="BaMmi" msgid="455193067926770581">"Blokování hovorů"</string>
    <string name="PwdMmi" msgid="7043715687905254199">"Změna hesla"</string>
    <string name="PinMmi" msgid="3113117780361190304">"Změna kódu PIN"</string>
    <string name="CnipMmi" msgid="3110534680557857162">"Volané číslo uvedeno"</string>
    <string name="CnirMmi" msgid="3062102121430548731">"Volání čísla omezeno"</string>
    <string name="ThreeWCMmi" msgid="9051047170321190368">"Konference tří účastníků"</string>
    <string name="RuacMmi" msgid="7827887459138308886">"Odmítnutí nevyžádaných obtěžujících hovorů"</string>
    <string name="CndMmi" msgid="3116446237081575808">"Doručení volaného čísla"</string>
    <string name="DndMmi" msgid="1265478932418334331">"Nerušit"</string>
    <string name="CLIRDefaultOnNextCallOn" msgid="429415409145781923">"Ve výchozím nastavení je identifikace volajícího omezena. Příští hovor: Omezeno"</string>
    <string name="CLIRDefaultOnNextCallOff" msgid="3092918006077864624">"Ve výchozím nastavení je identifikace volajícího omezena. Příští hovor: Neomezeno"</string>
    <string name="CLIRDefaultOffNextCallOn" msgid="6179425182856418465">"Ve výchozím nastavení není identifikace volajícího omezena. Příští hovor: Omezeno"</string>
    <string name="CLIRDefaultOffNextCallOff" msgid="2567998633124408552">"Ve výchozím nastavení není identifikace volajícího omezena. Příští hovor: Neomezeno"</string>
    <string name="serviceNotProvisioned" msgid="8614830180508686666">"Služba není zřízena."</string>
    <string name="CLIRPermanent" msgid="5460892159398802465">"Nelze změnit nastavení identifikace volajícího."</string>
    <string name="RestrictedChangedTitle" msgid="5592189398956187498">"Omezený přístup byl změněn."</string>
    <string name="RestrictedOnData" msgid="8653794784690065540">"Datová služba je zablokována."</string>
    <string name="RestrictedOnEmergency" msgid="6581163779072833665">"Tísňová linka je zablokována."</string>
    <string name="RestrictedOnNormal" msgid="4953867011389750673">"Hlasová služba je zablokována."</string>
    <string name="RestrictedOnAllVoice" msgid="1459318899842232234">"Veškeré hlasové služby jsou zablokovány."</string>
    <string name="RestrictedOnSms" msgid="8314352327461638897">"Služby SMS jsou zablokovány."</string>
    <string name="RestrictedOnVoiceData" msgid="8244438624660371717">"Hlasové a datové služby jsou zablokovány."</string>
    <string name="RestrictedOnVoiceSms" msgid="1888588152792023873">"Hlasové služby a služby SMS jsou zablokovány."</string>
    <string name="RestrictedOnAll" msgid="2714924667937117304">"Veškeré hlasové a datové služby a služby SMS jsou zablokovány."</string>
    <string name="serviceClassVoice" msgid="1258393812335258019">"Hlas"</string>
    <string name="serviceClassData" msgid="872456782077937893">"Data"</string>
    <string name="serviceClassFAX" msgid="5566624998840486475">"FAX"</string>
    <string name="serviceClassSMS" msgid="2015460373701527489">"SMS"</string>
    <string name="serviceClassDataAsync" msgid="4523454783498551468">"Async"</string>
    <string name="serviceClassDataSync" msgid="7530000519646054776">"Synchronizace"</string>
    <string name="serviceClassPacket" msgid="6991006557993423453">"Pakety"</string>
    <string name="serviceClassPAD" msgid="3235259085648271037">"PAD"</string>
    <string name="roamingText0" msgid="7170335472198694945">"Indikátor roamingu svítí"</string>
    <string name="roamingText1" msgid="5314861519752538922">"Indikátor roamingu nesvítí"</string>
    <string name="roamingText2" msgid="8969929049081268115">"Indikátor roamingu bliká"</string>
    <string name="roamingText3" msgid="5148255027043943317">"Není v blízkosti"</string>
    <string name="roamingText4" msgid="8808456682550796530">"Mimo budovu"</string>
    <string name="roamingText5" msgid="7604063252850354350">"Roaming – preferovaný systém"</string>
    <string name="roamingText6" msgid="2059440825782871513">"Roaming – dostupný systém"</string>
    <string name="roamingText7" msgid="7112078724097233605">"Roaming – alianční partner"</string>
    <string name="roamingText8" msgid="5989569778604089291">"Roaming – prémiový partner"</string>
    <string name="roamingText9" msgid="7969296811355152491">"Roaming – úplná funkčnost služby"</string>
    <string name="roamingText10" msgid="3992906999815316417">"Roaming – částečná funkčnost služby"</string>
    <string name="roamingText11" msgid="4154476854426920970">"Banner roamingu je zapnutý"</string>
    <string name="roamingText12" msgid="1189071119992726320">"Banner roamingu je vypnutý"</string>
    <string name="roamingTextSearching" msgid="8360141885972279963">"Vyhledávání služby"</string>
    <string name="cfTemplateNotForwarded" msgid="1683685883841272560">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nepřesměrováno"</string>
    <string name="cfTemplateForwarded" msgid="1302922117498590521">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g>"</string>
    <string name="cfTemplateForwardedTime" msgid="9206251736527085256">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: <xliff:g id="DIALING_NUMBER">{1}</xliff:g> po <xliff:g id="TIME_DELAY">{2}</xliff:g> sek."</string>
    <string name="cfTemplateRegistered" msgid="5073237827620166285">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nepřesměrováno"</string>
    <string name="cfTemplateRegisteredTime" msgid="6781621964320635172">"<xliff:g id="BEARER_SERVICE_CODE">{0}</xliff:g>: Nepřesměrováno"</string>
    <string name="fcComplete" msgid="3118848230966886575">"Požadavek zadaný pomocí kódu funkce byl úspěšně dokončen."</string>
    <string name="fcError" msgid="3327560126588500777">"Problém s připojením nebo neplatný kód funkce."</string>
    <string name="httpErrorOk" msgid="1191919378083472204">"OK"</string>
    <string name="httpError" msgid="2567300624552921790">"Webová stránka obsahuje chybu."</string>
    <string name="httpErrorLookup" msgid="4517085806977851374">"Adresu URL nelze najít."</string>
    <string name="httpErrorUnsupportedAuthScheme" msgid="2781440683514730227">"Schéma ověření webu není podporováno."</string>
    <string name="httpErrorAuth" msgid="7293960746955020542">"Ověření nebylo úspěšné."</string>
    <string name="httpErrorProxyAuth" msgid="1788207010559081331">"Ověření pomocí serveru proxy bylo neúspěšné."</string>
    <string name="httpErrorConnect" msgid="7623096283505770433">"Připojení k serveru bylo neúspěšné."</string>
    <string name="httpErrorIO" msgid="5047872902739125260">"Komunikace se serverem se nezdařila. Opakujte akci později."</string>
    <string name="httpErrorTimeout" msgid="4743403703762883954">"Spojení se serverem vypršelo."</string>
    <string name="httpErrorRedirectLoop" msgid="8679596090392779516">"Stránka obsahuje příliš mnoho přesměrování serveru."</string>
    <string name="httpErrorUnsupportedScheme" msgid="5257172771607996054">"Protokol není podporován."</string>
    <string name="httpErrorFailedSslHandshake" msgid="3088290300440289771">"Nelze navázat zabezpečené spojení."</string>
    <string name="httpErrorBadUrl" msgid="6088183159988619736">"Stránku nelze otevřít, protože adresa URL je neplatná."</string>
    <string name="httpErrorFile" msgid="8250549644091165175">"K souboru nelze získat přístup."</string>
    <string name="httpErrorFileNotFound" msgid="5588380756326017105">"Požadovaný soubor nebyl nalezen."</string>
    <string name="httpErrorTooManyRequests" msgid="1235396927087188253">"Je zpracováváno příliš mnoho požadavků. Opakujte akci později."</string>
    <string name="notification_title" msgid="1259940370369187045">"Chyba přihlášení k účtu <xliff:g id="ACCOUNT">%1$s</xliff:g>"</string>
    <string name="contentServiceSync" msgid="8353523060269335667">"Synchronizace"</string>
    <string name="contentServiceSyncNotificationTitle" msgid="397743349191901458">"Synchronizace"</string>
    <string name="contentServiceTooManyDeletesNotificationDesc" msgid="8100981435080696431">"Příliš mnoho smazaných položek služby <xliff:g id="CONTENT_TYPE">%s</xliff:g>."</string>
    <string name="low_memory" msgid="6632412458436461203">"Paměť telefonu je plná. Smažte některé soubory a uvolněte místo."</string>
    <string name="me" msgid="6545696007631404292">"Já"</string>
    <string name="power_dialog" msgid="1319919075463988638">"Možnosti telefonu"</string>
    <string name="silent_mode" msgid="7167703389802618663">"Tichý režim"</string>
    <string name="turn_on_radio" msgid="3912793092339962371">"Zapnout bezdrátové připojení"</string>
    <string name="turn_off_radio" msgid="8198784949987062346">"Vypnout bezdrátové připojení"</string>
    <string name="screen_lock" msgid="799094655496098153">"Zámek obrazovky"</string>
    <string name="power_off" msgid="4266614107412865048">"Vypnout"</string>
    <string name="shutdown_progress" msgid="2281079257329981203">"Vypínání..."</string>
    <string name="shutdown_confirm" msgid="649792175242821353">"Váš telefon bude vypnut."</string>
    <string name="recent_tasks_title" msgid="3691764623638127888">"Nejnovější"</string>
    <string name="no_recent_tasks" msgid="279702952298056674">"Žádné nedávno použité aplikace."</string>
    <string name="global_actions" msgid="2406416831541615258">"Možnosti telefonu"</string>
    <string name="global_action_lock" msgid="2844945191792119712">"Zámek obrazovky"</string>
    <string name="global_action_power_off" msgid="4471879440839879722">"Vypnout"</string>
    <string name="global_action_toggle_silent_mode" msgid="8219525344246810925">"Tichý režim"</string>
    <string name="global_action_silent_mode_on_status" msgid="3289841937003758806">"Zvuk je VYPNUTÝ."</string>
    <string name="global_action_silent_mode_off_status" msgid="1506046579177066419">"Zvuk je zapnutý"</string>
    <string name="global_actions_toggle_airplane_mode" msgid="5884330306926307456">"Režim V letadle"</string>
    <string name="global_actions_airplane_mode_on_status" msgid="2719557982608919750">"Režim V letadle je ZAPNUTÝ"</string>
    <string name="global_actions_airplane_mode_off_status" msgid="5075070442854490296">"Režim V letadle je VYPNUTÝ"</string>
    <string name="safeMode" msgid="2788228061547930246">"Nouzový režim"</string>
    <string name="android_system_label" msgid="6577375335728551336">"Systém Android"</string>
    <string name="permgrouplab_costMoney" msgid="5429808217861460401">"Zpoplatněné služby"</string>
    <string name="permgroupdesc_costMoney" msgid="8193824940620517189">"Umožňuje aplikacím provádět činnosti, které vás mohou stát peníze."</string>
    <string name="permgrouplab_messages" msgid="7521249148445456662">"Vaše zprávy"</string>
    <string name="permgroupdesc_messages" msgid="7045736972019211994">"Čtení a zápis zpráv SMS, e-mailů a dalších zpráv."</string>
    <string name="permgrouplab_personalInfo" msgid="3519163141070533474">"Vaše osobní informace"</string>
    <string name="permgroupdesc_personalInfo" msgid="5488050357388806068">"Přímý přístup k vašim kontaktům a kalendáři v telefonu."</string>
    <string name="permgrouplab_location" msgid="635149742436692049">"Vaše poloha"</string>
    <string name="permgroupdesc_location" msgid="2430258821648348660">"Sleduje vaši fyzickou polohu"</string>
    <string name="permgrouplab_network" msgid="5808983377727109831">"Síťová komunikace"</string>
    <string name="permgroupdesc_network" msgid="5035763698958415998">"Umožňuje aplikacím získat přístup k různým funkcím sítě."</string>
    <string name="permgrouplab_accounts" msgid="3359646291125325519">"Vaše účty"</string>
    <string name="permgroupdesc_accounts" msgid="4948732641827091312">"Přístup k dostupným účtům."</string>
    <string name="permgrouplab_hardwareControls" msgid="7998214968791599326">"Řízení hardwaru"</string>
    <string name="permgroupdesc_hardwareControls" msgid="4357057861225462702">"Přímý přístup k hardwaru telefonu."</string>
    <string name="permgrouplab_phoneCalls" msgid="9067173988325865923">"Telefonní hovory"</string>
    <string name="permgroupdesc_phoneCalls" msgid="7489701620446183770">"Sledování, záznam a zpracování telefonních hovorů."</string>
    <string name="permgrouplab_systemTools" msgid="4652191644082714048">"Systémové nástroje"</string>
    <string name="permgroupdesc_systemTools" msgid="8162102602190734305">"Nízkoúrovňový přístup a kontrola nad systémem."</string>
    <string name="permgrouplab_developmentTools" msgid="3446164584710596513">"Nástroje pro vývojáře"</string>
    <string name="permgroupdesc_developmentTools" msgid="9056431193893809814">"Funkce pouze pro vývojáře aplikací"</string>
    <string name="permgrouplab_storage" msgid="1971118770546336966">"Úložiště"</string>
    <string name="permgroupdesc_storage" msgid="9203302214915355774">"Přístup ke kartě SD."</string>
    <string name="permlab_statusBar" msgid="7417192629601890791">"zakázání či změny stavového řádku"</string>
    <string name="permdesc_statusBar" msgid="1365473595331989732">"Umožňuje aplikaci zakázat stavový řádek nebo přidat či odebrat systémové ikony."</string>
    <string name="permlab_expandStatusBar" msgid="1148198785937489264">"rozbalení a sbalení stavového řádku"</string>
    <string name="permdesc_expandStatusBar" msgid="7088604400110768665">"Umožňuje aplikaci rozbalit či sbalit stavový řádek."</string>
    <string name="permlab_processOutgoingCalls" msgid="1136262550878335980">"zachycení odchozích hovorů"</string>
    <string name="permdesc_processOutgoingCalls" msgid="2228988201852654461">"Umožňuje aplikaci zpracovat odchozí hovory a změnit číslo, které má být vytočeno. Škodlivé aplikace mohou sledovat či přesměrovat odchozí hovory nebo jim zabránit."</string>
    <string name="permlab_receiveSms" msgid="2697628268086208535">"příjem zpráv SMS"</string>
    <string name="permdesc_receiveSms" msgid="6298292335965966117">"Umožňuje aplikaci přijímat a zpracovávat zprávy SMS. Škodlivé aplikace mohou sledovat vaše zprávy nebo je smazat, aniž by vám byly zobrazeny."</string>
    <string name="permlab_receiveMms" msgid="8894700916188083287">"příjem zpráv MMS"</string>
    <string name="permdesc_receiveMms" msgid="4563346832000174373">"Umožňuje aplikaci přijímat a zpracovávat zprávy MMS. Škodlivé aplikace mohou sledovat vaše zprávy nebo je smazat, aniž by vám byly zobrazeny."</string>
    <string name="permlab_sendSms" msgid="5600830612147671529">"odesílaní zpráv SMS"</string>
    <string name="permdesc_sendSms" msgid="1946540351763502120">"Umožňuje aplikaci odesílat zprávy SMS. Škodlivé aplikace mohou bez vašeho potvrzení odesílat zpoplatněné zprávy."</string>
    <string name="permlab_readSms" msgid="4085333708122372256">"čtení zpráv SMS a MMS"</string>
    <string name="permdesc_readSms" msgid="3002170087197294591">"Umožňuje aplikaci číst zprávy SMS uložené ve vašem telefonu nebo na kartě SIM. Škodlivé aplikace mohou načíst vaše soukromé zprávy."</string>
    <string name="permlab_writeSms" msgid="6881122575154940744">"úprava zpráv SMS a MMS"</string>
    <string name="permdesc_writeSms" msgid="6299398896177548095">"Umožňuje aplikaci zapisovat do zpráv SMS uložených ve vašem telefonu nebo na kartě SIM. Škodlivé aplikace mohou smazat vaše zprávy."</string>
    <string name="permlab_receiveWapPush" msgid="8258226427716551388">"příjem WAP"</string>
    <string name="permdesc_receiveWapPush" msgid="5979623826128082171">"Umožňuje aplikaci přijímat a zpracovávat zprávy WAP. Škodlivé aplikace mohou sledovat vaše zprávy nebo je smazat, aniž by vám byly zobrazeny."</string>
    <string name="permlab_getTasks" msgid="5005277531132573353">"načtení spuštěných aplikací"</string>
    <string name="permdesc_getTasks" msgid="7048711358713443341">"Umožňuje aplikaci načíst informace o aktuálně a nedávno spuštěných úlohách. Toto nastavení může škodlivým aplikacím umožnit odhalení soukromých informací o jiných aplikacích."</string>
    <string name="permlab_reorderTasks" msgid="5669588525059921549">"změna uspořádání spuštěných aplikací"</string>
    <string name="permdesc_reorderTasks" msgid="126252774270522835">"Umožňuje aplikaci přesouvat úlohy do popředí či pozadí. Škodlivé aplikace mohou vynutit své přesunutí do popředí bez vašeho přičinění."</string>
    <string name="permlab_setDebugApp" msgid="4339730312925176742">"povolit ladění aplikací"</string>
    <string name="permdesc_setDebugApp" msgid="5584310661711990702">"Umožňuje aplikaci povolit ladění jiné aplikace. Škodlivé aplikace mohou pomocí tohoto nastavení ukončit jiné aplikace."</string>
    <string name="permlab_changeConfiguration" msgid="8214475779521218295">"změna vašeho nastavení uživatelského rozhraní"</string>
    <string name="permdesc_changeConfiguration" msgid="3465121501528064399">"Umožňuje aplikaci změnit aktuální konfiguraci, např. národní prostředí či obecnou velikost písma."</string>
    <string name="permlab_enableCarMode" msgid="5684504058192921098">"aktivovat režim V autě"</string>
    <string name="permdesc_enableCarMode" msgid="5673461159384850628">"Umožňuje aplikaci aktivovat režim V autě."</string>
    <string name="permlab_killBackgroundProcesses" msgid="8373714752793061963">"ukončit procesy na pozadí"</string>
    <string name="permdesc_killBackgroundProcesses" msgid="2908829602869383753">"Umožňuje aplikaci ukončit procesy jiných aplikací běžící na pozadí i v případě, kdy je dostatek paměti."</string>
    <string name="permlab_forceStopPackages" msgid="1447830113260156236">"vynutit zastavení jiných aplikací"</string>
    <string name="permdesc_forceStopPackages" msgid="7263036616161367402">"Umožňuje aplikaci vynutit zastavení jiných aplikací."</string>
    <string name="permlab_forceBack" msgid="1804196839880393631">"vynucení zavření aplikace"</string>
    <string name="permdesc_forceBack" msgid="6534109744159919013">"Umožňuje aplikaci vynutit zavření a přesunutí libovolné činnosti v popředí na pozadí. Běžné aplikace by toto nastavení neměly nikdy využívat."</string>
    <string name="permlab_dump" msgid="1681799862438954752">"načtení interního stavu systému"</string>
    <string name="permdesc_dump" msgid="2198776174276275220">"Umožňuje aplikaci načíst interní stav systému. Škodlivé aplikace mohou načíst řádu soukromých a zabezpečených informací, které by nikdy neměly potřebovat."</string>
    <string name="permlab_shutdown" msgid="7185747824038909016">"částečné vypnutí"</string>
    <string name="permdesc_shutdown" msgid="7046500838746291775">"Uvede správce činností do vypnutého stavu. Nedojde však k úplnému vypnutí."</string>
    <string name="permlab_stopAppSwitches" msgid="4138608610717425573">"zabránění přepínání aplikací"</string>
    <string name="permdesc_stopAppSwitches" msgid="3857886086919033794">"Zabrání uživateli přepnout na jinou aplikaci."</string>
    <string name="permlab_runSetActivityWatcher" msgid="7811586187574696296">"sledování a řízení spouštění všech aplikací"</string>
    <string name="permdesc_runSetActivityWatcher" msgid="3228701938345388092">"Umožňuje aplikaci sledovat a řídit spouštění činností systémem. Škodlivé aplikace mohou zcela ovládnout systém. Toto oprávnění je zapotřebí pouze pro účely vývoje, nikdy pro běžné použití telefonu."</string>
    <string name="permlab_broadcastPackageRemoved" msgid="2576333434893532475">"odeslání vysílání o odstranění balíčku"</string>
    <string name="permdesc_broadcastPackageRemoved" msgid="3453286591439891260">"Umožňuje aplikaci vysílat oznámení o odstranění balíčku aplikace. Škodlivé aplikace mohou pomocí tohoto nastavení ukončit libovolnou další spuštěnou aplikaci."</string>
    <string name="permlab_broadcastSmsReceived" msgid="5689095009030336593">"odeslání vysílání o přijaté zprávě SMS"</string>
    <string name="permdesc_broadcastSmsReceived" msgid="9122419277306740155">"Umožňuje aplikaci vysílat oznámení o přijetí zprávy SMS. Škodlivé aplikace mohou pomocí tohoto nastavení falšovat příchozí zprávy SMS."</string>
    <string name="permlab_broadcastWapPush" msgid="3145347413028582371">"odeslání vysílání typu WAP-PUSH-received"</string>
    <string name="permdesc_broadcastWapPush" msgid="3955303669461378091">"Umožňuje aplikaci vysílat oznámení o přijetí zprávy WAP PUSH. Škodlivé aplikace mohou pomocí tohoto nastavení zfalšovat výpis o doručení zprávy MMS nebo nepozorovaně nahradit obsah jakékoli webové stránky škodlivým obsahem."</string>
    <string name="permlab_setProcessLimit" msgid="2451873664363662666">"omezení počtu spuštěných procesů"</string>
    <string name="permdesc_setProcessLimit" msgid="7824786028557379539">"Umožňuje aplikaci řídit maximální počet spuštěných procesů. Běžné aplikace toto nastavení nikdy nevyužívají."</string>
    <string name="permlab_setAlwaysFinish" msgid="5342837862439543783">"zavření všech aplikací na pozadí"</string>
    <string name="permdesc_setAlwaysFinish" msgid="8773936403987091620">"Umožňuje aplikaci ovládat, zda jsou činnosti vždy dokončeny po přesunutí do pozadí. Běžné aplikace toto nastavení nikdy nevyužívají."</string>
    <string name="permlab_batteryStats" msgid="7863923071360031652">"změna statistických údajů o baterii"</string>
    <string name="permdesc_batteryStats" msgid="5847319823772230560">"Umožňuje změnu shromážděných statistických údajů o baterii. Není určeno pro běžné aplikace."</string>
    <string name="permlab_backup" msgid="470013022865453920">"ovládání zálohování a obnovy systému"</string>
    <string name="permdesc_backup" msgid="4837493065154256525">"Umožňuje aplikaci ovládat systémový mechanizmus pro zálohování a obnovu dat. Není určeno pro běžné aplikace."</string>
    <string name="permlab_internalSystemWindow" msgid="2148563628140193231">"zobrazení nepovolených oken"</string>
    <string name="permdesc_internalSystemWindow" msgid="5895082268284998469">"Umožňuje vytvoření oken, která mají být použita interním systémem uživatelského rozhraní. Běžné aplikace toto nastavení nepoužívají."</string>
    <string name="permlab_systemAlertWindow" msgid="3372321942941168324">"zobrazení upozornění systémové úrovně"</string>
    <string name="permdesc_systemAlertWindow" msgid="5109622689323490558">"Umožňuje aplikaci zobrazit okna s výstrahami systému. Škodlivé aplikace mohou převzít kontrolu nad celou obrazovkou telefonu."</string>
    <string name="permlab_setAnimationScale" msgid="2805103241153907174">"změna globální rychlosti animace"</string>
    <string name="permdesc_setAnimationScale" msgid="7181522138912391988">"Umožňuje aplikaci kdykoli globálně změnit rychlost animace (rychlejší či pomalejší animace)."</string>
    <string name="permlab_manageAppTokens" msgid="17124341698093865">"správa tokenů aplikací"</string>
    <string name="permdesc_manageAppTokens" msgid="977127907524195988">"Umožňuje aplikaci vytvořit a spravovat své vlastní tokeny a obejít jejich obvyklé řazení typu Z. Toto nastavení by nikdy nemělo být potřeba pro běžné aplikace."</string>
    <string name="permlab_injectEvents" msgid="1378746584023586600">"používání kláves a tlačítek"</string>
    <string name="permdesc_injectEvents" msgid="3946098050410874715">"Umožňuje aplikaci doručit své vlastní vstupní události (stisknutí tlačítek, apod.) dalším aplikacím. Škodlivé aplikace mohou pomocí tohoto nastavení převzít kontrolu nad telefonem."</string>
    <string name="permlab_readInputState" msgid="469428900041249234">"zaznamenání psaného textu a prováděných činností"</string>
    <string name="permdesc_readInputState" msgid="5132879321450325445">"Umožňuje aplikacím sledovat, které klávesy používáte, a to i při práci s jinými aplikacemi (například při zadávání hesla). Běžné aplikace by toto nastavení nikdy neměly vyžadovat."</string>
    <string name="permlab_bindInputMethod" msgid="3360064620230515776">"vazba k metodě zadávání dat"</string>
    <string name="permdesc_bindInputMethod" msgid="3734838321027317228">"Umožňuje držiteli vázat se na nejvyšší úroveň rozhraní pro zadávání dat. Běžné aplikace by toto nastavení nikdy neměly využívat."</string>
    <string name="permlab_bindWallpaper" msgid="8716400279937856462">"vazba na tapetu"</string>
    <string name="permdesc_bindWallpaper" msgid="5287754520361915347">"Umožňuje držiteli navázat se na nejvyšší úroveň rozhraní tapety. Běžné aplikace by toto oprávnění nikdy neměly potřebovat."</string>
    <string name="permlab_bindDeviceAdmin" msgid="8704986163711455010">"komunikovat se správcem zařízení"</string>
    <string name="permdesc_bindDeviceAdmin" msgid="8714424333082216979">"Umožňuje držiteli oprávnění odesílat informace správci zařízení. Běžné aplikace by toto oprávnění nikdy neměly požadovat."</string>
    <string name="permlab_setOrientation" msgid="3365947717163866844">"změna orientace obrazovky"</string>
    <string name="permdesc_setOrientation" msgid="6335814461615851863">"Umožňuje aplikaci kdykoli změnit orientaci obrazovky. Běžné aplikace by toto nastavení nikdy neměly využívat."</string>
    <string name="permlab_signalPersistentProcesses" msgid="4255467255488653854">"odeslání signálů Linux aplikacím"</string>
    <string name="permdesc_signalPersistentProcesses" msgid="3565530463215015289">"Umožňuje aplikaci vyžádat zaslání poskytnutého signálu všem trvalým procesům."</string>
    <string name="permlab_persistentActivity" msgid="8659652042401085862">"trvalé spuštění aplikace"</string>
    <string name="permdesc_persistentActivity" msgid="5037199778265006008">"Umožňuje aplikaci učinit své části trvalými, takže je systém nemůže použít pro jiné aplikace."</string>
    <string name="permlab_deletePackages" msgid="3343439331576348805">"smazání aplikací"</string>
    <string name="permdesc_deletePackages" msgid="3634943677518723314">"Umožňuje aplikaci smazat balíčky systému Android. Škodlivé aplikace mohou pomocí tohoto nastavení smazat důležité aplikace."</string>
    <string name="permlab_clearAppUserData" msgid="2192134353540277878">"smazání dat ostatních aplikací"</string>
    <string name="permdesc_clearAppUserData" msgid="7546345080434325456">"Umožňuje aplikaci smazat data uživatele."</string>
    <string name="permlab_deleteCacheFiles" msgid="1518556602634276725">"smazání mezipaměti ostatních aplikací"</string>
    <string name="permdesc_deleteCacheFiles" msgid="2283074077168165971">"Umožňuje aplikaci smazat soubory v mezipaměti."</string>
    <string name="permlab_getPackageSize" msgid="4799785352306641460">"výpočet místa pro ukládání aplikací"</string>
    <string name="permdesc_getPackageSize" msgid="5557253039670753437">"Umožňuje aplikaci načtení svého kódu, dat a velikostí mezipaměti"</string>
    <string name="permlab_installPackages" msgid="335800214119051089">"přímá instalace aplikací"</string>
    <string name="permdesc_installPackages" msgid="526669220850066132">"Umožňuje aplikaci nainstalovat nové či aktualizované balíčky systému Android. Škodlivé aplikace mohou pomocí tohoto nastavení přidat nové aplikace s libovolnými oprávněními."</string>
    <string name="permlab_clearAppCache" msgid="4747698311163766540">"smazání všech dat v mezipaměti aplikace"</string>
    <string name="permdesc_clearAppCache" msgid="7740465694193671402">"Umožňuje aplikaci uvolnit paměť telefonu smazáním souborů v adresáři mezipaměti aplikace. Přístup je velmi omezený, většinou pouze pro systémové procesy."</string>
    <string name="permlab_movePackage" msgid="728454979946503926">"Přesun zdrojů aplikace"</string>
    <string name="permdesc_movePackage" msgid="6323049291923925277">"Umožňuje aplikaci přesunout své zdroje z interní paměti na externí médium a opačně."</string>
    <string name="permlab_readLogs" msgid="4811921703882532070">"čtení systémových souborů protokolu"</string>
    <string name="permdesc_readLogs" msgid="2257937955580475902">"Umožňuje aplikaci číst různé systémové soubory protokolů. Toto nastavení aplikaci umožní získat obecné informace o činnostech s telefonem, ale neměly by obsahovat žádné osobní či soukromé informace."</string>
    <string name="permlab_diagnostic" msgid="8076743953908000342">"čtení nebo zápis do prostředků funkce diag"</string>
    <string name="permdesc_diagnostic" msgid="3121238373951637049">"Umožňuje aplikaci číst libovolné prostředky ve skupině diag, např. soubory ve složce /dev, a zapisovat do nich. Může dojít k ovlivnění stability a bezpečnosti systému. Toto nastavení by měl používat pouze výrobce či operátor pro diagnostiku hardwaru."</string>
    <string name="permlab_changeComponentState" msgid="79425198834329406">"povolení či zakázání komponent aplikací"</string>
    <string name="permdesc_changeComponentState" msgid="4569107043246700630">"Umožňuje aplikaci změnit, zda je komponenta jiné aplikace povolena nebo ne. Škodlivé aplikace mohou pomocí tohoto nastavení vypnout důležité funkce telefonu. Je třeba postupovat opatrně, protože je možné způsobit nepoužitelnost, nekonzistenci či nestabilitu komponent aplikací."</string>
    <string name="permlab_setPreferredApplications" msgid="3393305202145172005">"nastavení upřednostňovaných aplikací"</string>
    <string name="permdesc_setPreferredApplications" msgid="760008293501937546">"Umožňuje aplikaci změnit vaše upřednostňované aplikace. Toto nastavení může škodlivým aplikacím umožnit nepozorovaně změnit spouštěné aplikace a oklamat vaše existující aplikace tak, aby shromažďovaly vaše soukromá data."</string>
    <string name="permlab_writeSettings" msgid="1365523497395143704">"změna globálních nastavení systému"</string>
    <string name="permdesc_writeSettings" msgid="838789419871034696">"Umožňuje aplikaci upravit data nastavení systému. Škodlivé aplikace mohou poškodit konfiguraci vašeho systému."</string>
    <string name="permlab_writeSecureSettings" msgid="204676251876718288">"změny zabezpečených nastavení systému"</string>
    <string name="permdesc_writeSecureSettings" msgid="5497873143539034724">"Umožňuje aplikaci změnit data zabezpečených nastavení systému. Běžné aplikace toto nastavení nevyužívají."</string>
    <string name="permlab_writeGservices" msgid="2149426664226152185">"změna mapy služeb Google"</string>
    <string name="permdesc_writeGservices" msgid="6602362746516676175">"Umožňuje aplikaci změnit mapu služeb Google. Běžné aplikace toto nastavení nevyužívají."</string>
    <string name="permlab_receiveBootCompleted" msgid="7776779842866993377">"automatické spuštění při startu"</string>
    <string name="permdesc_receiveBootCompleted" msgid="698336728415008796">"Umožňuje aplikaci spuštění ihned po spuštění systému. Toto nastavení může zpomalit spuštění telefonu a umožnit aplikaci celkově zpomalit telefon, protože bude neustále spuštěna."</string>
    <string name="permlab_broadcastSticky" msgid="7919126372606881614">"odeslání trvalého vysílání"</string>
    <string name="permdesc_broadcastSticky" msgid="1920045289234052219">"Umožňuje aplikaci odeslat trvalá vysílání, která přetrvávají i po skončení vysílání. Škodlivé aplikace mohou telefon zpomalit či způsobit jeho nestabilitu, protože bude používat příliš mnoho paměti."</string>
    <string name="permlab_readContacts" msgid="6219652189510218240">"čtení dat kontaktů"</string>
    <string name="permdesc_readContacts" msgid="3371591512896545975">"Umožňuje aplikaci načíst všechna data kontaktů (adresy) uložená ve vašem telefonu. Škodlivé aplikace poté mohou dalším lidem odeslat vaše data."</string>
    <string name="permlab_writeContacts" msgid="644616215860933284">"zápis dat kontaktů"</string>
    <string name="permdesc_writeContacts" msgid="3924383579108183601">"Umožňuje aplikaci změnit kontaktní údaje (adresu) uložené v telefonu. Škodlivé aplikace mohou pomocí tohoto nastavení vymazat či pozměnit kontaktní údaje."</string>
    <string name="permlab_writeOwnerData" msgid="4892555913849295393">"zápis informací o vlastníkovi"</string>
    <string name="permdesc_writeOwnerData" msgid="2344055317969787124">"Umožňuje aplikaci změnit informace o vlastníkovi telefonu uložené v telefonu. Škodlivé aplikace mohou pomocí tohoto nastavení vymazat či pozměnit informace o vlastníkovi."</string>
    <string name="permlab_readOwnerData" msgid="6668525984731523563">"čtení informací o vlastníkovi"</string>
    <string name="permdesc_readOwnerData" msgid="3088486383128434507">"Umožňuje aplikaci číst informace o vlastníkovi telefonu uložená v telefonu. Škodlivé aplikace mohou pomocí tohoto nastavení načíst informace o vlastníkovi."</string>
    <string name="permlab_readCalendar" msgid="6898987798303840534">"Čtení událostí v kalendáři"</string>
    <string name="permdesc_readCalendar" msgid="5533029139652095734">"Umožňuje aplikaci načíst všechny události kalendáře uložené ve vašem telefonu. Škodlivé aplikace poté mohou dalším lidem odeslat události z vašeho kalendáře."</string>
    <string name="permlab_writeCalendar" msgid="3894879352594904361">"Přidávání nebo úprava událostí v kalendáři a odesílání e-mailů hostům"</string>
    <string name="permdesc_writeCalendar" msgid="2988871373544154221">"Umožňuje aplikaci přidávat nebo měnit události v kalendáři, které budou odesílat e-maily hostům. Škodlivé aplikace mohou pomocí tohoto oprávnění mazat nebo upravovat události v kalendáři a odesílat e-maily hostům."</string>
    <string name="permlab_accessMockLocation" msgid="8688334974036823330">"simulace zdrojů polohy pro účely testování"</string>
    <string name="permdesc_accessMockLocation" msgid="7648286063459727252">"Vytváří simulované zdroje polohy pro účely testování. Škodlivé aplikace mohou pomocí tohoto nastavení změnit polohu či stav vrácený zdroji skutečné polohy, jako je např. jednotka GPS či poskytovatelé sítě."</string>
    <string name="permlab_accessLocationExtraCommands" msgid="2836308076720553837">"přístup k dalším příkazům poskytovatele polohy"</string>
    <string name="permdesc_accessLocationExtraCommands" msgid="1948144701382451721">"Umožňuje získat přístup k dalším příkazům poskytovatele polohy. Škodlivé aplikace mohou pomocí tohoto nastavení narušit funkci GPS či jiných zdrojů polohy."</string>
    <string name="permlab_installLocationProvider" msgid="6578101199825193873">"oprávnění k instalaci poskytovatele polohy"</string>
    <string name="permdesc_installLocationProvider" msgid="5449175116732002106">"Vytvořit simulace zdrojů polohy pro účely testování. Škodlivé aplikace mohou toto nastavení využít k přepsání polohy nebo stavu vráceného zdroji skutečné polohy, například systémem GPS nebo poskytovateli sítí. Mohou také monitorovat polohu a ohlásit ji externímu zdroji."</string>
    <string name="permlab_accessFineLocation" msgid="8116127007541369477">"upřesnění polohy (GPS)"</string>
    <string name="permdesc_accessFineLocation" msgid="7411213317434337331">"Umožňuje aplikaci přístup ke zdrojům přesné polohy v telefonu, jako je například systém GPS, je-li k dispozici. Škodlivé aplikace mohou pomocí tohoto nastavení zjistit vaši polohu a mohou zvýšit spotřebu baterie."</string>
    <string name="permlab_accessCoarseLocation" msgid="4642255009181975828">"přibližná poloha (pomocí sítě)"</string>
    <string name="permdesc_accessCoarseLocation" msgid="8235655958070862293">"Umožňuje získat přístup ke zdrojům přibližné polohy, jako je například databáze mobilní sítě, je-li k dispozici, a určit přibližnou pozici telefonu. Škodlivé aplikace takto mohou zjistit, kde se přibližně nacházíte."</string>
    <string name="permlab_accessSurfaceFlinger" msgid="2363969641792388947">"přístup ke službě SurfaceFlinger"</string>
    <string name="permdesc_accessSurfaceFlinger" msgid="6805241830020733025">"Umožňuje aplikaci používat nízkoúrovňové funkce SurfaceFlinger."</string>
    <string name="permlab_readFrameBuffer" msgid="6690504248178498136">"čtení vyrovnávací paměti snímků"</string>
    <string name="permdesc_readFrameBuffer" msgid="7530020370469942528">"Umožňuje aplikaci číst obsah vyrovnávací paměti snímků."</string>
    <string name="permlab_modifyAudioSettings" msgid="6095859937069146086">"změna vašeho nastavení zvuku"</string>
    <string name="permdesc_modifyAudioSettings" msgid="5793461287365991922">"Umožňuje aplikaci změnit globální nastavení zvuku, například hlasitost či směrování."</string>
    <string name="permlab_recordAudio" msgid="3876049771427466323">"nahrání zvuku"</string>
    <string name="permdesc_recordAudio" msgid="6493228261176552356">"Umožňuje aplikaci získat přístup k nahrávání zvuku."</string>
    <string name="permlab_camera" msgid="8059288807274039014">"pořizování fotografií"</string>
    <string name="permdesc_camera" msgid="9013476258810982546">"Umožňuje aplikaci pořizovat fotografie pomocí fotoaparátu. Toto nastavení aplikaci umožní shromažďovat fotografie toho, na co je zrovna fotoaparát namířen."</string>
    <string name="permlab_brick" msgid="8337817093326370537">"trvalé vypnutí telefonu"</string>
    <string name="permdesc_brick" msgid="5569526552607599221">"Umožňuje aplikaci trvale vypnout celý telefon. Toto je velmi nebezpečné nastavení."</string>
    <string name="permlab_reboot" msgid="2898560872462638242">"vynucení restartování telefonu"</string>
    <string name="permdesc_reboot" msgid="7914933292815491782">"Umožňuje aplikaci vynutit restartování telefonu."</string>
    <string name="permlab_mount_unmount_filesystems" msgid="1761023272170956541">"připojení a odpojení souborových systémů"</string>
    <string name="permdesc_mount_unmount_filesystems" msgid="6253263792535859767">"Umožňuje aplikaci připojit či odpojit souborové systémy ve vyměnitelných úložištích."</string>
    <string name="permlab_mount_format_filesystems" msgid="5523285143576718981">"formátovat externí úložiště"</string>
    <string name="permdesc_mount_format_filesystems" msgid="574060044906047386">"Umožňuje aplikaci formátovat vyměnitelná úložiště."</string>
    <string name="permlab_asec_access" msgid="1070364079249834666">"získat informace o zabezpečeném úložišti"</string>
    <string name="permdesc_asec_access" msgid="7691616292170590244">"Umožňuje aplikaci získat informace o zabezpečeném úložišti."</string>
    <string name="permlab_asec_create" msgid="7312078032326928899">"vytvořit zabezpečené úložiště"</string>
    <string name="permdesc_asec_create" msgid="7041802322759014035">"Umožňuje aplikaci vytvořit zabezpečené úložiště."</string>
    <string name="permlab_asec_destroy" msgid="7787322878955261006">"zničit zabezpečené úložiště"</string>
    <string name="permdesc_asec_destroy" msgid="5740754114967893169">"Umožňuje aplikaci zničit zabezpečené úložiště."</string>
    <string name="permlab_asec_mount_unmount" msgid="7517449694667828592">"připojit nebo odpojit zabezpečené úložiště"</string>
    <string name="permdesc_asec_mount_unmount" msgid="5438078121718738625">"Umožňuje aplikaci připojit nebo odpojit zabezpečené úložiště."</string>
    <string name="permlab_asec_rename" msgid="5685344390439934495">"přejmenovat zabezpečené úložiště"</string>
    <string name="permdesc_asec_rename" msgid="1387881770708872470">"Umožňuje aplikaci přejmenovat zabezpečeného úložiště."</string>
    <string name="permlab_vibrate" msgid="7768356019980849603">"ovládání vibrací"</string>
    <string name="permdesc_vibrate" msgid="2886677177257789187">"Umožňuje aplikaci ovládat vibrace."</string>
    <string name="permlab_flashlight" msgid="2155920810121984215">"ovládání kontrolky"</string>
    <string name="permdesc_flashlight" msgid="6433045942283802309">"Umožňuje aplikaci ovládat kontrolku."</string>
    <string name="permlab_hardware_test" msgid="4148290860400659146">"testování hardwaru"</string>
    <string name="permdesc_hardware_test" msgid="3668894686500081699">"Umožňuje aplikaci ovládat různé periferie pro účely testování hardwaru."</string>
    <string name="permlab_callPhone" msgid="3925836347681847954">"přímé volání na telefonní čísla"</string>
    <string name="permdesc_callPhone" msgid="3369867353692722456">"Umožňuje aplikaci bez vašeho zásahu volat na telefonní čísla. Škodlivé aplikace mohou na váš telefonní účet připsat neočekávané hovory. Toto nastavení aplikaci neumožňuje volat na tísňové linky."</string>
    <string name="permlab_callPrivileged" msgid="4198349211108497879">"přímé volání na libovolná telefonní čísla"</string>
    <string name="permdesc_callPrivileged" msgid="244405067160028452">"Umožňuje aplikaci bez vašeho zásahu vytočit jakékoli telefonní číslo, včetně čísel tísňového volání. Škodlivé aplikace mohou provádět zbytečná a nezákonná volání na tísňové linky."</string>
    <string name="permlab_performCdmaProvisioning" msgid="5604848095315421425">"přímo spustit nastavení telefonu CDMA"</string>
    <string name="permdesc_performCdmaProvisioning" msgid="6457447676108355905">"Umožňuje aplikaci zahájit poskytování CDMA. Škodlivé aplikace mohou poskytování CDMA zahájit samovolně."</string>
    <string name="permlab_locationUpdates" msgid="7785408253364335740">"ovládání oznámení o aktualizaci polohy"</string>
    <string name="permdesc_locationUpdates" msgid="2300018303720930256">"Umožňuje povolit či zakázat aktualizace polohy prostřednictvím bezdrátového připojení. Aplikace toto nastavení obvykle nepoužívají."</string>
    <string name="permlab_checkinProperties" msgid="7855259461268734914">"přístup k vlastnostem Checkin"</string>
    <string name="permdesc_checkinProperties" msgid="7150307006141883832">"Umožňuje čtení i zápis vlastností nahraných službou Checkin. Běžné aplikace toto nastavení obvykle nevyužívají."</string>
    <string name="permlab_bindGadget" msgid="776905339015863471">"zvolit widgety"</string>
    <string name="permdesc_bindGadget" msgid="2098697834497452046">"Umožňuje aplikaci sdělit systému, které aplikace mohou používat které widgety. Aplikace s tímto oprávněním mohou zpřístupnit osobní údaje jiným aplikacím. Není určeno pro běžné aplikace."</string>
    <string name="permlab_modifyPhoneState" msgid="8423923777659292228">"změna stavu telefonu"</string>
    <string name="permdesc_modifyPhoneState" msgid="3302284561346956587">"Umožňuje aplikaci ovládat telefonní funkce zařízení. Aplikace s tímto oprávněním může přepínat sítě nebo zapnout či vypnout bezdrátové připojení telefonu bez vašeho svolení."</string>
    <string name="permlab_readPhoneState" msgid="2326172951448691631">"čtení stavu a identity telefonu"</string>
    <string name="permdesc_readPhoneState" msgid="188877305147626781">"Umožňuje aplikaci získat přístup k telefonním funkcím zařízení. Aplikace s tímto oprávněním mohou určit telefonní a sériové číslo tohoto telefonu, zda zrovna probíhá hovor, volané telefonní číslo a podobně."</string>
    <string name="permlab_wakeLock" msgid="573480187941496130">"zabránění přechodu telefonu do režimu spánku"</string>
    <string name="permdesc_wakeLock" msgid="7584036471227467099">"Umožňuje aplikaci zabránit přechodu telefonu do režimu spánku."</string>
    <string name="permlab_devicePower" msgid="4928622470980943206">"zapnutí či vypnutí telefonu"</string>
    <string name="permdesc_devicePower" msgid="4577331933252444818">"Umožňuje aplikaci zapnout či vypnout telefon."</string>
    <string name="permlab_factoryTest" msgid="3715225492696416187">"spuštění v režimu továrního testu"</string>
    <string name="permdesc_factoryTest" msgid="8136644990319244802">"Umožňuje aplikaci spuštění v režimu nízkoúrovňového testu výrobce a povolí přístup k hardwaru telefonu. K dispozici pouze, je-li telefon spuštěn v režimu testování výrobce."</string>
    <string name="permlab_setWallpaper" msgid="6627192333373465143">"nastavení tapety"</string>
    <string name="permdesc_setWallpaper" msgid="6417041752170585837">"Umožňuje aplikaci nastavit tapetu systému."</string>
    <string name="permlab_setWallpaperHints" msgid="3600721069353106851">"nastavení nápovědy pro velikost tapety"</string>
    <string name="permdesc_setWallpaperHints" msgid="6019479164008079626">"Umožňuje aplikaci nastavit nápovědu pro velikost tapety systému."</string>
    <string name="permlab_masterClear" msgid="2315750423139697397">"obnovení továrního nastavení systému"</string>
    <string name="permdesc_masterClear" msgid="5033465107545174514">"Umožňuje aplikaci kompletně obnovit systém do továrního nastavení a vymazat všechna data, konfiguraci a nainstalované aplikace."</string>
    <string name="permlab_setTime" msgid="2021614829591775646">"nastavit čas"</string>
    <string name="permdesc_setTime" msgid="667294309287080045">"Umožňuje aplikaci změnit čas hodin v telefonu."</string>
    <string name="permlab_setTimeZone" msgid="2945079801013077340">"nastavení časového pásma"</string>
    <string name="permdesc_setTimeZone" msgid="1902540227418179364">"Umožňuje aplikaci změnit časové pásmo telefonu."</string>
    <string name="permlab_accountManagerService" msgid="4829262349691386986">"role služby AccountManagerService"</string>
    <string name="permdesc_accountManagerService" msgid="6056903274106394752">"Umožňuje aplikaci volat funkce AccountAuthenticator"</string>
    <string name="permlab_getAccounts" msgid="4549918644233460103">"odhalení známých účtů"</string>
    <string name="permdesc_getAccounts" msgid="6839262446413155394">"Umožňuje aplikaci získat seznam účtů v telefonu."</string>
    <string name="permlab_authenticateAccounts" msgid="3940505577982882450">"role ověřovatele účtu"</string>
    <string name="permdesc_authenticateAccounts" msgid="4006839406474208874">"Umožňuje aplikaci používat funkce aplikace AccountManager související s ověřováním účtů – včetně vytváření účtů a získávání a nastavování hesel."</string>
    <string name="permlab_manageAccounts" msgid="4440380488312204365">"správa seznamu účtů"</string>
    <string name="permdesc_manageAccounts" msgid="8804114016661104517">"Umožňuje aplikaci provádět operace, jako je přidávání nebo odebírání účtů nebo mazání jejich hesel."</string>
    <string name="permlab_useCredentials" msgid="6401886092818819856">"používání ověřovacích pověření účtu"</string>
    <string name="permdesc_useCredentials" msgid="7416570544619546974">"Umožňuje aplikaci požadovat ověřovací tokeny."</string>
    <string name="permlab_accessNetworkState" msgid="6865575199464405769">"zobrazení stavu sítě"</string>
    <string name="permdesc_accessNetworkState" msgid="558721128707712766">"Umožňuje aplikaci zobrazit stav všech sítí."</string>
    <string name="permlab_createNetworkSockets" msgid="9121633680349549585">"plný přístup k internetu"</string>
    <string name="permdesc_createNetworkSockets" msgid="4593339106921772192">"Umožňuje aplikaci vytvořit síťové sokety."</string>
    <string name="permlab_writeApnSettings" msgid="7823599210086622545">"zápis nastavení názvu přístupového bodu (APN)"</string>
    <string name="permdesc_writeApnSettings" msgid="7443433457842966680">"Umožňuje aplikaci změnit nastavení APN, jako je například proxy či port APN."</string>
    <string name="permlab_changeNetworkState" msgid="958884291454327309">"změna připojení k síti"</string>
    <string name="permdesc_changeNetworkState" msgid="4199958910396387075">"Umožňuje aplikaci změnit stav připojení k síti."</string>
    <string name="permlab_changeTetherState" msgid="2702121155761140799">"Změna sdíleného datového připojení"</string>
    <string name="permdesc_changeTetherState" msgid="8905815579146349568">"Umožňuje aplikaci změnit stav sdíleného datového připojení k síti."</string>
    <string name="permlab_changeBackgroundDataSetting" msgid="1400666012671648741">"změnit nastavení použití dat na pozadí"</string>
    <string name="permdesc_changeBackgroundDataSetting" msgid="1001482853266638864">"Umožňuje aplikaci změnit nastavení použití dat na pozadí."</string>
    <string name="permlab_accessWifiState" msgid="8100926650211034400">"zobrazení stavu WiFi"</string>
    <string name="permdesc_accessWifiState" msgid="485796529139236346">"Umožňuje aplikaci zobrazit informace o stavu připojení WiFi."</string>
    <string name="permlab_changeWifiState" msgid="7280632711057112137">"změna stavu WiFi"</string>
    <string name="permdesc_changeWifiState" msgid="2950383153656873267">"Umožňuje aplikaci připojit se k přístupovým bodům WiFi či se od nich odpojit a provádět změny nakonfigurovaných sítí WiFi."</string>
    <string name="permlab_changeWifiMulticastState" msgid="1368253871483254784">"povolení příjmu Wi-Fi Multicast"</string>
    <string name="permdesc_changeWifiMulticastState" msgid="8199464507656067553">"Povoluje aplikaci přijímat pakety, které nebyly adresovány přímo vašemu zařízení. Pomocí této možnosti můžete objevit služby nabízené ve vaší blízkosti. Spotřeba energie je vyšší než u režimu bez vícesměrového vysílání (multicast)."</string>
    <string name="permlab_bluetoothAdmin" msgid="1092209628459341292">"správa rozhraní Bluetooth"</string>
    <string name="permdesc_bluetoothAdmin" msgid="7256289774667054555">"Umožňuje aplikaci konfigurovat místní telefon s rozhraním Bluetooth a vyhledávat a párovat vzdálená zařízení."</string>
    <string name="permlab_bluetooth" msgid="8361038707857018732">"vytvoření připojení Bluetooth"</string>
    <string name="permdesc_bluetooth" msgid="762515380679392945">"Umožňuje aplikaci zobrazit konfiguraci místního telefonu s rozhraním Bluetooth, vytvářet připojení ke spárovaným zařízením a přijímat tato připojení."</string>
    <string name="permlab_disableKeyguard" msgid="4977406164311535092">"vypnutí zámku kláves"</string>
    <string name="permdesc_disableKeyguard" msgid="3189763479326302017">"Umožňuje aplikaci vypnout zámek kláves a související zabezpečení heslem. Příkladem oprávněného použití této funkce je vypnutí zámku klávesnice při příchozím hovoru a jeho opětovné zapnutí po skončení hovoru."</string>
    <string name="permlab_readSyncSettings" msgid="6201810008230503052">"čtení nastavení synchronizace"</string>
    <string name="permdesc_readSyncSettings" msgid="5315925706353341823">"Umožňuje aplikaci načíst nastavení synchronizace, např. zda má být povolena synchronizace kontaktů."</string>
    <string name="permlab_writeSyncSettings" msgid="6297138566442486462">"zápis nastavení synchronizace"</string>
    <string name="permdesc_writeSyncSettings" msgid="2498201614431360044">"Umožňuje aplikaci změnit nastavení synchronizace, např. zda má být povolena synchronizace kontaktů."</string>
    <string name="permlab_readSyncStats" msgid="7396577451360202448">"čtení statistických údajů o synchronizaci"</string>
    <string name="permdesc_readSyncStats" msgid="7511448343374465000">"Umožňuje aplikaci číst statistické informace o synchronizaci, např. historii proběhlých synchronizací."</string>
    <string name="permlab_subscribedFeedsRead" msgid="4756609637053353318">"čtení zdrojů přihlášených k odběru"</string>
    <string name="permdesc_subscribedFeedsRead" msgid="3622200625634207660">"Umožňuje aplikaci získat podrobnosti o aktuálně synchronizovaných zdrojích."</string>
    <string name="permlab_subscribedFeedsWrite" msgid="9015246325408209296">"zápis odebíraných zdrojů"</string>
    <string name="permdesc_subscribedFeedsWrite" msgid="8121607099326533878">"Umožňuje aplikaci upravit vaše aktuálně synchronizované zdroje. To může škodlivým aplikacím umožnit změnu vašich synchronizovaných zdrojů."</string>
    <string name="permlab_readDictionary" msgid="432535716804748781">"člení slovníku definovaného uživatelem"</string>
    <string name="permdesc_readDictionary" msgid="1082972603576360690">"Umožní aplikaci číst soukromá slova, jména a fráze, která uživatel mohl uložit do svého slovníku."</string>
    <string name="permlab_writeDictionary" msgid="6703109511836343341">"zápis do slovníku definovaného uživatelem"</string>
    <string name="permdesc_writeDictionary" msgid="2241256206524082880">"Umožní aplikaci zapisovat nová slova do uživatelského slovníku."</string>
    <string name="permlab_sdcardWrite" msgid="8079403759001777291">"změna/smazání obsahu karty SD"</string>
    <string name="permdesc_sdcardWrite" msgid="6643963204976471878">"Umožní aplikaci zápis na kartu SD."</string>
    <string name="permlab_cache_filesystem" msgid="5656487264819669824">"přistupovat do souborového systému mezipaměti"</string>
    <string name="permdesc_cache_filesystem" msgid="1624734528435659906">"Umožňuje aplikaci číst a zapisovat do souborového systému mezipaměti."</string>
    <string name="policylab_limitPassword" msgid="4307861496302850201">"Omezení hesla"</string>
    <string name="policydesc_limitPassword" msgid="1719877245692318299">"Omezuje typ hesel, která lze použít."</string>
    <string name="policylab_watchLogin" msgid="7374780712664285321">"Sledování pokusů o přihlášení"</string>
    <string name="policydesc_watchLogin" msgid="1961251179624843483">"Sleduje nezdařené pokusy o přihlášení do zařízení a umožňuje provedení určité akce."</string>
    <string name="policylab_resetPassword" msgid="9084772090797485420">"Obnovení hesla"</string>
    <string name="policydesc_resetPassword" msgid="3332167600331799991">"Vynutí nastavení hesla na novou hodnotu, kterou vám před přihlášením musí sdělit správce."</string>
    <string name="policylab_forceLock" msgid="5760466025247634488">"Vynucení uzamčení"</string>
    <string name="policydesc_forceLock" msgid="2819868664946089740">"Určuje, kdy dojde k uzamčení zařízení a bude požadováno opětovné zadání hesla."</string>
    <string name="policylab_wipeData" msgid="3910545446758639713">"Vymazání všech dat"</string>
    <string name="policydesc_wipeData" msgid="2314060933796396205">"Bez dalšího potvrzení obnoví výchozí nastavení z výroby a smaže všechna data."</string>
  <string-array name="phoneTypes">
    <item msgid="8901098336658710359">"Domů"</item>
    <item msgid="869923650527136615">"Mobil"</item>
    <item msgid="7897544654242874543">"Práce"</item>
    <item msgid="1103601433382158155">"Pracovní fax"</item>
    <item msgid="1735177144948329370">"Fax domů"</item>
    <item msgid="603878674477207394">"Pager"</item>
    <item msgid="1650824275177931637">"Ostatní"</item>
    <item msgid="9192514806975898961">"Vlastní"</item>
  </string-array>
  <string-array name="emailAddressTypes">
    <item msgid="8073994352956129127">"Domů"</item>
    <item msgid="7084237356602625604">"Práce"</item>
    <item msgid="1112044410659011023">"(další)"</item>
    <item msgid="2374913952870110618">"Vlastní"</item>
  </string-array>
  <string-array name="postalAddressTypes">
    <item msgid="6880257626740047286">"Domů"</item>
    <item msgid="5629153956045109251">"Práce"</item>
    <item msgid="4966604264500343469">"Ostatní"</item>
    <item msgid="4932682847595299369">"Vlastní"</item>
  </string-array>
  <string-array name="imAddressTypes">
    <item msgid="1738585194601476694">"Domů"</item>
    <item msgid="1359644565647383708">"Práce"</item>
    <item msgid="7868549401053615677">"Ostatní"</item>
    <item msgid="3145118944639869809">"Vlastní"</item>
  </string-array>
  <string-array name="organizationTypes">
    <item msgid="7546335612189115615">"Práce"</item>
    <item msgid="4378074129049520373">"Ostatní"</item>
    <item msgid="3455047468583965104">"Vlastní"</item>
  </string-array>
  <string-array name="imProtocols">
    <item msgid="8595261363518459565">"AIM"</item>
    <item msgid="7390473628275490700">"Windows Live"</item>
    <item msgid="7882877134931458217">"Yahoo!"</item>
    <item msgid="5035376313200585242">"Skype"</item>
    <item msgid="7532363178459444943">"QQ"</item>
    <item msgid="3713441034299660749">"Google Talk"</item>
    <item msgid="2506857312718630823">"ICQ"</item>
    <item msgid="1648797903785279353">"Jabber"</item>
  </string-array>
    <string name="phoneTypeCustom" msgid="1644738059053355820">"Vlastní"</string>
    <string name="phoneTypeHome" msgid="2570923463033985887">"Domů"</string>
    <string name="phoneTypeMobile" msgid="6501463557754751037">"Mobil"</string>
    <string name="phoneTypeWork" msgid="8863939667059911633">"Práce"</string>
    <string name="phoneTypeFaxWork" msgid="3517792160008890912">"Pracovní fax"</string>
    <string name="phoneTypeFaxHome" msgid="2067265972322971467">"Domácí fax"</string>
    <string name="phoneTypePager" msgid="7582359955394921732">"Pager"</string>
    <string name="phoneTypeOther" msgid="1544425847868765990">"Jiné"</string>
    <string name="phoneTypeCallback" msgid="2712175203065678206">"Zpětné volání"</string>
    <string name="phoneTypeCar" msgid="8738360689616716982">"Auto"</string>
    <string name="phoneTypeCompanyMain" msgid="540434356461478916">"Firma (hlavní)"</string>
    <string name="phoneTypeIsdn" msgid="8022453193171370337">"ISDN"</string>
    <string name="phoneTypeMain" msgid="6766137010628326916">"Hlavní"</string>
    <string name="phoneTypeOtherFax" msgid="8587657145072446565">"Jiný fax"</string>
    <string name="phoneTypeRadio" msgid="4093738079908667513">"Radiotelefon"</string>
    <string name="phoneTypeTelex" msgid="3367879952476250512">"Telex"</string>
    <string name="phoneTypeTtyTdd" msgid="8606514378585000044">"Telefon pro sluchově postižené (TTY/TDD)"</string>
    <string name="phoneTypeWorkMobile" msgid="1311426989184065709">"Pracovní mobil"</string>
    <string name="phoneTypeWorkPager" msgid="649938731231157056">"Pracovní pager"</string>
    <string name="phoneTypeAssistant" msgid="5596772636128562884">"Asistent"</string>
    <string name="phoneTypeMms" msgid="7254492275502768992">"MMS"</string>
    <string name="eventTypeBirthday" msgid="2813379844211390740">"Narozeniny"</string>
    <string name="eventTypeAnniversary" msgid="3876779744518284000">"Výročí"</string>
    <string name="eventTypeOther" msgid="5834288791948564594">"Událost"</string>
    <string name="emailTypeCustom" msgid="8525960257804213846">"Vlastní"</string>
    <string name="emailTypeHome" msgid="449227236140433919">"Domů"</string>
    <string name="emailTypeWork" msgid="3548058059601149973">"Práce"</string>
    <string name="emailTypeOther" msgid="2923008695272639549">"Jiné"</string>
    <string name="emailTypeMobile" msgid="119919005321166205">"Mobil"</string>
    <string name="postalTypeCustom" msgid="8903206903060479902">"Vlastní"</string>
    <string name="postalTypeHome" msgid="8165756977184483097">"Domů"</string>
    <string name="postalTypeWork" msgid="5268172772387694495">"Práce"</string>
    <string name="postalTypeOther" msgid="2726111966623584341">"Jiné"</string>
    <string name="imTypeCustom" msgid="2074028755527826046">"Vlastní"</string>
    <string name="imTypeHome" msgid="6241181032954263892">"Domů"</string>
    <string name="imTypeWork" msgid="1371489290242433090">"Práce"</string>
    <string name="imTypeOther" msgid="5377007495735915478">"Jiné"</string>
    <string name="imProtocolCustom" msgid="6919453836618749992">"Vlastní"</string>
    <string name="imProtocolAim" msgid="7050360612368383417">"AIM"</string>
    <string name="imProtocolMsn" msgid="144556545420769442">"Windows Live"</string>
    <string name="imProtocolYahoo" msgid="8271439408469021273">"Yahoo"</string>
    <string name="imProtocolSkype" msgid="9019296744622832951">"Skype"</string>
    <string name="imProtocolQq" msgid="8887484379494111884">"QQ"</string>
    <string name="imProtocolGoogleTalk" msgid="3808393979157698766">"Google Talk"</string>
    <string name="imProtocolIcq" msgid="1574870433606517315">"ICQ"</string>
    <string name="imProtocolJabber" msgid="2279917630875771722">"Jabber"</string>
    <string name="imProtocolNetMeeting" msgid="8287625655986827971">"NetMeeting"</string>
    <string name="orgTypeWork" msgid="29268870505363872">"Práce"</string>
    <string name="orgTypeOther" msgid="3951781131570124082">"Jiné"</string>
    <string name="orgTypeCustom" msgid="225523415372088322">"Vlastní"</string>
    <string name="contact_status_update_attribution" msgid="5112589886094402795">"pomocí <xliff:g id="SOURCE">%1$s</xliff:g>"</string>
    <string name="contact_status_update_attribution_with_date" msgid="5945386376369979909">"<xliff:g id="DATE">%1$s</xliff:g> pomocí <xliff:g id="SOURCE">%2$s</xliff:g>"</string>
    <string name="keyguard_password_enter_pin_code" msgid="3731488827218876115">"Zadejte kód PIN"</string>
    <string name="keyguard_password_enter_password_code" msgid="9138158344813213754">"Zadejte heslo pro odblokování"</string>
    <string name="keyguard_password_wrong_pin_code" msgid="1295984114338107718">"Nesprávný kód PIN"</string>
    <string name="keyguard_label_text" msgid="861796461028298424">"Chcete-li telefon odemknout, stiskněte Menu a poté 0."</string>
    <string name="emergency_call_dialog_number_for_display" msgid="696192103195090970">"Číslo tísňové linky"</string>
    <string name="lockscreen_carrier_default" msgid="8812714795156374435">"(Není signál)"</string>
    <string name="lockscreen_screen_locked" msgid="7288443074806832904">"Obrazovka uzamčena."</string>
    <string name="lockscreen_instructions_when_pattern_enabled" msgid="46154051614126049">"Chcete-li odemknout telefon nebo provést tísňové volání, stiskněte Menu."</string>
    <string name="lockscreen_instructions_when_pattern_disabled" msgid="686260028797158364">"Telefon odemknete stisknutím tlačítka Menu."</string>
    <string name="lockscreen_pattern_instructions" msgid="7478703254964810302">"Odblokujte pomocí gesta"</string>
    <string name="lockscreen_emergency_call" msgid="5347633784401285225">"Tísňové volání"</string>
    <string name="lockscreen_return_to_call" msgid="5244259785500040021">"Zavolat zpět"</string>
    <string name="lockscreen_pattern_correct" msgid="9039008650362261237">"Správně!"</string>
    <string name="lockscreen_pattern_wrong" msgid="4817583279053112312">"Zkuste to prosím znovu"</string>
    <string name="lockscreen_plugged_in" msgid="613343852842944435">"Nabíjení (<xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>)"</string>
    <string name="lockscreen_charged" msgid="4938930459620989972">"Nabito."</string>
    <string name="lockscreen_battery_short" msgid="3617549178603354656">"<xliff:g id="NUMBER">%d</xliff:g> <xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="lockscreen_low_battery" msgid="1482873981919249740">"Připojte dobíjecí zařízení."</string>
    <string name="lockscreen_missing_sim_message_short" msgid="7381499217732227295">"Není vložena SIM karta."</string>
    <string name="lockscreen_missing_sim_message" msgid="2186920585695169078">"V telefonu není žádná karta SIM."</string>
    <string name="lockscreen_missing_sim_instructions" msgid="8874620818937719067">"Prosím vložte kartu SIM."</string>
    <string name="emergency_calls_only" msgid="6733978304386365407">"Pouze tísňová volání"</string>
    <string name="lockscreen_network_locked_message" msgid="143389224986028501">"Síť je blokována"</string>
    <string name="lockscreen_sim_puk_locked_message" msgid="7441797339976230">"Karta SIM je zablokována pomocí kódu PUK."</string>
    <string name="lockscreen_sim_puk_locked_instructions" msgid="635967534992394321">"Další informace naleznete v uživatelské příručce, nebo kontaktujte podporu zákazníků."</string>
    <string name="lockscreen_sim_locked_message" msgid="8066660129206001039">"Karta SIM je zablokována."</string>
    <string name="lockscreen_sim_unlock_progress_dialog_message" msgid="595323214052881264">"Odblokování karty SIM..."</string>
    <string name="lockscreen_too_many_failed_attempts_dialog_message" msgid="3514742106066877476">"<xliff:g id="NUMBER_0">%d</xliff:g>krát jste nakreslili nesprávné bezpečnostní gesto. "\n\n"Opakujte prosím akci za <xliff:g id="NUMBER_1">%d</xliff:g> s."</string>
    <string name="lockscreen_failed_attempts_almost_glogin" msgid="3351013842320127827">"<xliff:g id="NUMBER_0">%d</xliff:g>krát jste nesprávně nakreslili své bezpečnostní gesto. Po dalších neúspěšných pokusech (<xliff:g id="NUMBER_1">%d</xliff:g>) budete požádáni o odemčení telefonu pomocí přihlášení do účtu Google."\n\n" Akci prosím opakujte za několik sekund (<xliff:g id="NUMBER_2">%d</xliff:g>)."</string>
    <string name="lockscreen_too_many_failed_attempts_countdown" msgid="6251480343394389665">"Sekundy zbývající do dalšího pokusu: <xliff:g id="NUMBER">%d</xliff:g>."</string>
    <string name="lockscreen_forgot_pattern_button_text" msgid="2626999449610695930">"Zapomněli jste gesto?"</string>
    <string name="lockscreen_glogin_forgot_pattern" msgid="2588521501166032747">"Odemčení účtu"</string>
    <string name="lockscreen_glogin_too_many_attempts" msgid="2446246026221678244">"Gesta: Příliš mnoho pokusů"</string>
    <string name="lockscreen_glogin_instructions" msgid="1816635201812207709">"Chcete-li telefon odemknout, přihlaste se pomocí svého účtu Google"</string>
    <string name="lockscreen_glogin_username_hint" msgid="8846881424106484447">"Uživatelské jméno (e-mail)"</string>
    <string name="lockscreen_glogin_password_hint" msgid="5958028383954738528">"Heslo"</string>
    <string name="lockscreen_glogin_submit_button" msgid="7130893694795786300">"Přihlásit se"</string>
    <string name="lockscreen_glogin_invalid_input" msgid="1364051473347485908">"Neplatné uživatelské jméno nebo heslo."</string>
    <string name="lockscreen_glogin_checking_password" msgid="6758890536332363322">"Probíhá kontrola..."</string>
    <string name="lockscreen_unlock_label" msgid="737440483220667054">"Odemknout"</string>
    <string name="lockscreen_sound_on_label" msgid="9068877576513425970">"Zapnout zvuk"</string>
    <string name="lockscreen_sound_off_label" msgid="996822825154319026">"Vypnout zvuk"</string>
    <string name="password_keyboard_label_symbol_key" msgid="992280756256536042">"?123"</string>
    <string name="password_keyboard_label_alpha_key" msgid="8001096175167485649">"ABC"</string>
    <string name="password_keyboard_label_alt_key" msgid="1284820942620288678">"Alt"</string>
    <string name="hour_ampm" msgid="4329881288269772723">"<xliff:g id="HOUR">%-l</xliff:g><xliff:g id="AMPM">%P</xliff:g>"</string>
    <string name="hour_cap_ampm" msgid="1829009197680861107">"<xliff:g id="HOUR">%-l</xliff:g><xliff:g id="AMPM">%p</xliff:g>"</string>
    <string name="status_bar_clear_all_button" msgid="7774721344716731603">"Vymazat"</string>
    <string name="status_bar_no_notifications_title" msgid="4755261167193833213">"Žádná oznámení"</string>
    <string name="status_bar_ongoing_events_title" msgid="1682504513316879202">"Probíhající"</string>
    <string name="status_bar_latest_events_title" msgid="6594767438577593172">"Oznámení"</string>
    <string name="battery_status_text_percent_format" msgid="7660311274698797147">"<xliff:g id="NUMBER">%d</xliff:g><xliff:g id="PERCENT">%%</xliff:g>"</string>
    <string name="battery_status_charging" msgid="756617993998772213">"Nabíjení..."</string>
    <string name="battery_low_title" msgid="7923774589611311406">"Prosím připojte dobíjecí zařízení"</string>
    <string name="battery_low_subtitle" msgid="7388781709819722764">"Baterie je vybitá:"</string>
    <string name="battery_low_percent_format" msgid="696154104579022959">"Zbývá <xliff:g id="NUMBER">%d%%</xliff:g> nebo méně."</string>
    <string name="battery_low_why" msgid="7279169609518386372">"Využití baterie"</string>
    <string name="factorytest_failed" msgid="5410270329114212041">"Test továrního nastavení se nezdařil"</string>
    <string name="factorytest_not_system" msgid="4435201656767276723">"Test FACTORY_TEST lze provést pouze u balíčků nainstalovaných ve složce /system/app."</string>
    <string name="factorytest_no_action" msgid="872991874799998561">"Nebyl nalezen žádný balíček umožňující test FACTORY_TEST."</string>
    <string name="factorytest_reboot" msgid="6320168203050791643">"Restartovat"</string>
    <string name="js_dialog_title" msgid="8143918455087008109">"Stránka <xliff:g id="TITLE">%s</xliff:g> uvádí:"</string>
    <string name="js_dialog_title_default" msgid="6961903213729667573">"JavaScript"</string>
    <string name="js_dialog_before_unload" msgid="1901675448179653089">"Chcete opustit tuto stránku?"\n\n"<xliff:g id="MESSAGE">%s</xliff:g>"\n\n"Vyberte OK, chcete-li pokračovat, nebo Zrušit, chcete-li na stránce zůstat."</string>
    <string name="save_password_label" msgid="6860261758665825069">"Potvrdit"</string>
    <string name="double_tap_toast" msgid="1068216937244567247">"Tip: Dvojitým klepnutím můžete zobrazení přiblížit nebo oddálit."</string>
    <string name="permlab_readHistoryBookmarks" msgid="1284843728203412135">"čtení historie a záložek Prohlížeče"</string>
    <string name="permdesc_readHistoryBookmarks" msgid="4981489815467617191">"Umožňuje aplikaci číst všechny navštívené adresy URL a záložky Prohlížeče."</string>
    <string name="permlab_writeHistoryBookmarks" msgid="9009434109836280374">"zápis do historie a záložek Prohlížeče"</string>
    <string name="permdesc_writeHistoryBookmarks" msgid="945571990357114950">"Umožní aplikaci změnit historii či záložky prohlížeče uložené v telefonu. Škodlivé aplikace mohou pomocí tohoto nastavení vymazat či pozměnit data Prohlížeče."</string>
    <string name="permlab_writeGeolocationPermissions" msgid="4715212655598275532">"Změnit oprávnění prohlížeče poskytovat informace o zeměpisné poloze"</string>
    <string name="permdesc_writeGeolocationPermissions" msgid="4011908282980861679">"Umožňuje aplikaci změnit oprávnění prohlížeče poskytovat informace o zeměpisné poloze. Škodlivé aplikace mohou toto nastavení použít k odesílání informací o umístění na libovolné webové stránky."</string>
    <string name="save_password_message" msgid="767344687139195790">"Chcete, aby si prohlížeč zapamatoval toto heslo?"</string>
    <string name="save_password_notnow" msgid="6389675316706699758">"Nyní ne"</string>
    <string name="save_password_remember" msgid="6491879678996749466">"Zapamatovat"</string>
    <string name="save_password_never" msgid="8274330296785855105">"Nikdy"</string>
    <string name="open_permission_deny" msgid="5661861460947222274">"Nemáte povolení otevřít tuto stránku."</string>
    <string name="text_copied" msgid="4985729524670131385">"Text byl zkopírován do schránky."</string>
    <string name="more_item_label" msgid="4650918923083320495">"Více"</string>
    <string name="prepend_shortcut_label" msgid="2572214461676015642">"Menu+"</string>
    <string name="menu_space_shortcut_label" msgid="2410328639272162537">"mezerník"</string>
    <string name="menu_enter_shortcut_label" msgid="2743362785111309668">"enter"</string>
    <string name="menu_delete_shortcut_label" msgid="3658178007202748164">"smazat"</string>
    <string name="search_go" msgid="8298016669822141719">"Hledat"</string>
    <string name="oneMonthDurationPast" msgid="7396384508953779925">"před 1 měsícem"</string>
    <string name="beforeOneMonthDurationPast" msgid="909134546836499826">"Déle než před 1 měsícem"</string>
  <plurals name="num_seconds_ago">
    <item quantity="one" msgid="4869870056547896011">"před 1 sekundou"</item>
    <item quantity="other" msgid="3903706804349556379">"před <xliff:g id="COUNT">%d</xliff:g> sek."</item>
  </plurals>
  <plurals name="num_minutes_ago">
    <item quantity="one" msgid="3306787433088810191">"před 1 minutou"</item>
    <item quantity="other" msgid="2176942008915455116">"před <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="num_hours_ago">
    <item quantity="one" msgid="9150797944610821849">"před 1 hodinou"</item>
    <item quantity="other" msgid="2467273239587587569">"před <xliff:g id="COUNT">%d</xliff:g> hod."</item>
  </plurals>
  <plurals name="last_num_days">
    <item quantity="other" msgid="3069992808164318268">"Posledních <xliff:g id="COUNT">%d</xliff:g> dnů"</item>
  </plurals>
    <string name="last_month" msgid="3959346739979055432">"Poslední měsíc"</string>
    <string name="older" msgid="5211975022815554840">"Starší"</string>
  <plurals name="num_days_ago">
    <item quantity="one" msgid="861358534398115820">"včera"</item>
    <item quantity="other" msgid="2479586466153314633">"před <xliff:g id="COUNT">%d</xliff:g> dny"</item>
  </plurals>
  <plurals name="in_num_seconds">
    <item quantity="one" msgid="2729745560954905102">"za 1 sekundu"</item>
    <item quantity="other" msgid="1241926116443974687">"za <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="in_num_minutes">
    <item quantity="one" msgid="8793095251325200395">"za 1 minutu"</item>
    <item quantity="other" msgid="3330713936399448749">"za <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="in_num_hours">
    <item quantity="one" msgid="7164353342477769999">"za 1 hodinu"</item>
    <item quantity="other" msgid="547290677353727389">"za <xliff:g id="COUNT">%d</xliff:g> hod."</item>
  </plurals>
  <plurals name="in_num_days">
    <item quantity="one" msgid="5413088743009839518">"zítra"</item>
    <item quantity="other" msgid="5109449375100953247">"zbývající počet dní: <xliff:g id="COUNT">%d</xliff:g>"</item>
  </plurals>
  <plurals name="abbrev_num_seconds_ago">
    <item quantity="one" msgid="1849036840200069118">"před 1 s"</item>
    <item quantity="other" msgid="3699169366650930415">"před <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="abbrev_num_minutes_ago">
    <item quantity="one" msgid="6361490147113871545">"před 1 min."</item>
    <item quantity="other" msgid="851164968597150710">"před <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="abbrev_num_hours_ago">
    <item quantity="one" msgid="4796212039724722116">"před 1 hodinou"</item>
    <item quantity="other" msgid="6889970745748538901">"před <xliff:g id="COUNT">%d</xliff:g> hod."</item>
  </plurals>
  <plurals name="abbrev_num_days_ago">
    <item quantity="one" msgid="8463161711492680309">"včera"</item>
    <item quantity="other" msgid="3453342639616481191">"před <xliff:g id="COUNT">%d</xliff:g> dny"</item>
  </plurals>
  <plurals name="abbrev_in_num_seconds">
    <item quantity="one" msgid="5842225370795066299">"za 1 s"</item>
    <item quantity="other" msgid="5495880108825805108">"za <xliff:g id="COUNT">%d</xliff:g> s"</item>
  </plurals>
  <plurals name="abbrev_in_num_minutes">
    <item quantity="one" msgid="562786149928284878">"za 1 min."</item>
    <item quantity="other" msgid="4216113292706568726">"za <xliff:g id="COUNT">%d</xliff:g> min."</item>
  </plurals>
  <plurals name="abbrev_in_num_hours">
    <item quantity="one" msgid="3274708118124045246">"za 1 hodinu"</item>
    <item quantity="other" msgid="3705373766798013406">"za <xliff:g id="COUNT">%d</xliff:g> hod."</item>
  </plurals>
  <plurals name="abbrev_in_num_days">
    <item quantity="one" msgid="2178576254385739855">"zítra"</item>
    <item quantity="other" msgid="2973062968038355991">"zbývající počet dní: <xliff:g id="COUNT">%d</xliff:g>"</item>
  </plurals>
    <string name="preposition_for_date" msgid="9093949757757445117">"dne <xliff:g id="DATE">%s</xliff:g>"</string>
    <string name="preposition_for_time" msgid="5506831244263083793">"v <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="preposition_for_year" msgid="5040395640711867177">"roku <xliff:g id="YEAR">%s</xliff:g>"</string>
    <string name="day" msgid="8144195776058119424">"den"</string>
    <string name="days" msgid="4774547661021344602">"d."</string>
    <string name="hour" msgid="2126771916426189481">"hodina"</string>
    <string name="hours" msgid="894424005266852993">"hod."</string>
    <string name="minute" msgid="9148878657703769868">"min."</string>
    <string name="minutes" msgid="5646001005827034509">"min."</string>
    <string name="second" msgid="3184235808021478">"s"</string>
    <string name="seconds" msgid="3161515347216589235">"s"</string>
    <string name="week" msgid="5617961537173061583">"týden"</string>
    <string name="weeks" msgid="6509623834583944518">"týd."</string>
    <string name="year" msgid="4001118221013892076">"rokem"</string>
    <string name="years" msgid="6881577717993213522">"lety"</string>
    <string name="VideoView_error_title" msgid="3359437293118172396">"Video nelze přehrát"</string>
    <string name="VideoView_error_text_invalid_progressive_playback" msgid="897920883624437033">"Omlouváme se, ale toto video nelze přenášet datovým proudem do tohoto zařízení."</string>
    <string name="VideoView_error_text_unknown" msgid="710301040038083944">"Toto video bohužel nelze přehrát."</string>
    <string name="VideoView_error_button" msgid="2822238215100679592">"OK"</string>
    <string name="relative_time" msgid="1818557177829411417">"<xliff:g id="DATE">%1$s</xliff:g>, <xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="noon" msgid="7245353528818587908">"poledne"</string>
    <string name="Noon" msgid="3342127745230013127">"Poledne"</string>
    <string name="midnight" msgid="7166259508850457595">"půlnoc"</string>
    <string name="Midnight" msgid="5630806906897892201">"Půlnoc"</string>
    <string name="elapsed_time_short_format_mm_ss" msgid="4431555943828711473">"<xliff:g id="MINUTES">%1$02d</xliff:g>:<xliff:g id="SECONDS">%2$02d</xliff:g>"</string>
    <string name="elapsed_time_short_format_h_mm_ss" msgid="1846071997616654124">"<xliff:g id="HOURS">%1$d</xliff:g>:<xliff:g id="MINUTES">%2$02d</xliff:g>:<xliff:g id="SECONDS">%3$02d</xliff:g>"</string>
    <string name="selectAll" msgid="6876518925844129331">"Vybrat vše"</string>
    <string name="selectText" msgid="3889149123626888637">"Označit text"</string>
    <string name="stopSelectingText" msgid="4157931463872320996">"Zastavit označování textu"</string>
    <string name="cut" msgid="3092569408438626261">"Vyjmout"</string>
    <string name="cutAll" msgid="2436383270024931639">"Vyjmout vše"</string>
    <string name="copy" msgid="2681946229533511987">"Kopírovat"</string>
    <string name="copyAll" msgid="2590829068100113057">"Kopírovat vše"</string>
    <string name="paste" msgid="5629880836805036433">"Vložit"</string>
    <string name="copyUrl" msgid="2538211579596067402">"Kopírovat adresu URL"</string>
    <string name="inputMethod" msgid="1653630062304567879">"Metoda zadávání dat"</string>
    <string name="addToDictionary" msgid="8793624991686948709">"Přidat slovo „<xliff:g id="WORD">%s</xliff:g>“ do slovníku"</string>
    <string name="editTextMenuTitle" msgid="1672989176958581452">"Úpravy textu"</string>
    <string name="low_internal_storage_view_title" msgid="1399732408701697546">"Málo paměti"</string>
    <string name="low_internal_storage_view_text" msgid="635106544616378836">"V telefonu zbývá málo místa pro ukládání dat."</string>
    <string name="ok" msgid="5970060430562524910">"OK"</string>
    <string name="cancel" msgid="6442560571259935130">"Zrušit"</string>
    <string name="yes" msgid="5362982303337969312">"OK"</string>
    <string name="no" msgid="5141531044935541497">"Zrušit"</string>
    <string name="dialog_alert_title" msgid="2049658708609043103">"Upozornění"</string>
    <string name="capital_on" msgid="1544682755514494298">"ZAPNUTO"</string>
    <string name="capital_off" msgid="6815870386972805832">"VYPNOUT"</string>
    <string name="whichApplication" msgid="4533185947064773386">"Dokončit akci pomocí aplikace"</string>
    <string name="alwaysUse" msgid="4583018368000610438">"Použít jako výchozí nastavení pro tuto činnost."</string>
    <string name="clearDefaultHintMsg" msgid="4815455344600932173">"Vymažte výchozí hodnoty v Nastavení plochy &gt; Aplikace &gt; Správa aplikací."</string>
    <string name="chooseActivity" msgid="1009246475582238425">"Vyberte akci"</string>
    <string name="noApplications" msgid="1691104391758345586">"Tuto činnost nemohou provádět žádné aplikace."</string>
    <string name="aerr_title" msgid="653922989522758100">"Omlouváme se"</string>
    <string name="aerr_application" msgid="4683614104336409186">"Aplikace <xliff:g id="APPLICATION">%1$s</xliff:g> (proces <xliff:g id="PROCESS">%2$s</xliff:g>) byla neočekávaně ukončena. Zkuste to znovu."</string>
    <string name="aerr_process" msgid="1551785535966089511">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> byl neočekávaně ukončen. Opakujte prosím akci."</string>
    <string name="anr_title" msgid="3100070910664756057">"Omlouváme se"</string>
    <string name="anr_activity_application" msgid="3538242413112507636">"Činnost <xliff:g id="ACTIVITY">%1$s</xliff:g> (v aplikaci <xliff:g id="APPLICATION">%2$s</xliff:g>) neodpovídá."</string>
    <string name="anr_activity_process" msgid="5420826626009561014">"Služba <xliff:g id="ACTIVITY">%1$s</xliff:g> (<xliff:g id="PROCESS">%2$s</xliff:g>) nereaguje."</string>
    <string name="anr_application_process" msgid="4185842666452210193">"Služba <xliff:g id="APPLICATION">%1$s</xliff:g> (<xliff:g id="PROCESS">%2$s</xliff:g>) nereaguje."</string>
    <string name="anr_process" msgid="1246866008169975783">"Proces <xliff:g id="PROCESS">%1$s</xliff:g> neodpovídá."</string>
    <string name="force_close" msgid="3653416315450806396">"Ukončit aplikaci"</string>
    <string name="report" msgid="4060218260984795706">"Nahlásit"</string>
    <string name="wait" msgid="7147118217226317732">"Počkat"</string>
    <string name="sendText" msgid="5132506121645618310">"Vyberte činnost s textem"</string>
    <string name="volume_ringtone" msgid="6885421406845734650">"Hlasitost vyzvánění"</string>
    <string name="volume_music" msgid="5421651157138628171">"Hlasitost médií"</string>
    <string name="volume_music_hint_playing_through_bluetooth" msgid="9165984379394601533">"Přehrávání pomocí rozhraní Bluetooth"</string>
    <string name="volume_music_hint_silent_ringtone_selected" msgid="6158339745293431194">"Je vybrán tichý vyzváněcí tón"</string>
    <string name="volume_call" msgid="3941680041282788711">"Hlasitost hovoru"</string>
    <string name="volume_bluetooth_call" msgid="2002891926351151534">"Hlasitost příchozích hovorů při připojení Bluetooth"</string>
    <string name="volume_alarm" msgid="1985191616042689100">"Hlasitost budíku"</string>
    <string name="volume_notification" msgid="2422265656744276715">"Hlasitost oznámení"</string>
    <string name="volume_unknown" msgid="1400219669770445902">"Hlasitost"</string>
    <string name="ringtone_default" msgid="3789758980357696936">"Výchozí vyzváněcí tón"</string>
    <string name="ringtone_default_with_actual" msgid="8129563480895990372">"Výchozí vyzváněcí tón (<xliff:g id="ACTUAL_RINGTONE">%1$s</xliff:g>)"</string>
    <string name="ringtone_silent" msgid="4440324407807468713">"Ticho"</string>
    <string name="ringtone_picker_title" msgid="3515143939175119094">"Vyzváněcí tóny"</string>
    <string name="ringtone_unknown" msgid="5477919988701784788">"Neznámý vyzváněcí tón"</string>
  <plurals name="wifi_available">
    <item quantity="one" msgid="6654123987418168693">"K dispozici je síť WiFi."</item>
    <item quantity="other" msgid="4192424489168397386">"Jsou k dispozici sítě WiFi."</item>
  </plurals>
  <plurals name="wifi_available_detailed">
    <item quantity="one" msgid="1634101450343277345">"K dispozici je veřejná síť WiFi"</item>
    <item quantity="other" msgid="7915895323644292768">"Jsou k dispozici veřejné sítě WiFi"</item>
  </plurals>
    <string name="select_character" msgid="3365550120617701745">"Vkládání znaků"</string>
    <string name="sms_control_default_app_name" msgid="7630529934366549163">"Neznámá aplikace"</string>
    <string name="sms_control_title" msgid="7296612781128917719">"Odesílání zpráv SMS"</string>
    <string name="sms_control_message" msgid="1289331457999236205">"Je odesílán velký počet zpráv SMS. Vyberte OK, chcete-li pokračovat, nebo Zrušit, chcete-li odesílání ukončit."</string>
    <string name="sms_control_yes" msgid="2532062172402615953">"OK"</string>
    <string name="sms_control_no" msgid="1715320703137199869">"Zrušit"</string>
    <string name="date_time_set" msgid="5777075614321087758">"Nastavit"</string>
    <string name="default_permission_group" msgid="2690160991405646128">"Výchozí"</string>
    <string name="no_permissions" msgid="7283357728219338112">"Nejsou vyžadována žádná oprávnění"</string>
    <string name="perms_hide" msgid="7283915391320676226"><b>"Skrýt"</b></string>
    <string name="perms_show_all" msgid="2671791163933091180"><b>"Zobrazit vše"</b></string>
    <string name="usb_storage_activity_title" msgid="2399289999608900443">"Úložiště USB"</string>
    <string name="usb_storage_title" msgid="5901459041398751495">"USB připojeno"</string>
    <string name="usb_storage_message" msgid="4796759646167247178">"Připojili jste svůj telefon k počítači pomocí USB. Chcete-li kopírovat soubory z počítače na kartu SD v zařízení Android či obráceně, vyberte následující tlačítko."</string>
    <string name="usb_storage_button_mount" msgid="1052259930369508235">"Zapnout úložiště USB"</string>
    <string name="usb_storage_error_message" msgid="2534784751603345363">"Při používání vaší karty SD jako úložiště USB došlo k problému."</string>
    <string name="usb_storage_notification_title" msgid="8175892554757216525">"USB připojeno"</string>
    <string name="usb_storage_notification_message" msgid="7380082404288219341">"Vyberte, chcete-li kopírovat soubory do nebo z počítače."</string>
    <string name="usb_storage_stop_notification_title" msgid="2336058396663516017">"Vypnout úložiště USB"</string>
    <string name="usb_storage_stop_notification_message" msgid="2591813490269841539">"Vyberte, chcete-li vypnout úložiště USB."</string>
    <string name="usb_storage_stop_title" msgid="660129851708775853">"Úložiště USB je používáno"</string>
    <string name="usb_storage_stop_message" msgid="3613713396426604104">"Před vypnutím úložiště USB zkontrolujte, zda jste odpojili (vyjmuli) kartu SD zařízení Android z počítače."</string>
    <string name="usb_storage_stop_button_mount" msgid="7060218034900696029">"Vypnout úložiště USB"</string>
    <string name="usb_storage_stop_error_message" msgid="143881914840412108">"Při vypínání úložiště USB došlo k problémům. Zkontrolujte, zda byl hostitel USB odpojen, a zkuste to znovu."</string>
    <string name="dlg_confirm_kill_storage_users_title" msgid="963039033470478697">"Zapnout úložiště USB"</string>
    <string name="dlg_confirm_kill_storage_users_text" msgid="3202838234780505886">"Pokud zapnete úložiště USB, dojde k zastavení některých používaných aplikací. Tyto aplikace pravděpodobně nebudou k dispozici až do vypnutí úložiště USB."</string>
    <string name="dlg_error_title" msgid="8048999973837339174">"Chyba operace na rozhraní USB"</string>
    <string name="dlg_ok" msgid="7376953167039865701">"OK"</string>
    <string name="extmedia_format_title" msgid="8663247929551095854">"Formátovat kartu SD"</string>
    <string name="extmedia_format_message" msgid="3621369962433523619">"Opravdu chcete kartu SD naformátovat? Všechna data na kartě budou ztracena."</string>
    <string name="extmedia_format_button_format" msgid="4131064560127478695">"Formátovat"</string>
    <string name="adb_active_notification_title" msgid="6729044778949189918">"Ladění přes rozhraní USB připojeno"</string>
    <string name="adb_active_notification_message" msgid="8470296818270110396">"Vyberte, chcete-li zakázat ladění USB."</string>
    <string name="select_input_method" msgid="6865512749462072765">"Výběr metody zadávání dat"</string>
    <string name="fast_scroll_alphabet" msgid="5433275485499039199">" AÁBCČDĎEÉĚFGHCHIÍJKLMNŇOÓPQRŘSŠTŤUÚVWXYÝZŽ"</string>
    <string name="fast_scroll_numeric_alphabet" msgid="4030170524595123610">" 0123456789AÁBCČDĎEÉĚFGHCHIÍJKLMNŇOÓPQRŘSŠTŤUÚVWXYÝZŽ"</string>
    <string name="candidates_style" msgid="4333913089637062257"><u>"kandidáti"</u></string>
    <string name="ext_media_checking_notification_title" msgid="5457603418970994050">"Příprava karty SD"</string>
    <string name="ext_media_checking_notification_message" msgid="8287319882926737053">"Kontrola chyb."</string>
    <string name="ext_media_nofs_notification_title" msgid="780477838241212997">"Prázdná karta SD"</string>
    <string name="ext_media_nofs_notification_message" msgid="3817704088027829380">"Karta SD je prázdná nebo obsahuje nepodporovaný systém souborů."</string>
    <string name="ext_media_unmountable_notification_title" msgid="6410723906019100189">"Poškozená karta SD"</string>
    <string name="ext_media_unmountable_notification_message" msgid="6902531775948238989">"Karta SD je poškozená. Bude pravděpodobně nutné ji přeformátovat."</string>
    <string name="ext_media_badremoval_notification_title" msgid="6872152882604407837">"Karta SD byla neočekávaně odebrána"</string>
    <string name="ext_media_badremoval_notification_message" msgid="7260183293747448241">"Chcete-li zabránit ztrátě dat, kartu SD před odebráním odpojte."</string>
    <string name="ext_media_safe_unmount_notification_title" msgid="6729801130790616200">"Kartu SD je možné bezpečně odebrat"</string>
    <string name="ext_media_safe_unmount_notification_message" msgid="568841278138377604">"Kartu SD lze bezpečně odebrat."</string>
    <string name="ext_media_nomedia_notification_title" msgid="8902518030404381318">"Karta SD byla odstraněna"</string>
    <string name="ext_media_nomedia_notification_message" msgid="3870120652983659641">"Karta SD byla odebrána. Vložte novou kartu."</string>
    <string name="activity_list_empty" msgid="4168820609403385789">"Nebyly nalezeny žádné odpovídající aktivity."</string>
    <string name="permlab_pkgUsageStats" msgid="8787352074326748892">"aktualizovat statistiku použití součástí"</string>
    <string name="permdesc_pkgUsageStats" msgid="891553695716752835">"Umožňuje změnu shromážděných statistických údajů o použití součástí. Není určeno pro běžné aplikace."</string>
    <string name="permlab_copyProtectedData" msgid="1660908117394854464">"Umožňuje volat výchozí službu kontejneru ke zkopírování obsahu. Běžné aplikace by toto oprávnění neměly používat."</string>
    <string name="permdesc_copyProtectedData" msgid="537780957633976401">"Umožňuje volat výchozí službu kontejneru ke zkopírování obsahu. Běžné aplikace by toto oprávnění neměly používat."</string>
    <string name="tutorial_double_tap_to_zoom_message_short" msgid="1311810005957319690">"Poklepáním můžete ovládat přiblížení"</string>
    <string name="gadget_host_error_inflating" msgid="2613287218853846830">"Chyba při spouštění widgetu"</string>
    <string name="ime_action_go" msgid="8320845651737369027">"Přejít"</string>
    <string name="ime_action_search" msgid="658110271822807811">"Hledat"</string>
    <string name="ime_action_send" msgid="2316166556349314424">"Odeslat"</string>
    <string name="ime_action_next" msgid="3138843904009813834">"Další"</string>
    <string name="ime_action_done" msgid="8971516117910934605">"Hotovo"</string>
    <string name="ime_action_default" msgid="2840921885558045721">"Spustit"</string>
    <string name="dial_number_using" msgid="5789176425167573586">"Vytočit číslo"\n" <xliff:g id="NUMBER">%s</xliff:g>."</string>
    <string name="create_contact_using" msgid="4947405226788104538">"Vytvořit kontakt"\n"pro <xliff:g id="NUMBER">%s</xliff:g>."</string>
    <string name="accessibility_compound_button_selected" msgid="5612776946036285686">"Zaškrtnuto"</string>
    <string name="accessibility_compound_button_unselected" msgid="8864512895673924091">"Nezaškrtnuto"</string>
    <string name="grant_credentials_permission_message_header" msgid="6824538733852821001">"Následující aplikace požadují oprávnění k přístupu do vašeho účtu (nyní i v budoucnu)."</string>
    <string name="grant_credentials_permission_message_footer" msgid="3125211343379376561">"Chcete tento požadavek povolit?"</string>
    <string name="grant_permissions_header_text" msgid="2722567482180797717">"Požadavek na přístup"</string>
    <string name="allow" msgid="7225948811296386551">"Povolit"</string>
    <string name="deny" msgid="2081879885755434506">"Odepřít"</string>
    <string name="permission_request_notification_title" msgid="5390555465778213840">"Požadováno oprávnění"</string>
    <string name="permission_request_notification_with_subtitle" msgid="4325409589686688000">"Požadováno oprávnění"\n"pro účet <xliff:g id="ACCOUNT">%s</xliff:g>"</string>
    <string name="input_method_binding_label" msgid="1283557179944992649">"Metoda zadávání dat"</string>
    <string name="sync_binding_label" msgid="3687969138375092423">"Synchronizace"</string>
    <string name="accessibility_binding_label" msgid="4148120742096474641">"Usnadnění"</string>
    <string name="wallpaper_binding_label" msgid="1240087844304687662">"Tapeta"</string>
    <string name="chooser_wallpaper" msgid="7873476199295190279">"Změnit tapetu"</string>
    <string name="pptp_vpn_description" msgid="2688045385181439401">"Protokol PPTP (Point-to-Point Tunneling Protocol)"</string>
    <string name="l2tp_vpn_description" msgid="3750692169378923304">"Protokol L2TP (Layer 2 Tunneling Protocol)"</string>
    <string name="l2tp_ipsec_psk_vpn_description" msgid="3945043564008303239">"Síť VPN L2TP/IPSec s předsdíleným klíčem"</string>
    <string name="l2tp_ipsec_crt_vpn_description" msgid="5382714073103653577">"Síť VPN L2TP/IPSec s certifikátem"</string>
    <string name="upload_file" msgid="2897957172366730416">"Zvolit soubor"</string>
    <string name="reset" msgid="2448168080964209908">"Resetovat"</string>
    <string name="submit" msgid="1602335572089911941">"Odeslat"</string>
    <string name="description_star" msgid="2654319874908576133">"oblíbené"</string>
    <string name="car_mode_disable_notification_title" msgid="3164768212003864316">"Aktivován režim V autě"</string>
    <string name="car_mode_disable_notification_message" msgid="668663626721675614">"Vyberte, chcete-li ukončit režim Na cestě."</string>
    <string name="tethered_notification_title" msgid="3146694234398202601">"Je aktivní tethering nebo hotspot"</string>
    <string name="tethered_notification_message" msgid="3067108323903048927">"Dotykem zahájíte konfiguraci"</string>
    <string name="throttle_warning_notification_title" msgid="4890894267454867276">"Vysoké využití mobilních dat"</string>
    <string name="throttle_warning_notification_message" msgid="2609734763845705708">"Dotykem zobrazíte další informace o využití mobilních dat"</string>
    <string name="throttled_notification_title" msgid="6269541897729781332">"Byl překročen limit mobilních dat"</string>
    <string name="throttled_notification_message" msgid="4712369856601275146">"Dotykem zobrazíte další informace o využití mobilních dat"</string>
</resources>
