<?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-tuner"</string>
    <string name="ut_app_name" msgid="8557698013780762454">"USB-tv-tuner"</string>
    <string name="ut_setup_on" msgid="7755608253387551795">"Aan"</string>
    <string name="ut_setup_off" msgid="1333878787059290524">"Uit"</string>
    <string name="ut_setup_cancel" msgid="5318292052302751909">"Wacht tot het proces is voltooid"</string>
    <string name="ut_select_channel_map" msgid="4831940000362338865">"Selecteer je kanaalbron"</string>
    <string name="ut_no_signal" msgid="7390099185275997984">"Geen signaal"</string>
    <string name="ut_fail_to_tune" msgid="2964582177222053143">"Kan niet afstemmen op <xliff:g id="CHANNEL_NAME">%s</xliff:g>"</string>
    <string name="ut_fail_to_tune_to_unknown_channel" msgid="7078953579048783762">"Kan niet afstemmen"</string>
    <string name="ut_rescan_needed" msgid="2273655435759849436">"De software van de tuner is recent geüpdatet. Scan de kanalen opnieuw."</string>
    <string name="ut_surround_sound_disabled" msgid="6465044734143962900">"Schakel surrond sound in via de geluidsinstellingen van het systeem om audio in te schakelen"</string>
    <string name="ut_setup_breadcrumb" msgid="2810318605327367247">"Configuratie van kanaaltuner"</string>
    <string name="bt_setup_new_title" msgid="8447554965697762891">"Tv-tuner instellen"</string>
    <string name="ut_setup_new_title" msgid="2118880835101453405">"Kanaalconfiguratie van USB-tuner"</string>
    <string name="bt_setup_new_description" msgid="256690722062003128">"Controleer of je tv is aangesloten op een tv-signaalbron.\n\nAls je een over-the-air-antenne gebruikt, moet je de positie of richting daarvan mogelijk aanpassen om zo veel mogelijk kanalen te ontvangen. Voor de beste resultaten plaats je de antenne op een hoge plek in de buurt van een raam."</string>
    <string name="ut_setup_new_description" msgid="2610122936163002137">"Controleer of de USB-tuner is ingeschakeld en aangesloten op een tv-signaalbron.\n\nAls je een over-the-air-antenne gebruikt, moet je de positie of richting daarvan mogelijk aanpassen om zo veel mogelijk kanalen te ontvangen. Voor de beste resultaten plaats je de antenne op een hoge plek in de buurt van een raam."</string>
  <string-array name="ut_setup_new_choices">
    <item msgid="8728069574888601683">"Doorgaan"</item>
    <item msgid="727245208787621142">"Niet nu"</item>
  </string-array>
    <string name="bt_setup_again_title" msgid="884713873101099572">"Kanaalconfiguratie opnieuw uitvoeren?"</string>
    <string name="bt_setup_again_description" msgid="1247792492948741337">"Hiermee worden de gevonden kanalen verwijderd van de tv-tuner en wordt opnieuw gezocht naar nieuwe kanalen.\n\nControleer of je tv is aangesloten op een tv-signaalbron.\n\nAls je een over-the-air-antenne gebruikt, moet je de positie of richting daarvan mogelijk aanpassen om zo veel mogelijk kanalen te ontvangen. Voor de beste resultaten plaats je de antenne op een hoge plek in de buurt van een raam."</string>
    <string name="ut_setup_again_description" msgid="7837706010887799255">"Hiermee worden de gevonden kanalen verwijderd van de USB-tuner en wordt opnieuw gescand naar nieuwe kanalen.\n\nControleer of de USB-tuner is ingeschakeld en aangesloten op een tv-signaalbron.\n\nAls je een over-the-air-antenne gebruikt, moet je de positie of richting daarvan mogelijk aanpassen om zo veel mogelijk kanalen te ontvangen. Voor de beste resultaten plaats je de antenne op een hoge plek in de buurt van een raam."</string>
  <string-array name="ut_setup_again_choices">
    <item msgid="2557527790311851317">"Doorgaan"</item>
    <item msgid="235450158666155406">"Annuleren"</item>
  </string-array>
    <string name="ut_connection_title" msgid="8435949189164677545">"Het verbindingstype selecteren"</string>
    <string name="ut_connection_description" msgid="7234582943233286192">"Kies Antenne als er een externe antenne is aangesloten op de tuner. Kies Kabel als je kanalen afkomstig zijn van een kabelprovider. Als je het niet zeker weet, worden beide typen gescand. Dit kan echter langer duren."</string>
  <string-array name="ut_connection_choices">
    <item msgid="1499878461856892555">"Antenne"</item>
    <item msgid="2670079958754180142">"Kabel"</item>
    <item msgid="36774059871728525">"Niet zeker"</item>
    <item msgid="6881204453182153978">"Alleen ontwikkeling"</item>
  </string-array>
    <string name="bt_channel_scan" msgid="3291924771702347469">"Tv-tuner instellen"</string>
    <string name="ut_channel_scan" msgid="6100090671500464604">"Kanaalconfiguratie van USB-tuner"</string>
    <string name="ut_channel_scan_time" msgid="1844845425359642393">"Dit kan enkele minuten duren"</string>
    <string name="ut_channel_scan_tuner_unavailable" msgid="3135723754380409658">"De tuner is tijdelijk niet beschikbaar of wordt al gebruikt voor een opname."</string>
    <plurals name="ut_channel_scan_message" formatted="false" msgid="3131606783282632056">
      <item quantity="other">%1$d kanalen gevonden</item>
      <item quantity="one">%1$d kanaal gevonden</item>
    </plurals>
    <string name="ut_stop_channel_scan" msgid="566811986747774193">"KANAALSCAN STOPPEN"</string>
    <plurals name="ut_result_found_title" formatted="false" msgid="1448908152026339099">
      <item quantity="other">%1$d kanalen gevonden</item>
      <item quantity="one">%1$d kanaal gevonden</item>
    </plurals>
    <plurals name="ut_result_found_description" formatted="false" msgid="4132691388395648565">
      <item quantity="other">Er zijn %1$d kanalen gevonden tijdens de kanaalscan. Als je denkt dat dit niet klopt, pas je de antennepositie aan en voer je de scan opnieuw uit.</item>
      <item quantity="one">Er is %1$d kanaal gevonden tijdens de kanaalscan. Als je denkt dat dit niet klopt, pas je de antennepositie aan en voer je de scan opnieuw uit.</item>
    </plurals>
  <string-array name="ut_result_found_choices">
    <item msgid="3220617441427115421">"Gereed"</item>
    <item msgid="2480490326672924828">"Opnieuw scannen"</item>
  </string-array>
    <string name="ut_result_not_found_title" msgid="4649533929056795595">"Geen kanalen gevonden"</string>
    <string name="bt_result_not_found_description" msgid="7378208337325024042">"Er zijn geen kanalen gevonden tijdens de scan. Controleer of je tv is aangesloten op een tv-signaalbron.\n\nAls je een over-the-air-antenne gebruikt, pas je de positie of richting daarvan aan. Voor de beste resultaten plaats je de antenne op een hoge plek in de buurt van een raam en voer je de scan opnieuw uit."</string>
    <string name="ut_result_not_found_description" msgid="1080746285957681414">"Er zijn geen kanalen gevonden tijdens de scan. Controleer of de USB-tuner is ingeschakeld en aangesloten op een tv-signaalbron.\n\nAls je een over-the-air-antenne gebruikt, pas je de positie of richting daarvan aan. Voor de beste resultaten plaats je de antenne op een hoge plek in de buurt van een raam en voer je de scan opnieuw uit."</string>
  <string-array name="ut_result_not_found_choices">
    <item msgid="5436884968471542030">"Opnieuw scannen"</item>
    <item msgid="2092797862490235174">"Gereed"</item>
  </string-array>
    <string name="ut_setup_recommendation_card_focused_title" msgid="7434151993964505386">"Scannen naar tv-kanalen"</string>
    <string name="bt_setup_recommendation_card_title" msgid="1026906771141769829">"Tv-tuner instellen"</string>
    <string name="ut_setup_recommendation_card_title" msgid="1093869817128338226">"USB-tv-tuner instellen"</string>
    <string name="msg_usb_device_detached" msgid="5123930566630230724">"USB-tv-tuner ontkoppeld."</string>
</resources>
