<?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">"Gestore dei download"</string>
    <string name="permlab_downloadManager" msgid="7779544811202855500">"Accedere al gestore dei download."</string>
    <string name="permdesc_downloadManager" msgid="4240298564918160337">"Consente l\'accesso dell\'applicazione al gestore dei download e il suo utilizzo per scaricare file. Le applicazioni dannose possono sfruttare questa possibilità per interrompere download e accedere a informazioni riservate."</string>
    <string name="permlab_downloadManagerAdvanced" msgid="7103642833308809655">"Funzioni avanzate del gestore dei download."</string>
    <string name="permdesc_downloadManagerAdvanced" msgid="6985743912436565114">"Consente l\'accesso dell\'applicazione alle funzioni avanzate del gestore dei download. Le applicazioni dannose possono sfruttare questa possibilità per interrompere download e accedere a informazioni riservate."</string>
    <string name="permlab_downloadCompletedIntent" msgid="945913803765675685">"Inviare notifiche di download."</string>
    <string name="permdesc_downloadCompletedIntent" msgid="8672701687104399228">"Consente l\'invio da parte dell\'applicazione di notifiche relative ai download completati. Le applicazioni dannose possono sfruttare questa possibilità per \"confondere\" altre applicazioni usate per scaricare file."</string>
    <string name="permlab_seeAllExternal" msgid="140058400609165726">"Visualizza tutti i download sulla scheda SD"</string>
    <string name="permdesc_seeAllExternal" msgid="3298948060016417104">"Consente all\'applicazione di visualizzare tutti i download sulla scheda SD, indipendentemente dall\'applicazione che li ha scaricati."</string>
    <!-- no translation found for permlab_downloadCacheNonPurgeable (3069534308882047412) -->
    <skip />
    <!-- no translation found for permdesc_downloadCacheNonPurgeable (1089583021652571424) -->
    <skip />
    <!-- no translation found for permlab_downloadWithoutNotification (3650349274034807567) -->
    <skip />
    <!-- no translation found for permdesc_downloadWithoutNotification (5174806530123417020) -->
    <skip />
    <string name="download_unknown_title" msgid="7015124071247271585">"&lt;Senza nome&gt;"</string>
    <string name="notification_filename_separator" msgid="7147189522857807618">", "</string>
    <string name="notification_filename_extras" msgid="5549729917695688191">" e <xliff:g id="NUMBER">%d</xliff:g> altri"</string>
    <string name="notification_download_complete" msgid="840713937779273632">"Download completato"</string>
    <string name="notification_download_failed" msgid="5343637375905111462">"Download non riuscito"</string>
</resources>
