<?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">"An"</string>
    <string name="ut_setup_off" msgid="1333878787059290524">"Aus"</string>
    <string name="ut_setup_cancel" msgid="5318292052302751909">"Bitte warten Sie, bis die Verarbeitung abgeschlossen ist"</string>
    <string name="ut_select_channel_map" msgid="4831940000362338865">"Kanalquelle auswählen"</string>
    <string name="ut_no_signal" msgid="7390099185275997984">"Kein Signal"</string>
    <string name="ut_fail_to_tune" msgid="2964582177222053143">"\"<xliff:g id="CHANNEL_NAME">%s</xliff:g>\" konnte nicht eingestellt werden"</string>
    <string name="ut_fail_to_tune_to_unknown_channel" msgid="7078953579048783762">"Fehler beim Einstellen"</string>
    <string name="ut_rescan_needed" msgid="2273655435759849436">"Die Tunersoftware wurde kürzlich aktualisiert. Bitte führen Sie die Kanalsuche noch einmal durch."</string>
    <string name="ut_surround_sound_disabled" msgid="6465044734143962900">"Aktivieren Sie in den Systemeinstellungen Surround-Sound, um Audio einschalten zu können"</string>
    <string name="ut_setup_breadcrumb" msgid="2810318605327367247">"Kanaleinrichtung über den Tuner"</string>
    <string name="bt_setup_new_title" msgid="8447554965697762891">"TV-Tuner einrichten"</string>
    <string name="ut_setup_new_title" msgid="2118880835101453405">"Kanaleinrichtung über den USB-Tuner"</string>
    <string name="bt_setup_new_description" msgid="256690722062003128">"Vergewissern Sie sich, dass Ihr Fernseher mit einer TV-Signalquelle verbunden ist.\n\nWenn Sie eine terrestrische Antenne verwenden, ändern Sie die Position oder Ausrichtung, um mehr Kanäle zu finden. Die besten Ergebnisse erhalten Sie, wenn Sie sie an eine erhöhte Position in Fensternähe stellen."</string>
    <string name="ut_setup_new_description" msgid="2610122936163002137">"Vergewissern Sie sich, dass der USB-Tuner angeschlossen und mit einer TV-Signalquelle verbunden ist.\n\nWenn Sie eine terrestrische Antenne verwenden, ändern Sie die Position oder Ausrichtung, um mehr Kanäle zu finden. Die besten Ergebnisse erhalten Sie, wenn Sie sie an einer erhöhten Position in Fensternähe stellen."</string>
  <string-array name="ut_setup_new_choices">
    <item msgid="8728069574888601683">"Weiter"</item>
    <item msgid="727245208787621142">"Jetzt nicht"</item>
  </string-array>
    <string name="bt_setup_again_title" msgid="884713873101099572">"Kanaleinrichtung erneut durchführen?"</string>
    <string name="bt_setup_again_description" msgid="1247792492948741337">"Dies entfernt die vom TV-Tuner gefundenen Kanäle und sucht noch einmal nach neuen Kanälen.\n\nVergewissern Sie sich, dass Ihr Fernseher mit einer TV-Signalquelle verbunden ist.\n\nWenn Sie eine terrestrische Antenne verwenden, ändern Sie die Position oder Ausrichtung, um mehr Kanäle zu finden. Die besten Ergebnisse erhalten Sie, wenn Sie sie an eine erhöhte Position in Fensternähe stellen."</string>
    <string name="ut_setup_again_description" msgid="7837706010887799255">"Durch diese Aktion werden die gefundenen Kanäle vom USB-Tuner entfernt und die Kanalsuche wird erneut gestartet.\n\nVergewissern Sie sich, dass der USB-Tuner angeschlossen und mit einer TV-Signalquelle verbunden ist.\n\nWenn Sie eine terrestrische Antenne verwenden, ändern Sie die Position oder Ausrichtung, um mehr Kanäle zu finden. Die besten Ergebnisse erhalten Sie, wenn Sie sie an einer erhöhten Position in Fensternähe stellen."</string>
  <string-array name="ut_setup_again_choices">
    <item msgid="2557527790311851317">"Weiter"</item>
    <item msgid="235450158666155406">"Abbrechen"</item>
  </string-array>
    <string name="ut_connection_title" msgid="8435949189164677545">"Verbindungstyp auswählen"</string>
    <string name="ut_connection_description" msgid="7234582943233286192">"Wählen Sie \"Antenne\" aus, wenn eine externe Antenne mit dem Tuner verbunden ist. Wählen Sie \"Kabel\" aus, wenn Sie Ihre Kanäle bei einem Kabel-TV-Anbieter abrufen. Wenn Sie \"Nicht sicher\" auswählen, wird nach beiden Typen gesucht. Der Vorgang dauert dann unter Umständen länger."</string>
  <string-array name="ut_connection_choices">
    <item msgid="1499878461856892555">"Antenne"</item>
    <item msgid="2670079958754180142">"Kabel"</item>
    <item msgid="36774059871728525">"Nicht sicher"</item>
    <item msgid="6881204453182153978">"Nur Entwicklung"</item>
  </string-array>
    <string name="bt_channel_scan" msgid="3291924771702347469">"TV-Tuner einrichten"</string>
    <string name="ut_channel_scan" msgid="6100090671500464604">"Kanaleinrichtung über den USB-Tuner"</string>
    <string name="ut_channel_scan_time" msgid="1844845425359642393">"Dies kann einige Minuten dauern"</string>
    <string name="ut_channel_scan_tuner_unavailable" msgid="3135723754380409658">"Der Tuner ist vorübergehend nicht verfügbar oder wird schon für eine Aufnahme verwendet."</string>
    <plurals name="ut_channel_scan_message" formatted="false" msgid="3131606783282632056">
      <item quantity="other">%1$d Kanäle gefunden</item>
      <item quantity="one">%1$d Kanal gefunden</item>
    </plurals>
    <string name="ut_stop_channel_scan" msgid="566811986747774193">"KANALSUCHE STOPPEN"</string>
    <plurals name="ut_result_found_title" formatted="false" msgid="1448908152026339099">
      <item quantity="other">%1$d Kanäle gefunden</item>
      <item quantity="one">%1$d Kanal gefunden</item>
    </plurals>
    <plurals name="ut_result_found_description" formatted="false" msgid="4132691388395648565">
      <item quantity="other">Wunderbar. Bei der Kanalsuche wurden %1$d Kanäle gefunden. Wenn Sie vermuten, dass dies nicht korrekt ist, ändern Sie die Antennenposition und versuchen Sie es noch einmal.</item>
      <item quantity="one">Wunderbar. Bei der Kanalsuche wurde %1$d Kanal gefunden. Wenn Sie vermuten, dass dies nicht korrekt ist, ändern Sie die Antennenposition und versuchen Sie es noch einmal.</item>
    </plurals>
  <string-array name="ut_result_found_choices">
    <item msgid="3220617441427115421">"Fertig"</item>
    <item msgid="2480490326672924828">"Noch einmal suchen"</item>
  </string-array>
    <string name="ut_result_not_found_title" msgid="4649533929056795595">"Keine Kanäle gefunden"</string>
    <string name="bt_result_not_found_description" msgid="7378208337325024042">"Bei der Suche wurden keine Kanäle gefunden. Vergewissern Sie sich, dass Ihr Fernseher mit einer TV-Signalquelle verbunden ist.\n\nWenn Sie eine terrestrische Antenne verwenden, ändern Sie die Position oder Ausrichtung. Um die besten Ergebnisse zu erhalten, stellen Sie sie an eine erhöhte Position in Fensternähe und führen Sie die Suche noch einmal durch."</string>
    <string name="ut_result_not_found_description" msgid="1080746285957681414">"Bei der Suche wurden keine Kanäle gefunden. Vergewissern Sie sich, dass der USB-Tuner angeschlossen und mit einer TV-Signalquelle verbunden ist.\n\nWenn Sie eine terrestrische Antenne verwenden, ändern Sie die Position oder Ausrichtung. Die besten Ergebnisse erhalten Sie, wenn Sie sie an einer erhöhten Position in Fensternähe stellen. Führen Sie dann die Suche erneut durch."</string>
  <string-array name="ut_result_not_found_choices">
    <item msgid="5436884968471542030">"Noch einmal suchen"</item>
    <item msgid="2092797862490235174">"Fertig"</item>
  </string-array>
    <string name="ut_setup_recommendation_card_focused_title" msgid="7434151993964505386">"Nach TV-Kanälen suchen"</string>
    <string name="bt_setup_recommendation_card_title" msgid="1026906771141769829">"TV-Tuner einrichten"</string>
    <string name="ut_setup_recommendation_card_title" msgid="1093869817128338226">"USB-TV-Tuner einrichten"</string>
    <string name="msg_usb_device_detached" msgid="5123930566630230724">"Verbindung zum USB-TV-Empfänger wurde aufgehoben."</string>
</resources>
