<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 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="app_label" msgid="3658948994665187911">"İndirme Yöneticisi"</string>
    <string name="permlab_downloadManager" msgid="7779544811202855500">"İndirme yöneticisine eriş."</string>
    <string name="permdesc_downloadManager" msgid="4240298564918160337">"Uygulamaya indirme yöneticisine erişme ve bunu dosyaları indirmek için kullanma izni verir. Kötü amaçlı uygulamalar bunu indirme işlemlerini bozmak ve özel bilgilere erişmek için kullanabilir."</string>
    <string name="permlab_downloadManagerAdvanced" msgid="7103642833308809655">"Gelişmiş indirme yöneticisi işlevleri."</string>
    <string name="permdesc_downloadManagerAdvanced" msgid="6985743912436565114">"Uygulamaya indirme yöneticisinin gelişmiş işlevlerine erişme izni verir. Kötü niyetli uygulamalar, indirme işlemlerini bozmak ve özel bilgilere erişmek için bunu kullanabilir."</string>
    <string name="permlab_downloadCompletedIntent" msgid="945913803765675685">"İndirme bildirimleri gönder."</string>
    <string name="permdesc_downloadCompletedIntent" msgid="8672701687104399228">"Uygulamaya tamamlanan indirme işlemleri ile ilgili bildirimler gönderme izni verir. Kötü amaçlı uygulamalar bunu dosya indiren diğer uygulamaları yanıltmak için kullanabilir."</string>
    <string name="permlab_seeAllExternal" msgid="140058400609165726">"SD karta yapılan tüm indirmeleri gör"</string>
    <string name="permdesc_seeAllExternal" msgid="3298948060016417104">"Uygulamanın SD karta yapılan tüm indirmeleri, indirme işlemini yapan uygulamadan bağımsız olarak görmesine izin verir."</string>
    <string name="download_unknown_title" msgid="7015124071247271585">"&lt;Adsız&gt;"</string>
    <string name="notification_filename_separator" msgid="7147189522857807618">", "</string>
    <string name="notification_filename_extras" msgid="5549729917695688191">" ve <xliff:g id="NUMBER">%d</xliff:g> adet daha"</string>
    <string name="notification_download_complete" msgid="840713937779273632">"İndirme işlemi tamamlandı"</string>
    <string name="notification_download_failed" msgid="5343637375905111462">"İndirme işlemi başarısız"</string>
</resources>
