<?xml version="1.0" encoding="UTF-8"?>
<!-- 
  ~ Copyright (C) 2015 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="bt_app_name" msgid="5515382901862469770">"TV kanālu meklētājs"</string>
    <string name="ut_app_name" msgid="8557698013780762454">"USB TV kanālu meklētājs"</string>
    <string name="nt_app_name" msgid="4627006858832620833">"Interneta TV kanālu meklētājs (BETA)"</string>
    <string name="ut_setup_cancel" msgid="5318292052302751909">"Lūdzu, uzgaidiet, līdz tiks pabeigta apstrāde!"</string>
    <string name="ut_rescan_needed" msgid="2273655435759849436">"Nesen tika atjaunināta kanālu meklētāja programmatūra. Lūdzu, atkārtoti meklējiet kanālus."</string>
    <string name="ut_surround_sound_disabled" msgid="6465044734143962900">"Lai ieslēgtu audio, sistēmas skaņas iestatījumos iespējojiet ieskaujošo skaņu."</string>
    <string name="audio_passthrough_not_supported" msgid="8766302073295760976">"Nevar atskaņot audio. Lūdzu, izmantojiet citu televizoru."</string>
    <string name="ut_setup_breadcrumb" msgid="2810318605327367247">"Kanālu meklētāja iestatīšana"</string>
    <string name="bt_setup_new_title" msgid="8447554965697762891">"TV kanālu meklētāja iestatīšana"</string>
    <string name="ut_setup_new_title" msgid="2118880835101453405">"USB kanālu meklētāja iestatīšana"</string>
    <string name="nt_setup_new_title" msgid="2996573474450060002">"Interneta kanālu meklētāja iestatīšana"</string>
    <string name="bt_setup_new_description" msgid="256690722062003128">"Pārbaudiet, vai televizors ir pievienots TV signāla avotam.\n\nJa izmantojat bezvadu antenu, iespējams, būs jāmaina tās novietojums vai virziens, lai uztvertu lielāko daļu kanālu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga."</string>
    <string name="ut_setup_new_description" msgid="2610122936163002137">"Pārbaudiet, vai USB kanālu meklētājs ir pievienots strāvas avotam un TV signāla avotam.\n\nJa izmantojat bezvadu antenu, mainiet tās novietojumu un virzienu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga un atkārtojiet kanālu meklēšanu."</string>
    <string name="nt_setup_new_description" msgid="8315318180352515751">"Pārbaudiet, vai interneta kanālu meklētājs ir ieslēgts un pievienots TV signāla avotam.\n\nJa izmantojat bezvadu antenu, iespējams, jāmaina tās novietojums vai virziens, lai uztvertu lielāko daļu kanālu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga."</string>
  <string-array name="ut_setup_new_choices">
    <item msgid="8728069574888601683">"Turpināt"</item>
    <item msgid="727245208787621142">"Vēlāk"</item>
  </string-array>
    <string name="bt_setup_again_title" msgid="884713873101099572">"Vai atkārtot kanālu iestatīšanu?"</string>
    <string name="bt_setup_again_description" msgid="1247792492948741337">"Šādi no TV kanālu meklētāja tiks noņemti atrastie kanāli un tiks vēlreiz meklēti jauni kanāli.\n\nPārbaudiet, vai televizors ir pievienots TV signāla avotam.\n\nJa izmantojat bezvadu antenu, iespējams, būs jāmaina tās novietojums vai virziens, lai uztvertu lielāko daļu kanālu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga."</string>
    <string name="ut_setup_again_description" msgid="7837706010887799255">"Tādējādi tiks noņemti kanāli, kas tika atrasti ar USB kanālu meklētāju, un tiks atkārtota kanālu meklēšana.\n\nPārbaudiet, vai USB kanālu meklētājs ir pievienots strāvas avotam un TV signāla avotam.\n\nJa izmantojat bezvadu antenu, mainiet tās novietojumu un virzienu, lai uztvertu lielāko daļu kanālu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga."</string>
    <string name="nt_setup_again_description" msgid="681642895365018072">"Šādi no interneta kanālu meklētāja tiks noņemti atrastie kanāli un tiks vēlreiz meklēti jauni kanāli.\n\nPārbaudiet, vai interneta kanālu meklētājs ir ieslēgts un pievienots TV signāla avotam.\n\nJa izmantojat bezvadu antenu, iespējams, jāmaina tās novietojums vai virziens, lai uztvertu lielāko daļu kanālu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga."</string>
  <string-array name="ut_setup_again_choices">
    <item msgid="2557527790311851317">"Turpināt"</item>
    <item msgid="235450158666155406">"Atcelt"</item>
  </string-array>
    <string name="ut_connection_title" msgid="8435949189164677545">"Atlasiet savienojuma veidu"</string>
    <string name="ut_connection_description" msgid="7234582943233286192">"Ja kanālu meklētājam ir ārējā antena, izvēlieties opciju “Antena”. Ja izmantojat kabeļtelevīziju, izvēlieties opciju “Kabelis”. Ja neesat pārliecināts, kanālu meklēšana tiks veikta, izmantojot abas opcijas, taču būs nepieciešams vairāk laika."</string>
  <string-array name="ut_connection_choices">
    <item msgid="1499878461856892555">"Antena"</item>
    <item msgid="2670079958754180142">"Kabelis"</item>
    <item msgid="36774059871728525">"Neesmu pārliecināts"</item>
    <item msgid="6881204453182153978">"Tikai izstrāde"</item>
  </string-array>
    <string name="bt_channel_scan" msgid="3291924771702347469">"TV kanālu meklētāja iestatīšana"</string>
    <string name="ut_channel_scan" msgid="6100090671500464604">"USB kanālu meklētāja iestatīšana"</string>
    <string name="nt_channel_scan" msgid="30206992732534178">"Interneta kanālu meklētāja iestatīšana"</string>
    <string name="ut_channel_scan_time" msgid="1844845425359642393">"Tas var ilgt vairākas minūtes."</string>
    <string name="ut_channel_scan_tuner_unavailable" msgid="3135723754380409658">"Kanālu meklētājs īslaicīgi nav pieejams, vai arī tas jau tiek izmantots ierakstīšanai."</string>
    <plurals name="ut_channel_scan_message" formatted="false" msgid="3131606783282632056">
      <item quantity="zero">Atrasti %1$d kanāli</item>
      <item quantity="one">Atrasts %1$d kanāls</item>
      <item quantity="other">Atrasti %1$d kanāli</item>
    </plurals>
    <string name="ut_stop_channel_scan" msgid="566811986747774193">"APTURĒT KANĀLU MEKLĒŠANU"</string>
    <plurals name="ut_result_found_title" formatted="false" msgid="1448908152026339099">
      <item quantity="zero">Atrasti %1$d kanāli</item>
      <item quantity="one">Atrasts %1$d kanāls</item>
      <item quantity="other">Atrasti %1$d kanāli</item>
    </plurals>
    <plurals name="ut_result_found_description" formatted="false" msgid="4132691388395648565">
      <item quantity="zero">Lieliski! Tika atrasti %1$d kanāli. Ja jums šķiet, ka kaut kas nav pareizi, noregulējiet antenu un meklējiet kanālus vēlreiz.</item>
      <item quantity="one">Lieliski! Tika atrasts %1$d kanāls. Ja jums šķiet, ka kaut kas nav pareizi, noregulējiet antenu un meklējiet kanālus vēlreiz.</item>
      <item quantity="other">Lieliski! Tika atrasti %1$d kanāli. Ja jums šķiet, ka kaut kas nav pareizi, noregulējiet antenu un meklējiet kanālus vēlreiz.</item>
    </plurals>
  <string-array name="ut_result_found_choices">
    <item msgid="3220617441427115421">"Gatavs"</item>
    <item msgid="2480490326672924828">"Meklēt vēlreiz"</item>
  </string-array>
    <string name="ut_result_not_found_title" msgid="4649533929056795595">"Netika atrasts neviens kanāls"</string>
    <string name="bt_result_not_found_description" msgid="7378208337325024042">"Veicot meklēšanu, netika atrasts neviens kanāls. Pārbaudiet, vai televizors pievienots TV signāla avotam.\n\nJa izmantojat bezvadu antenu, mainiet tās novietojumu vai virzienu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga, bet pēc tam vēlreiz veiciet meklēšanu."</string>
    <string name="ut_result_not_found_description" msgid="1080746285957681414">"Netika atrasts neviens kanāls. Pārbaudiet, vai USB kanālu meklētājs ir pievienots strāvas avotam un TV signāla avotam.\n\nJa izmantojat bezvadu antenu, mainiet tās novietojumu un virzienu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga un atkārtojiet kanālu meklēšanu."</string>
    <string name="nt_result_not_found_description" msgid="2177919867285510855">"Netika atrasts neviens kanāls. Pārbaudiet, vai interneta kanālu meklētājs ir ieslēgts un pievienots TV signāla avotam.\n\nJa izmantojat bezvadu antenu, mainiet tās novietojumu un virzienu. Lai iegūtu labākos rezultātus, novietojiet antenu augstu pie loga un atkārtojiet kanālu meklēšanu."</string>
  <string-array name="ut_result_not_found_choices">
    <item msgid="5436884968471542030">"Meklēt vēlreiz"</item>
    <item msgid="2092797862490235174">"Gatavs"</item>
  </string-array>
    <string name="ut_setup_notification_content_title" msgid="3439301313253273422">"TV kanālu meklēšana"</string>
    <string name="bt_setup_notification_content_text" msgid="7578820978070596694">"TV kanālu meklētāja iestatīšana"</string>
    <string name="ut_setup_notification_content_text" msgid="1656697878628557384">"USB TV kanālu meklētāja iestatīšana"</string>
    <string name="nt_setup_notification_content_text" msgid="1186152789699583895">"Interneta TV kanālu meklētāja iestatīšana"</string>
    <string name="msg_usb_tuner_disconnected" msgid="1206606328815245830">"USB TV kanālu meklētājs ir atvienots."</string>
    <string name="msg_network_tuner_disconnected" msgid="7103193099674978964">"Interneta kanālu meklētājs ir atvienots."</string>
</resources>
