<?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 Kanal Ayarlayıcı"</string>
    <string name="ut_app_name" msgid="8557698013780762454">"USB TV Kanal Ayarlayıcı"</string>
    <string name="ut_setup_on" msgid="7755608253387551795">"Açık"</string>
    <string name="ut_setup_off" msgid="1333878787059290524">"Kapalı"</string>
    <string name="ut_setup_cancel" msgid="5318292052302751909">"Lütfen işlemin tamamlanmasını bekleyin"</string>
    <string name="ut_select_channel_map" msgid="4831940000362338865">"Kanal kaynağınızı seçin"</string>
    <string name="ut_no_signal" msgid="7390099185275997984">"Sinyal Yok"</string>
    <string name="ut_fail_to_tune" msgid="2964582177222053143">"<xliff:g id="CHANNEL_NAME">%s</xliff:g> adlı kanala ayarlanamadı"</string>
    <string name="ut_fail_to_tune_to_unknown_channel" msgid="7078953579048783762">"Kanal ayarlanamadı"</string>
    <string name="ut_rescan_needed" msgid="2273655435759849436">"Kanal ayarlayıcı yazılımı yakın zamanda güncellendi. Lütfen kanalları yeniden tarayın."</string>
    <string name="ut_surround_sound_disabled" msgid="6465044734143962900">"Sesi etkinleştirmek için sistemin ses ayarlarında surround sesi etkinleştirin"</string>
    <string name="ut_setup_breadcrumb" msgid="2810318605327367247">"Kanal ayarlayıcı kurulumu"</string>
    <string name="bt_setup_new_title" msgid="8447554965697762891">"TV Kanal Ayarlayıcı kurulumu"</string>
    <string name="ut_setup_new_title" msgid="2118880835101453405">"USB kanal ayarlayıcı kurulumu"</string>
    <string name="bt_setup_new_description" msgid="256690722062003128">"TV\'nizin bir TV sinyal kaynağına bağlı olduğunu doğrulayın.\n\nHavadan yayın alan bir anten kullanıyorsanız en çok sayıda kanalı almak için antenin yerini veya yönünü ayarlamanız gerekebilir. En iyi sonucu elde etmek için anteni yüksek ve pencereye yakın bir yere yerleştirin."</string>
    <string name="ut_setup_new_description" msgid="2610122936163002137">"USB kanal ayarlayıcının takılı olduğunu ve bir TV sinyali kaynağına bağlandığını doğrulayın.\n\nHavadan yayın alan bir anten kullanıyorsanız en çok sayıda kanalı almak için antenin yerini veya yönünü ayarlamanız gerekebilir. En iyi sonucu elde etmek için anteni yüksek ve pencereye yakın bir yere yerleştirin."</string>
  <string-array name="ut_setup_new_choices">
    <item msgid="8728069574888601683">"Devam"</item>
    <item msgid="727245208787621142">"Şimdi değil"</item>
  </string-array>
    <string name="bt_setup_again_title" msgid="884713873101099572">"Kanal kurulumu yeniden çalıştırılsın mı?"</string>
    <string name="bt_setup_again_description" msgid="1247792492948741337">"Bu işlem, TV kanal ayarlayıcının bulduğu kanalları kaldıracak ve tekrar yeni kanallar arayacak.\n\nTV\'nizin bir TV sinyal kaynağına bağlı olduğunu doğrulayın.\n\nHavadan yayın alan bir anten kullanıyorsanız en çok sayıda kanalı almak için antenin yerini veya yönünü ayarlamanız gerekebilir. En iyi sonucu elde etmek için anteni yüksek ve pencereye yakın bir yere yerleştirin."</string>
    <string name="ut_setup_again_description" msgid="7837706010887799255">"Bu işlem, USB kanal ayarlayıcıdan bulunan kanalları kaldıracak ve yeni kanallar için tekrar tarama yapacaktır.\n\nUSB kanal ayarlayıcının takılı olduğunu ve bir TV sinyali kaynağına bağlandığını doğrulayın.\n\nHavadan yayın alan bir anten kullanıyorsanız en çok sayıda kanalı almak için antenin yerini veya yönünü ayarlamanız gerekebilir. En iyi sonucu elde etmek için anteni yüksek ve pencereye yakın bir yere yerleştirin."</string>
  <string-array name="ut_setup_again_choices">
    <item msgid="2557527790311851317">"Devam"</item>
    <item msgid="235450158666155406">"İptal"</item>
  </string-array>
    <string name="ut_connection_title" msgid="8435949189164677545">"Bağlantı türünü seçin"</string>
    <string name="ut_connection_description" msgid="7234582943233286192">"Kanal ayarlayıcıya bağlı harici bir anteniniz varsa Anten\'i seçin. Kanallarınız bir kablolu yayın hizmeti sağlayıcısından geliyorsa Kablolu\'yu seçin. Emin değilseniz her iki tür de taranacaktır, ancak işlem daha uzun sürebilir."</string>
  <string-array name="ut_connection_choices">
    <item msgid="1499878461856892555">"Anten"</item>
    <item msgid="2670079958754180142">"Kablolu"</item>
    <item msgid="36774059871728525">"Emin değilim"</item>
    <item msgid="6881204453182153978">"Yalnızca geliştirme"</item>
  </string-array>
    <string name="bt_channel_scan" msgid="3291924771702347469">"TV kanal ayarlayıcı kurulumu"</string>
    <string name="ut_channel_scan" msgid="6100090671500464604">"USB kanal ayarlayıcı kurulumu"</string>
    <string name="ut_channel_scan_time" msgid="1844845425359642393">"Bu işlem birkaç dakika sürebilir"</string>
    <string name="ut_channel_scan_tuner_unavailable" msgid="3135723754380409658">"Kanal ayarlayıcı geçici olarak kullanılamıyor veya şu anda kayıt yapmak için kullanılıyor."</string>
    <plurals name="ut_channel_scan_message" formatted="false" msgid="3131606783282632056">
      <item quantity="other">%1$d kanal bulundu</item>
      <item quantity="one">%1$d kanal bulundu</item>
    </plurals>
    <string name="ut_stop_channel_scan" msgid="566811986747774193">"KANAL TARAMASINI DURDUR"</string>
    <plurals name="ut_result_found_title" formatted="false" msgid="1448908152026339099">
      <item quantity="other">%1$d kanal bulundu</item>
      <item quantity="one">%1$d kanal bulundu</item>
    </plurals>
    <plurals name="ut_result_found_description" formatted="false" msgid="4132691388395648565">
      <item quantity="other">Başarılı! Kanal tarama sırasında %1$d kanal bulundu. Bu sonuç doğru görünmüyorsa antenin konumunu ayarlayıp tekrar taramayı deneyin.</item>
      <item quantity="one">Başarılı! Kanal tarama sırasında %1$d kanal bulundu. Bu sonuç doğru görünmüyorsa antenin konumunu ayarlayıp tekrar taramayı deneyin.</item>
    </plurals>
  <string-array name="ut_result_found_choices">
    <item msgid="3220617441427115421">"Bitti"</item>
    <item msgid="2480490326672924828">"Yeniden tara"</item>
  </string-array>
    <string name="ut_result_not_found_title" msgid="4649533929056795595">"Hiçbir kanal bulunamadı"</string>
    <string name="bt_result_not_found_description" msgid="7378208337325024042">"Tarama işleminde hiçbir kanal bulunamadı. TV\'nizin bir TV sinyal kaynağına bağlı olduğunu doğrulayın.\n\nHavadan yayın alan bir anten kullanıyorsanız yerini veya yönünü ayarlayın. En iyi sonucu elde etmek için anteni yüksek ve pencereye yakın bir yere yerleştirerek tekrar tarayın."</string>
    <string name="ut_result_not_found_description" msgid="1080746285957681414">"Tarama işlemi herhangi bir kanal bulamadı. USB kanal ayarlayıcının takılı olduğunu ve bir TV sinyali kaynağına bağlandığını doğrulayın.\n\nHavadan yayın alan bir anten kullanıyorsanız yerini veya yönünü ayarlayın. En iyi sonucu elde etmek için anteni yüksek ve pencereye yakın bir yere yerleştirerek tekrar tarayın."</string>
  <string-array name="ut_result_not_found_choices">
    <item msgid="5436884968471542030">"Yeniden tara"</item>
    <item msgid="2092797862490235174">"Bitti"</item>
  </string-array>
    <string name="ut_setup_recommendation_card_focused_title" msgid="7434151993964505386">"TV kanallarını tarayın"</string>
    <string name="bt_setup_recommendation_card_title" msgid="1026906771141769829">"TV Kanal Ayarlayıcı kurulumu"</string>
    <string name="ut_setup_recommendation_card_title" msgid="1093869817128338226">"USB TV Kanal Ayarlayıcı kurulumu"</string>
    <string name="msg_usb_device_detached" msgid="5123930566630230724">"USB TV kanal ayarlayıcı bağlantısı kesildi."</string>
</resources>
