cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [10/51] [abbrv] [partial] docs commit: added cordova 6.0.0 docs
Date Thu, 28 Jan 2016 18:10:47 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/it/6.0.0/guide/cli/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/6.0.0/guide/cli/index.md b/www/docs/it/6.0.0/guide/cli/index.md
new file mode 100644
index 0000000..02a5ace
--- /dev/null
+++ b/www/docs/it/6.0.0/guide/cli/index.md
@@ -0,0 +1,419 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+title: L'interfaccia della riga di comando
+---
+
+# L'interfaccia della riga di comando
+
+Questa guida viene illustrato come creare applicazioni e distribuirle in varie piattaforme mobile nativi utilizzando il `cordova` interfaccia della riga di comando (CLI). Questo strumento consente di creare nuovi progetti, costruirli su diverse piattaforme ed eseguire su dispositivi reali o all'interno di emulatori. Il CLI è lo strumento principale da utilizzare per il workflow cross-piattaforma descritto nella panoramica. Altrimenti è possibile utilizzare anche la CLI per inizializzare il codice del progetto, poi cambia platforms vari SDK e strumenti per il costante sviluppo di shell.
+
+## Prerequisiti
+
+Prima di eseguire eventuali strumenti da riga di comando, è necessario installare il SDK per ogni piattaforma che si desidera fare riferimento. (Vedi le guide di piattaforma per maggiori dettagli).
+
+Per aggiungere il supporto o ricostruire un progetto per qualsiasi piattaforma, è necessario eseguire l'interfaccia della riga di comando dalla stessa macchina che supporta SDK la piattaforma. CLI supporta le seguenti combinazioni:
+
+*   iOS (Mac)
+*   Amazon fuoco OS (Mac, Linux, Windows)
+*   Android (Mac, Linux, Windows)
+*   BlackBerry 10 (Mac, Linux, Windows)
+*   Windows Phone 8 (Windows)
+*   Windows (Windows)
+*   Firefox OS (Mac, Linux, Windows)
+
+Su Mac, la riga di comando è disponibile tramite l'applicazione *terminale* . Sul PC, è disponibile come *Prompt dei comandi* sotto *accessori*.
+
+**Nota**: per le piattaforme Windows-only, si può ancora fare vostro sviluppo hardware Mac eseguendo Windows in un ambiente di macchina virtuale o in modalità dual-boot. Per le opzioni disponibili, vedere la guida di Windows Phone 8 piattaforma o la guida di piattaforma di Windows.
+
+Il più probabile è che si esegue CLI da macchine diverse, più ha senso mantenere un repository di codice sorgente remota, la cui attività si tira per le directory di lavoro locale.
+
+## L'installazione di Cordova CLI
+
+Lo strumento della riga di comando di Cordova è distribuito come un pacchetto di npm in un formato pronto per l'uso. Non è necessario compilarlo dai sorgenti.
+
+Per installare il `cordova` della riga di comando strumento, attenersi alla seguente procedura:
+
+1.  Scaricare e installare [node. js][1]. Dopo l'installazione, si dovrebbe essere in grado di richiamare `node` e `npm` sulla riga di comando. Se lo si desidera, si può eventualmente utilizzare uno strumento come `nvm` o `nave` per gestire l'installazione di node. js.
+
+2.  Scaricare e installare un [client git][2], se non avete già uno. Dopo l'installazione, si dovrebbe essere in grado di richiamare `git` sulla riga di comando. Anche se serviro ' `git` manualmente, CLI usarlo dietro le quinte per scaricare alcuni attivi quando si crea un nuovo progetto.
+
+3.  Installare il `cordova` modulo utilizzando `npm` utilità di node. js. La `cordova` modulo verrà automaticamente scaricato dalla `npm` utilità.
+
+ [1]: http://nodejs.org/
+ [2]: http://git-scm.com/
+
+*   su OS X e Linux:
+    
+            $ sudo npm install -g cordova
+        
+    
+    Su OS X e Linux, precedono il `npm` comando con `sudo` può essere necessario installare questo sviluppo utilità nel limitato altrimenti le directory come `/usr/local/share` . Se si utilizza lo strumento opzionale nvm/navata o avere accesso in scrittura per la directory di installazione, è possibile omettere il `sudo` prefisso. Esistono [ulteriori suggerimenti][3] sull'utilizzo di `npm` senza `sudo` , se voglia di farlo.
+
+*   su Windows:
+    
+            C:\>npm install -g cordova
+        
+    
+    Il `-g` bandiera sopra dice `npm` installare `cordova` globalmente. In caso contrario verrà installato nella `node_modules` sottodirectory della directory di lavoro corrente.
+    
+    Potrebbe essere necessario aggiungere il `npm` nella directory tuo `PATH` per poter richiamare globalmente installata `npm` moduli. Su Windows, `npm` di solito può essere trovato alla `C:\Users\username\AppData\Roaming\npm` . Su OS X e Linux di solito può essere trovato presso`/usr/local/share/npm`.
+    
+    Il log di installazione può produrre errori per qualsiasi disinstallato platform SDK.
+    
+    Dopo l'installazione, si dovrebbe essere in grado di eseguire `cordova` sulla riga di comando con senza argomenti e si deve stampare il testo della guida.
+
+ [3]: http://justjs.com/posts/npm-link-developing-your-own-npm-modules-without-tears
+
+## Creare l'applicazione
+
+Andare nella directory dove si mantiene il codice sorgente ed eseguire un comando analogo al seguente:
+
+        $ cordova create hello com.example.hello HelloWorld
+    
+
+Esso può richiedere molto tempo per completare il comando, quindi siate pazienti. Esegue il comando con il `-d` opzione Visualizza informazioni sui suoi progressi.
+
+Il primo argomento *Ciao* specifica una directory ad essere generato per il progetto. Questa directory non dovrebbe già esistere, Cordova si creerà per voi. Sua `www` sottodirectory ospita la pagina iniziale dell'applicazione, insieme a diverse risorse sotto `css` , `js` , e `img` , che seguono le convenzioni di denominazione dei file del sviluppo web comuni. Queste attività verranno memorizzate su file system locale del dispositivo, non servito da remoto. La `config.xml` file contiene metadati importanti necessari per generare e distribuire l'applicazione.
+
+Il secondo argomento `com.example.hello` fornisce il tuo progetto con un identificatore di dominio-stile reverse. Questo argomento è facoltativo, ma solo se si omette anche il terzo argomento, poiché gli argomenti sono posizionali. È possibile modificare questo valore successivamente nella `config.xml` del file, ma essere consapevoli che ci può essere un codice generato di fuori di `config.xml` utilizzando questo valore, ad esempio nomi di pacchetto Java. Il valore predefinito è `io.cordova.hellocordova` , ma è consigliabile che si seleziona un valore appropriato.
+
+Il terzo argomento `HelloWorld` fornisce il titolo di visualizzazione dell'applicazione. Questo argomento è facoltativo. È possibile modificare questo valore successivamente nella `config.xml` del file, ma essere consapevoli che ci può essere un codice generato di fuori di `config.xml` utilizzando questo valore, ad esempio i nomi delle classi di Java. Il valore predefinito è `HelloCordova` , ma è consigliabile che si seleziona un valore appropriato.
+
+## Aggiungi piattaforme
+
+Tutti i comandi successivi devono essere eseguito all'interno della directory del progetto, o qualsiasi sottodirectory all'interno del proprio ambito:
+
+        $ cd hello
+    
+
+Per poter compilare il progetto, è necessario specificare un insieme di piattaforme di destinazione. La capacità di eseguire questi comandi dipende se la macchina supporta ogni SDK, e se avete già installato ogni SDK. Eseguire uno di questi da un Mac:
+
+        $ cordova platform add ios
+        $ cordova platform add amazon-fireos
+        $ cordova platform add android
+        $ cordova platform add blackberry10
+        $ cordova platform add firefoxos
+    
+
+Eseguire una qualsiasi di queste da una macchina Windows, dove *wp* si riferisce a diverse versioni del sistema operativo Windows Phone:
+
+        piattaforma di cordova $ aggiungere $ wp8 cordova piattaforma aggiungere windows piattaforma cordova $ aggiungere piattaforma di amazon-fireos $ cordova aggiungere $ android piattaforma cordova aggiungere $ blackberry10 cordova piattaforma aggiungere firefoxos
+    
+
+Eseguire questo per controllare il set corrente di piattaforme:
+
+        $ cordova platforms ls
+    
+
+(Nota del `platform` e `platforms` comandi sono sinonime.)
+
+Eseguire uno dei seguenti comandi per rimuovere una piattaforma sinonimi:
+
+        $ cordova platform remove blackberry10
+        $ cordova platform rm amazon-fireos
+        $ cordova platform rm android
+    
+
+Esecuzione di comandi per aggiungere o rimuovere colpisce piattaforme il contenuto della directory del progetto *piattaforme* , dove ogni piattaforma specificata appare come una sottodirectory. La directory di origine *www* è riprodotta all'interno di sottodirectory su ogni piattaforma, apparendo ad esempio `platforms/ios/www` o `platforms/android/assets/www` . Perché CLI costantemente copia i file dalla cartella sorgente *www* , è consigliabile modificare solo questi file e non quelli situati sotto le sottodirectory di *piattaforme* . Se si utilizza il software di controllo versione, è necessario aggiungere questa cartella *www* di origine, insieme con la cartella *si fonde* , al sistema di controllo di versione. (Ulteriori informazioni sulla cartella *si fonde* possono essere trovati nella sezione Personalizza ogni piattaforma sottostante).
+
+**AVVERTENZA**: quando si utilizza la CLI per compilare l'applicazione, è necessario *non* modificare qualsiasi file nella `/platforms/` directory se non sai cosa stai facendo, o se la documentazione specifica altrimenti. I file in questa directory sono ordinariamente sovrascritto quando preparare le applicazioni per la costruzione, o quando vengono reinstallati plugins.
+
+Se volete a questo punto, è possibile utilizzare un SDK come Eclipse o Xcode per aprire il progetto creato. Devi aprire il set derivato dei beni dalla `/platforms/` directory per sviluppare con un SDK. Questo è perché sono archiviati i file di metadati specifici SDK all'interno l'appropriato `/platform/` sottodirectory. (Vedi le guide di piattaforma per informazioni su come sviluppare applicazioni all'interno di ogni IDE). Utilizzare questo approccio se si desidera semplicemente inizializzare un progetto utilizzando la CLI e poi passare a un SDK per lavoro nativo.
+
+Leggere se si desidera utilizzare l'approccio del flusso di lavoro multi-piattaforma (CLI) per il ciclo di sviluppo intero.
+
+## Costruire l'App
+
+Per impostazione predefinita, il `cordova create` script genera una scheletrica applicazione web-based in cui home page è il progetto `www/index.html` file. Modificare questa applicazione, tuttavia si desidera, ma qualsiasi inizializzazione deve essere specificato come parte della `[deviceready](../../cordova/events/events.deviceready.html)` gestore di eventi, a cui fa riferimento predefinito da`www/js/index.js`.
+
+Eseguire il comando seguente per costruire in modo iterativo del progetto:
+
+        $ cordova build
+    
+
+Questo genera il codice specifico della piattaforma nell'ambito del progetto `platforms` sottodirectory. Facoltativamente, è possibile limitare l'ambito della compilazione per specifiche piattaforme:
+
+        $ cordova build ios
+    
+
+Il `cordova build` comando è una forma abbreviata per i seguenti, che in questo esempio si rivolge anche a una singola piattaforma:
+
+        $ cordova prepare ios
+        $ cordova compile ios
+    
+
+In questo caso, una volta si esegue `prepare` , è possibile utilizzare Apple Xcode SDK come alternativa per modificare e compilare il codice specifico della piattaforma Cordova generato all'interno di `platforms/ios` . È possibile utilizzare lo stesso approccio con SDK altre platforms.
+
+## Testare l'applicazione su un emulatore o un dispositivo
+
+SDK per piattaforme mobili, spesso in bundle con emulatori che eseguire un'immagine del dispositivo, in modo che è possibile lanciare l'applicazione dalla schermata iniziale e vedere come esso interagisce con molte caratteristiche di piattaforma. Eseguire un comando come ad esempio il seguente per ricostruire l'app e si mostra all'interno dell'emulatore su una piattaforma specifica:
+
+        $ cordova emulate android
+    
+
+Alcune piattaforme mobili emulano un particolare dispositivo per impostazione predefinita, come l'iPhone per i progetti di iOS. Per altre piattaforme, è necessario prima di associare un dispositivo con un emulatore.
+
+**Nota**: supporto emulatore non è attualmente disponibile per OS di fuoco di Amazon.
+
+(Vedi le guide di piattaforma per dettagli). Ad esempio, si può in primo luogo eseguire il `android` comando per lanciare il SDK di Android, quindi eseguire un'immagine particolare dispositivo, che lancia il secondo il comportamento predefinito:
+
+![][4]
+
+ [4]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_init.png
+
+Seguente in su con il `cordova emulate` comando aggiorna l'immagine di emulatore per visualizzare l'applicazione più recente, che è ora disponibile per il lancio dalla schermata iniziale:
+
+![][5]
+
+ [5]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_install.png
+
+Alternativamente, è possibile collegare il telefono al computer e testare le app direttamente:
+
+        $ cordova run android
+    
+
+Prima di eseguire questo comando, è necessario impostare il dispositivo per la prova, seguendo procedure che variano per ogni piattaforma. Nei dispositivi Android e Amazon fuoco OS, dovete abilitare un'opzione di **debug USB** sul dispositivo e magari aggiungere un driver USB a seconda del vostro sviluppo di Francia. Vedere piattaforma guide per informazioni dettagliate sui requisiti di ogni piattaforma.
+
+## Aggiungere funzionalità di Plugin
+
+Quando si compila e Mostra un nuovo progetto, l'applicazione predefinita che appare non fa molto molto. È possibile modificare l'applicazione in molti modi per sfruttare tecnologie web standard, ma per le app comunicare strettamente con varie funzionalità a livello di dispositivo, è necessario aggiungere plugins che forniscono accesso al nucleo Cordova APIs.
+
+Un *plugin* è un po ' di codice del componente aggiuntivo che fornisce un'interfaccia per i componenti nativi. È possibile progettare la propria interfaccia plugin, per esempio, quando si progetta un'applicazione ibrida che mescola una Cordova WebView con componenti nativi. (Vedere visualizzazioni Web Embedding e [Guida allo sviluppo di Plugin][6] per dettagli). Più comunemente, è necessario aggiungere un plugin per abilitare una delle caratteristiche fondamentali di Cordova dispositivo-livello dettagliati in riferimento all'API.
+
+ [6]: guide_hybrid_plugins_index.md.html#Plugin%20Development%20Guide
+
+A partire dalla versione 3.0, quando si crea un progetto di Cordova non ha alcun plugin presenti. Questo è il nuovo comportamento predefinito. Tutti i plugin che desideri, anche i plugin di nucleo, devono essere aggiunto in modo esplicito.
+
+Un elenco di questi plugin, tra cui il plugin aggiuntivi di terze parti fornito dalla Comunità, può essere trovato nel registro di sistema [plugins.cordova.io][7]. È possibile utilizzare la CLI per la ricerca di plugin da questo registro. Ad esempio, alla ricerca di `bar` e `code` produce un singolo risultato che corrisponde a entrambi i termini come minuscole sottostringhe:
+
+ [7]: http://plugins.cordova.io/
+
+        $ cordova plugin search bar code
+    
+        com.phonegap.plugins.barcodescanner - Scans Barcodes
+    
+
+Cercando solo il `bar` termine rendimenti e risultati aggiuntivi:
+
+        cordova-plugin-statusbar - Cordova StatusBar Plugin
+    
+
+Il `cordova plugin add` comando richiede di specificare il repository per il codice del plugin. Ecco alcuni esempi di come si potrebbe utilizzare la CLI per aggiungere funzionalità per l'app:
+
+*   Informazioni di base del dispositivo (dispositivo API):
+    
+        $ cordova plugin add cordova-plugin-device
+        
+
+*   Connessione di rete e batteria eventi:
+    
+        $ cordova plugin add cordova-plugin-network-information
+        $ cordova plugin add cordova-plugin-battery-status
+        
+
+*   Accelerometro, bussola e geolocalizzazione:
+    
+        $ cordova plugin add cordova-plugin-device-motion
+        $ cordova plugin add cordova-plugin-device-orientation
+        $ cordova plugin add cordova-plugin-geolocation
+        
+
+*   Macchina fotografica, la riproduzione multimediale e cattura:
+    
+        $ cordova plugin add cordova-plugin-camera
+        $ cordova plugin add cordova-plugin-media-capture
+        $ cordova plugin add cordova-plugin-media
+        
+
+*   Accedere ai file sul dispositivo o rete (File API):
+    
+        $ cordova plugin add cordova-plugin-file
+        $ cordova plugin add cordova-plugin-file-transfer
+        
+
+*   Notifica tramite la finestra di dialogo o vibrazione:
+    
+        $ cordova plugin add cordova-plugin-dialogs
+        $ cordova plugin add cordova-plugin-vibration
+        
+
+*   Contatti:
+    
+        $ cordova plugin add cordova-plugin-contacts
+        
+
+*   Globalizzazione:
+    
+        $ cordova plugin add cordova-plugin-globalization
+        
+
+*   Splashscreen:
+    
+        $ cordova plugin add cordova-plugin-splashscreen
+        
+
+*   Finestre aperte del browser nuovo (InAppBrowser):
+    
+        $ cordova plugin add cordova-plugin-inappbrowser
+        
+
+*   Console di debug:
+    
+        $ cordova plugin add cordova-plugin-console
+        
+
+**Nota**: il CLI aggiunge codice plugin come appropriato per ogni piattaforma. Se si desidera sviluppare con strumenti di basso livello shell o platform SDK, come discusso nella panoramica, è necessario eseguire l'utilità di Plugman per aggiungere plugin separatamente per ogni piattaforma. (Per ulteriori informazioni, vedere utilizzando Plugman per gestire i plugin).
+
+Uso `plugin ls` (o `plugin list` , o `plugin` da sola) alla Mostra attualmente installato il plugin. Ognuno viene visualizzato tramite il relativo identificatore:
+
+        $ cordova plugin ls    # or 'plugin list'
+        [ 'cordova-plugin-console' ]
+    
+
+Per rimuovere un plugin, si riferiscono ad esso dall'identificatore stesso che compare nell'elenco. Ad esempio, ecco come si vuoi rimuovere il supporto per una console di debug da una versione di rilascio:
+
+        $ cordova plugin rm cordova-plugin-console
+        $ cordova plugin remove cordova-plugin-console    # same
+    
+
+È possibile rimuovere-lotto o aggiungere plugins specificando più argomenti per ogni comando:
+
+        $ cordova plugin add cordova-plugin-console cordova-plugin-device
+    
+
+## Opzioni avanzate del Plugin
+
+Quando si aggiunge un plugin, diverse opzioni consentono di specificare da dove scaricare il plugin. Gli esempi sopra utilizzano un noto `registry.cordova.io` Registro di sistema e il plugin è specificato dal `id` :
+
+        $ cordova plugin add cordova-plugin-console
+    
+
+Il `id` può anche includere il numero di versione del plugin, dopo un `@` personaggio. Il `latest` versione è un alias per la versione più recente. Ad esempio:
+
+        $ cordova plugin add cordova-plugin-console@latest
+        $ cordova plugin add cordova-plugin-console@0.2.1
+    
+
+Se il plugin non è registrato presso `registry.cordova.io` , ma si trova in un altro repository git, è possibile specificare un URL alternativo:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git
+    
+
+Git esempio precedente recupera il plugin dalla fine del ramo principale, ma può essere aggiunto un git-rif alternativo come ad esempio un tag o ramo dopo un `#` personaggio:
+
+Installare da un tag:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#r0.2.0
+    
+
+o un ramo:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#CB-8438cordova-plugin-console
+    
+
+o git-ref potrebbe essere anche un particolare commit:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#f055daec45575bf08538f885e09c85a0eba363ff
+    
+
+Se il plugin (e la sua `plugin.xml` file) è in una sottodirectory all'interno il repo git, è possibile specificare con un `:` personaggio. Si noti che il `#` è ancora necessario il carattere:
+
+        $ cordova plugin add https://github.com/someone/aplugin.git#:/my/sub/dir
+    
+
+È inoltre possibile combinare il git-ref sia nella sottodirectory:
+
+        $ cordova plugin add https://github.com/someone/aplugin.git#r0.0.1:/my/sub/dir
+    
+
+In alternativa, specificare un percorso locale per la directory dei plugin che contiene il `plugin.xml` file:
+
+        $ cordova plugin add ../my_plugin_dir
+    
+
+## Utilizzando *si fonde* a personalizzare ogni piattaforma
+
+Mentre Cordova consente di distribuire con facilità un'app per molte piattaforme diverse, a volte è necessario aggiungere le personalizzazioni. In tal caso, non volete modificare i file di origine in vari `www` Directory all'interno di primo livello `platforms` directory, perché stai regolarmente sostituiti con il primo livello `www` origine multipiattaforma di directory.
+
+Invece, il primo livello `merges` directory offre un posto per specificare attività per la distribuzione su piattaforme specifiche. Ogni sottodirectory specifiche della piattaforma all'interno `merges` riflette la struttura di directory della `www` struttura di origine, consentendo di eseguire l'override o aggiungere i file desiderati. Ad esempio, ecco come si potrebbero usi `merges` per aumentare la dimensione del carattere predefinita per dispositivi Android e Amazon fuoco OS:
+
+*   Modificare il `www/index.html` file, aggiungendo un link al file CSS aggiuntivo, `overrides.css` in questo caso:
+    
+        <link rel="stylesheet" type="text/css" href="css/overrides.css" />
+        
+
+*   Se si desidera creare un vuoto `www/css/overrides.css` file che vuoi applicare per tutte le build di Android non, impedendo un errore del file mancante.
+
+*   Creare un `css` sottodirectory all'interno di `merges/android` , quindi aggiungere un corrispondente `overrides.css` file. Specificare CSS che esegue l'override la dimensione del carattere di 12 punti predefiniti specificata all'interno di `www/css/index.css` , ad esempio:
+    
+        body { font-size:14px; }
+        
+
+Quando si rigenera il progetto, la versione per Android offre la dimensione di carattere personalizzato, mentre gli altri rimangono invariati.
+
+È inoltre possibile utilizzare `merges` per aggiungere file non presenti nell'originale `www` directory. Ad esempio, un'app può incorporare un grafico *pulsante indietro* nell'interfaccia di iOS, memorizzati `merges/ios/img/back_button.png` , mentre invece la versione di Android è in grado di catturare `[backbutton](../../cordova/events/events.backbutton.html)` eventi dal corrispondente pulsante hardware.
+
+## Aiuto comandi
+
+Cordova dispone di un paio di comandi globali, che possono aiutarti se rimani bloccato o si verifichi un problema. Il `help` comando consente di visualizzare tutti i comandi disponibili di Cordova e la loro sintassi:
+
+    $ cordova help
+    $ cordova        # same
+    
+
+Inoltre, è possibile ottenere informazioni più dettagliate su un comando specifico. Per esempio:
+
+    $ cordova run --help
+    
+
+Il `info` comando produce un elenco di dettagli potenzialmente utili, quali piattaforme attualmente installate e plugin, versioni SDK per ogni piattaforma e versioni di CLI e `node.js` :
+
+    $ cordova info
+    
+
+Esso presenta le informazioni a schermo sia acquisisce l'output in un locale `info.txt` file.
+
+**Nota**: attualmente, solo dettagli sulle piattaforme iOS e Android sono disponibili.
+
+## Aggiornamento di Cordova e progetto
+
+Dopo aver installato il `cordova` Utilità, si può sempre aggiornare all'ultima versione eseguendo il seguente comando:
+
+        $ sudo npm update -g cordova
+    
+
+Per installare una versione specifica, utilizzare questa sintassi:
+
+        $ sudo npm install -g cordova@3.1.0-0.2.0
+    
+
+Eseguire `cordova -v` per vedere quale versione è attualmente in esecuzione. Eseguire il `npm
+info` comando per un elenco più lungo che include la versione corrente insieme ad altri numeri di versione disponibile:
+
+        $ npm info cordova
+    
+
+3.0 di Cordova è la prima versione a supportare l'interfaccia della riga di comando descritta in questa sezione. Se si sta aggiornando da una versione precedente alla 3.0, è necessario creare un nuovo progetto, come descritto sopra, quindi copiare risorse dell'applicazione più anziani nel primo livello `www` directory. Se del caso, ulteriori dettagli sull'aggiornamento a 3.0 sono disponibili nelle guide piattaforma. Una volta che decidete di acquistare il `cordova` interfaccia riga di comando e uso `npm update` per rimanere attuale, la più lunghe procedure ivi descritte non sono più rilevanti.
+
+Cordova 3.0 + potrebbe richiedere ancora varie modifiche alle strutture di directory a livello di progetto e altre dipendenze. Dopo aver eseguito il `npm` comando sopra per aggiornare Cordova stesso, potrebbe essere necessario garantire le risorse del progetto sono conformi ai requisiti della versione più recente. Eseguire un comando simile al seguente per ogni piattaforma che si sta costruendo:
+
+        $ cordova platform update android
+        $ cordova platform update ios
+        ...etc.

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/it/6.0.0/guide/hybrid/plugins/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/6.0.0/guide/hybrid/plugins/index.md b/www/docs/it/6.0.0/guide/hybrid/plugins/index.md
new file mode 100644
index 0000000..4f23c89
--- /dev/null
+++ b/www/docs/it/6.0.0/guide/hybrid/plugins/index.md
@@ -0,0 +1,177 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+title: Guida allo sviluppo di plugin
+---
+
+# Guida allo sviluppo di plugin
+
+Un *plugin* è un pacchetto di codice inserito che permette di Cordova webview entro il quale l'applicazione esegue il rendering per comunicare con la piattaforma nativa su cui viene eseguito. Plugin forniscono accesso alla funzionalità di piattaforma e dispositivo ordinariamente non disponibile per le applicazioni basate su web. Tutte le principali caratteristiche di Cordova API vengono implementate come plugin, e molti altri sono disponibili che abilitare funzioni quali scanner di codice a barre, comunicazione NFC, o calendario di adattare le interfacce. C'è un [Registro][1] di plugin disponibili.
+
+ [1]: http://plugins.cordova.io
+
+Plugin comprendono una singola interfaccia JavaScript corrispondenti librerie di codice nativo per ogni piattaforma supportata. In sostanza questo nasconde le varie implementazioni di codice nativo dietro un'interfaccia comune di JavaScript.
+
+Questa sezione a pochi passi attraverso un plugin semplice *eco* che passa una stringa da JavaScript alla piattaforma nativa e ritorno, uno che è possibile utilizzare come modello per costruire funzioni molto più complesse. Questa sezione discute la struttura di base del plugin e l'interfaccia JavaScript rivolte. Per ogni interfaccia nativa corrispondente, vedere l'elenco alla fine di questa sezione.
+
+Oltre a queste istruzioni, quando si appresta a scrivere un plugin che è meglio guardare oltre [esistenti plugin][2] per l'orientamento.
+
+ [2]: http://cordova.apache.org/#contribute
+
+## Costruzione di un Plugin
+
+Gli sviluppatori di applicazioni utilizzano il CLI `plugin add` comando (discusso in The Command-Line Interface) per applicare un plugin per un progetto. L'argomento che il comando è l'URL di un repository *git* , contenente il codice del plugin. Questo esempio implementa l'API di Device di Cordova:
+
+        $ cordova plugin add https://git-wip-us.apache.org/repos/asf/cordova-plugin-device.git
+    
+
+Il repository dei plugin deve dispongono di un livello superiore `plugin.xml` file manifesto. Ci sono molti modi per configurare questo file, per cui i dettagli sono disponibili nella specifica del Plugin. Questa versione abbreviata della `Device` plugin fornisce un esempio semplice da utilizzare come modello:
+
+        <?xml version="1.0" encoding="UTF-8"?>
+        <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+                id="cordova-plugin-device" version="0.2.3">
+            <name>Device</name>
+            <description>Cordova Device Plugin</description>
+            <license>Apache 2.0</license>
+            <keywords>cordova,device</keywords>
+            <js-module src="www/device.js" name="device">
+                <clobbers target="device" />
+            </js-module>
+            <platform name="ios">
+                <config-file target="config.xml" parent="/*">
+                    <feature name="Device">
+                        <param name="ios-package" value="CDVDevice"/>
+                    </feature>
+                </config-file>
+                <header-file src="src/ios/CDVDevice.h" />
+                <source-file src="src/ios/CDVDevice.m" />
+            </platform>
+        </plugin>
+    
+
+Il primo livello `plugin` tag `id` attributo utilizza lo stesso formato di retromarcia-dominio per identificare il pacchetto plugin aggiunti i apps per essi. Il `js-module` tag specifica il percorso del comune interfaccia JavaScript. Il `platform` tag specifica un insieme corrispondente di codice nativo, per il `ios` piattaforma in questo caso. Il `config-file` tag incapsula un `feature` tag che viene iniettato nella piattaforma-specifiche `config.xml` file a sensibilizzare la piattaforma della libreria di codice aggiuntivo. Il `header-file` e `source-file` tag specificare il percorso al file di libreria componenti.
+
+## Convalidando un Plugin
+
+È possibile utilizzare il `plugman` utility per verificare se il plugin si installa correttamente per ogni piattaforma. Installare `plugman` con il seguente comando di [nodo][3] :
+
+ [3]: http://nodejs.org/
+
+        $ npm install -g plugman
+    
+
+Hai bisogno di una directory di origine valido app, ad esempio il primo livello `www` directory incluso in un progetto generato da CLI predefinito come descritto in l'interfaccia della riga di comando. Assicurarsi che l'app `index.html` home page di riferimento al nome dell'interfaccia del plugin JavaScript come se fossero nella stessa directory dei sorgenti:
+
+        <script src="myplugin.js"></script>
+    
+
+Quindi eseguire un comando simile al seguente per verificare se le dipendenze iOS carica correttamente:
+
+         $ plugman install --platform ios --project /path/to/my/project/www --plugin /path/to/my/plugin
+    
+
+Per maggiori dettagli su `plugman` opzioni, vedere utilizzando Plugman per gestire i plugin. Per informazioni su come effettivamente plugin *debug* , vedere l'interfaccia nativa su ogni piattaforma, elencato in fondo a questa pagina.
+
+## L'interfaccia JavaScript
+
+Il JavaScript fornisce l'interfaccia frontale, che lo rende forse la parte più importante del plugin. Si può strutturare JavaScript del vostro plugin comunque piace, ma è necessario chiamare `cordova.exec` per comunicare con la piattaforma nativa, utilizzando la seguente sintassi:
+
+        cordova.exec(function(winParam) {},
+                     function(error) {},
+                     "service",
+                     "action",
+                     ["firstArgument", "secondArgument", 42, false]);
+    
+
+Ecco come funziona ogni parametro:
+
+*   `function(winParam) {}`: Funzione di callback un successo. Supponendo che il `exec` chiamata viene completata correttamente, questa funzione viene eseguita insieme a tutti i parametri si passa ad esso.
+
+*   `function(error) {}`: Funzione di callback un errore. Se l'operazione non viene completata correttamente, questa funzione viene eseguita con un parametro facoltativo errore.
+
+*   `"service"`: Il nome del servizio chiamare il lato nativo. Ciò corrisponde ad una classe nativa, per cui ulteriori informazioni sono disponibili nelle guide native elencate di seguito.
+
+*   `"action"`: Il nome dell'azione per chiamare sul lato nativo. Generalmente corrisponde al metodo classe nativa. Vedere le guide native elencate di seguito.
+
+*   `[/* arguments */]`: Una matrice di argomenti da passare nell'ambiente nativo.
+
+## Esempio JavaScript
+
+In questo esempio viene illustrato un modo per implementare l'interfaccia JavaScript del plugin:
+
+        window.echo = function(str, callback) {
+            cordova.exec(callback, function(err) {
+                callback('Nothing to echo.');
+            }, "Echo", "echo", [str]);
+        };
+    
+
+In questo esempio, il plugin si attacca per la `window` object come la `echo` funzione che gli utenti plugin chiamerebbe come segue:
+
+        window.echo("echome", function(echoValue) {
+            alert(echoValue == "echome"); // should alert true.
+        });
+    
+
+Guardate gli ultimi tre argomenti per la `cordova.exec` funzione. Il primo chiama la `Echo` *servizio*, un nome di classe. Le richieste seconda la `echo` *azione*, un metodo all'interno di tale classe. La terza è una matrice di argomenti contenenti la stringa di eco, che è la `window.echo` funzione di primo parametro.
+
+Il callback di successo passati in `exec` è semplicemente un riferimento alla funzione di callback `window.echo` prende. Se la piattaforma nativa viene generato il callback di errore, semplicemente chiama il callback di successo e si passa una stringa predefinita.
+
+## Interfacce native
+
+Una volta definito per il plugin JavaScript, è necessario integrarla con almeno un'implementazione nativa. Di seguito sono elencati i dettagli per ogni piattaforma, e ciascuno si basa sul semplice esempio Echo Plugin precedente:
+
+*   [Amazon fuoco OS Plugins](../../platforms/amazonfireos/plugin.html)
+*   [Plugin Android](../../platforms/android/plugin.html)
+*   [iOS Plugins](../../platforms/ios/plugin.html)
+*   [BlackBerry 10 plugin](../../platforms/blackberry10/plugin.html)
+*   [Windows Phone 8 plugin](../../platforms/wp8/plugin.html)
+*   [Plugin di Windows](../../platforms/win8/plugin.html)
+
+La piattaforma di Tizen non supporta plugin.
+
+## Editrice Plugins
+
+Una volta che si sviluppa il tuo plugin, puoi pubblicare e condividere con la Comunità. È possibile pubblicare il tuo plugin in qualsiasi `npmjs` -base del registro di sistema, ma quella consigliata è il [Registro di sistema NPM][4]. Si prega di leggere il nostro [plugin editrice npm guida][5].
+
+ [4]: https://www.npmjs.com
+ [5]: http://plugins.cordova.io/npm/developers.html
+
+**Nota**: [Registro dei plugin di Cordova][6] si sta muovendo per uno stato di sola lettura. `publish`/ `unpublish` i comandi sono stati rimossi dal `plugman` , quindi avrete bisogno di utilizzare la corrispondente `npm` comandi.
+
+ [6]: https://plugins.cordova.io
+
+Altri sviluppatori possono installare il plugin automaticamente utilizzando uno `plugman` o Cordova CLI. (Per informazioni dettagliate su ciascun percorso di sviluppo, vedere utilizzando Plugman per gestire i plugin e The Command-Line Interface).
+
+Per pubblicare un plugin del registro di sistema NPM che è necessario seguire la procedura riportata di seguito:
+
+*   creare `package.json` file per il vostro plugin:
+    
+        $ plugman createpackagejson /path/to/your/plugin
+        
+
+*   pubblicarlo:
+    
+        $ npm adduser # that is if you don't have an account yet
+        $ npm publish /path/to/your/plugin
+        
+
+Questo è tutto!
+
+Esecuzione `plugman --help` elenca altri comandi disponibili basati sui registri.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/it/6.0.0/guide/hybrid/webviews/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/6.0.0/guide/hybrid/webviews/index.md b/www/docs/it/6.0.0/guide/hybrid/webviews/index.md
new file mode 100644
index 0000000..7212950
--- /dev/null
+++ b/www/docs/it/6.0.0/guide/hybrid/webviews/index.md
@@ -0,0 +1,32 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+title: Incorporamento visualizzazioni Web
+---
+
+# Incorporamento visualizzazioni Web
+
+Applicazioni di Cordova sono ordinariamente implementate come un browser-basato *WebView* all'interno della piattaforma mobile nativa. In questa sezione viene illustrato come, per sostenere piattaforme, per creare il tuo WebView componenti che fare pieno uso di Cordova APIs. È quindi possibile distribuire questi componenti di applicazione Cordova assieme componenti nativi in un'applicazione ibrida.
+
+Per distribuire un WebView, è necessario avere familiarità con ogni ambiente di programmazione nativo. Di seguito vengono fornite le istruzioni per piattaforme supportate:
+
+*   [Amazon fuoco OS visualizzazioni Web](../../platforms/amazonfireos/webview.html)
+*   [Visualizzazioni Web Android](../../platforms/android/webview.html)
+*   [iOS visualizzazioni Web](../../platforms/ios/webview.html)
+*   [Windows Phone visualizzazioni 8,0 Web](../../platforms/wp8/webview.html)
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/it/6.0.0/guide/next/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/6.0.0/guide/next/index.md b/www/docs/it/6.0.0/guide/next/index.md
new file mode 100644
index 0000000..c979316
--- /dev/null
+++ b/www/docs/it/6.0.0/guide/next/index.md
@@ -0,0 +1,258 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+title: Prossimi passi
+---
+
+# Prossimi passi
+
+Per gli sviluppatori che hanno una comprensione di come usare la CLI di Cordova e fare uso di plugin, ci sono alcune cose che si possono prendere in considerazione ricercando accanto a costruire meglio, più performante Cordova applicazioni. Il seguente documento offre consulenza su vari argomenti inerenti alle migliori pratiche, test, aggiornamenti e altri argomenti, ma non vuol essere prescrittiva. Considerare questo tuo punto di lancio per la tua crescita come uno sviluppatore di Cordova. Inoltre, se vedete qualcosa che può essere migliorato, si prega di [contribuire][1]!
+
+ [1]: http://cordova.apache.org/#contribute
+
+Questa guida contiene i seguenti argomenti:
+
+*   Consigliate
+*   Gestione degli aggiornamenti
+*   Test di applicazioni di Cordova
+*   Debug delle applicazioni di Cordova
+*   Interfaccia utente
+*   Considerazioni speciali
+*   Tenere il passo
+*   Come ottenere aiuto 
+
+# Sviluppo di app migliore pratiche Cordova
+
+## 1) SPA è tuo amico
+
+Innanzitutto - applicazioni Cordova dovrebbero adottare il design SPA (pagina singola applicazione). Vagamente definito, un centro benessere è un'applicazione lato client che viene eseguita da una richiesta di una pagina web. L'utente carica una serie iniziale di risorse (HTML, CSS e JavaScript) e ulteriori aggiornamenti (mostrando una nuova vista, caricamento dei dati) è fatto tramite AJAX. Terme sono comunemente usati per applicazioni più complesse sul lato client. GMail è un grande esempio di questo. Dopo il caricamento di GMail, posta visualizzazioni, editing e organizzazione sono tutti fatti aggiornando il DOM invece effettivamente lasciare la pagina corrente per caricare uno completamente nuovo.
+
+Utilizzando una SPA può aiutare a organizzare la tua applicazione in maniera più efficiente, ma ha anche vantaggi specifici per applicazioni di Cordova. Un'applicazione di Cordova deve attendere l'evento di [deviceready](../../cordova/events/events.deviceready.html) al fuoco prima di qualsiasi plugin può essere utilizzato. Se non si utilizza una SPA e l'utente fa clic per passare da una pagina a altra, si dovrà aspettare per [deviceready](../../cordova/events/events.deviceready.html) al fuoco ancora prima di fare uso di un plugin. Questo è facile dimenticare come l'applicazione diventa più grande.
+
+Anche se non si desidera utilizzare Cordova, creando un'applicazione mobile senza utilizzare un'architettura a singola pagina avrà implicazioni gravi prestazioni. Questo è perché navigare tra le pagine richiedono script, beni, ecc., per essere ricaricato. Anche se questi beni vengono memorizzati nella cache, ci saranno ancora problemi di prestazioni.
+
+Esempi di librerie SPA che è possibile utilizzare nelle vostre applicazioni di Cordova sono:
+
+*   [AngularJS][2]
+*   [EmberJS][3]
+*   [Spina dorsale][4]
+*   [Kendo UI][5]
+*   [Monaca][6]
+*   [ReactJS][7]
+*   [Sencha Touch][8]
+*   [jQuery Mobile][9]
+
+ [2]: http://angularjs.org
+ [3]: http://emberjs.com
+ [4]: http://backbonejs.org
+ [5]: http://www.telerik.com/kendo-ui
+ [6]: http://monaca.mobi/en/
+ [7]: http://facebook.github.io/react/
+ [8]: http://www.sencha.com/products/touch/
+ [9]: http://jquerymobile.com
+
+E molti, molti, altri.
+
+## 2) considerazioni sulle prestazioni
+
+Uno dei più grandi errori che può fare un nuovo sviluppatore di Cordova è ritenere che le prestazioni che si ottengono su una macchina desktop sono lo stesso che riceveranno su un dispositivo mobile. Mentre i nostri dispositivi mobili hanno ottenuto più potente ogni anno, hanno ancora la potenza e le prestazioni di un desktop. I dispositivi mobili sono in genere molto meno RAM e una GPU che è ben lungi dal proprio desktop (o anche portatile) fratelli. Un elenco completo dei suggerimenti qui sarebbe troppo, ma qui ci sono alcune cose da tenere a mente (con un elenco di risorse più lungo alla fine per ulteriori ricerche).
+
+**Clicca versus Touch** - l'errore più grande e più semplice che si può fare è utilizzare gli eventi click. Mentre queste "funzionano" bene mobile, la maggior parte dei dispositivi impongono un ritardo 300ms su di loro al fine di distinguere tra un tocco e un tocco di "tenere" evento. Utilizzando `touchstart` , o `touchend` , si tradurrà in un drastico miglioramento - 300ms non suono piace molto, ma può tradursi in UI aggiornamenti a scatti e il comportamento. Si deve anche considerare il fatto che "toccare" gli eventi non sono supportati nei non-webkit browser, vedere [CanIUse][10]. Per fronteggiare queste limitazioni, è possibile checkout varie librerie come HandJS e Fastouch.
+
+ [10]: http://caniuse.com/#search=touch
+
+**Le transizioni CSS contro manipolazione del DOM** - utilizzando le transizioni CSS di accelerazione hardware sarà notevolmente migliore rispetto all'utilizzo di JavaScript per creare animazioni. Visualizza l'elenco delle risorse alla fine di questa sezione per gli esempi.
+
+**Reti succhiare** - Ok, le reti non sempre succhiare, ma la latenza delle reti mobili, reti di telefonia mobile anche buone, è molto peggio di quanto si pensi probabilmente. Un'applicazione desktop che slurps giù 500 righe di dati JSON, ogni 30 secondi, saranno entrambi più lento su un dispositivo mobile come un maiale di batteria. Tenete a mente che Cordova apps hanno diversi modi per rendere persistenti i dati nell'app (LocalStorage e il file system, ad esempio). Memorizzare nella cache i dati localmente ed essere consapevoli della quantità di dati che stanno mandando avanti e indietro. Questa è una considerazione importante soprattutto quando l'applicazione è collegata attraverso una rete cellulare.
+
+**Prestazioni aggiuntive articoli e risorse**
+
+*   ["Hai mezza assed esso"][11]
+*   ["Top Performance dieci suggerimenti per PhoneGap e ibrido Apps"][12]
+*   ["App veloci e siti con JavaScript"][13]
+
+ [11]: http://sintaxi.com/you-half-assed-it
+ [12]: http://coenraets.org/blog/2013/10/top-10-performance-techniques-for-phonegap-and-hybrid-apps-slides-available/
+ [13]: https://channel9.msdn.com/Events/Build/2013/4-313
+
+## 3) riconoscere e gestire stato Offline
+
+Vedere la precedente punta sulle reti. Non solo può essere una rete lenta, è interamente possibile che l'applicazione sia completamente offline. L'applicazione deve gestire questo in maniera intelligente. Se l'applicazione non lo fa, la gente penserà che l'applicazione viene interrotta. Dato quanto è facile da gestire (supporti di Cordova ascolto per entrambi un evento offline e online), non non c'è assolutamente alcun motivo per l'applicazione non risponde bene quando eseguire offline. Assicurarsi di testare (vedere la sezione relativa ai test) applicazione e assicurarsi di testare come l'applicazione gestisce quando si avvia in uno stato e poi passare ad un altro.
+
+Notare che gli eventi online e offline, così come l'API di connessione di rete non è perfetto. Potrebbe essere necessario affidarsi utilizzando una richiesta XHR per vedere se il dispositivo è veramente offline o online. Alla fine della giornata, essere sicuri di aggiungere qualche forma di supporto per problemi di rete - in realtà, l'Apple store (e probabilmente altri negozi) rifiuterà apps che non gestiscono correttamente gli Stati in linea/non in linea. Per più discussione su questo argomento, vedere ["È questa cosa?"][14]
+
+ [14]: http://blogs.telerik.com/appbuilder/posts/13-04-23/is-this-thing-on-%28part-1%29
+
+# Gestione degli aggiornamenti
+
+## Aggiornamento di progetti di Cordova
+
+Se il progetto esistente è stato creato utilizzando Cordova 3. x, è possibile aggiornare il progetto inviando il seguente:
+
+    Cordova piattaforma aggiornamento nome-piattaforma ios, android, ecc.
+    
+
+Se progetto esistente è stato creato con una versione precedente alla Cordova 3. x, probabilmente sarebbe meglio creare un nuovo progetto di Cordova 3. x e quindi copiare il codice e le attività del progetto esistente al nuovo progetto. Passaggi tipici:
+
+*   Creare un nuovo progetto di 3. x di Cordova (Cordoba creare...)
+*   Copiare la cartella www dal tuo vecchio progetto per il nuovo progetto
+*   Copiare le impostazioni di configurazione dal vecchio progetto per il nuovo progetto
+*   Aggiungi plug-in utilizzati nel vecchio progetto per il nuovo progetto
+*   Compilare il progetto
+*   Prova, prova, prova!
+
+Indipendentemente dalla versione precedente del progetto, è assolutamente fondamentale che si leggere su ciò che è stato modificato nella versione aggiornata, come l'aggiornamento può rompere il codice. Il posto migliore per trovare queste informazioni sarà nelle note di rilascio pubblicate sia nei repository e sul blog di Cordova. Volete testare app accuratamente al fine di verificare che esso funziona correttamente dopo aver eseguito l'aggiornamento.
+
+Nota: alcuni plugin potrebbero non essere compatibili con la nuova versione di Cordova. Se un plugin non è compatibile, si può essere in grado di trovare un plugin di sostituzione che fa quello che ti serve, o potrebbe essere necessario ritardare l'aggiornamento del progetto. In alternativa, modificare il plugin modo che lavorano sotto la nuova versione e contribuire torna alla Comunità.
+
+## Aggiornamenti plugin
+
+A partire da Cordova 3.4, non non c'è alcun meccanismo per l'aggiornamento del plugin modificato utilizzando un unico comando. Invece, rimuovere il plugin e aggiungere di nuovo al tuo progetto, e la nuova versione sarà installata:
+
+    Cordova plugin rm com.some.plugin cordova plugin aggiungere com.some.plugin
+    
+
+Essere sicuri di controllare la documentazione del plugin aggiornato, come potrebbe essere necessario regolare il vostro codice di lavorare con la nuova versione. Inoltre, doppia controllare che la nuova versione del plugin funziona con la versione del progetto di Cordova.
+
+Sempre testare le applicazioni per garantire che l'installazione del nuovo plugin non è rotto qualcosa che non si prevede.
+
+Se il progetto ha un sacco di plugin che avete bisogno di essere aggiornato, potrebbe risparmiare tempo per creare uno script di shell o batch che rimuove e aggiunge i plugin con un solo comando.
+
+# Test di applicazioni di Cordova
+
+Testing delle applicazioni è super importante. Il team di Cordova utilizza Jasmine ma qualsiasi soluzione di test web unità amichevole farà.
+
+## Test su un simulatore vs su un dispositivo reale
+
+Non è raro utilizzare browser desktop e simulatori/emulatori durante lo sviluppo di un'applicazione di Cordova. Tuttavia, è incredibilmente importante provare l'app su dispositivi fisici come molti come si può eventualmente:
+
+*   Simulatori sono proprio questo: simulatori. Ad esempio, l'app può funzionare nel simulatore di iOS senza problemi, ma potrebbe non funzionare su un dispositivo reale (soprattutto in certe circostanze, ad esempio uno stato di memoria bassa). O, l'app potrebbe effettivamente non sul simulatore mentre funziona bene su un dispositivo reale. 
+*   Gli emulatori sono proprio questo: gli emulatori. Non rappresentano quanto bene l'app verrà eseguito su un dispositivo fisico. Ad esempio, alcuni emulatori possono rendere l'app con un display incomprensibile, mentre un vero dispositivo non ha alcun problema. (Se si verifica questo problema, disattivare l'host GPU nell'emulatore).
+*   Simulatori sono generalmente più veloci di dispositivo fisico. Emulatori, d'altra parte, sono generalmente più lenti. Non giudicare le prestazioni dell'app di come si svolge in un simulatore o un emulatore. Giudicare le prestazioni dell'app di come funziona su una gamma di dispositivi reali.
+*   È impossibile ottenere una buona sensazione per come app risponde al tuo tocco utilizzando un simulatore o un emulatore. Invece, che esegue l'applicazione su un dispositivo reale può segnalare problemi con le dimensioni degli elementi dell'interfaccia utente, reattività, ecc.
+*   Anche se sarebbe bello essere in grado di testare solo su un dispositivo per la piattaforma, è meglio testare su molti dispositivi sportivi molte diverse versioni del sistema operativo. Ad esempio, ciò che funziona sul tuo smartphone Android particolare potrebbe non riuscire in un altro dispositivo Android. Ciò che funziona su un dispositivo iOS 7 potrebbe non funzionare su un dispositivo iOS 6.
+
+Naturalmente, è impossibile provare su ogni possibile dispositivo sul mercato. Per questo motivo, è saggio reclutare molti tester che hanno diversi dispositivi. Anche se essi non cattura ogni problema, le probabilità sono buone che scoprono capricci e problemi che non troveresti mai da solo.
+
+Suggerimento: È possibile su dispositivi Android Nexus per flash facilmente diverse versioni di Android sul dispositivo. Questo semplice processo vi permetterà di testare facilmente l'applicazione su diversi livelli di Android con un unico dispositivo, senza far decadere la garanzia o che si richiedono a "jailbreak" o "radice" nel dispositivo. Le immagini di Google Android fabbrica e le istruzioni si trovano presso: https://developers.google.com/android/nexus/images#instructions
+
+# Debug delle applicazioni di Cordova
+
+Debug Cordova richiede alcune operazioni di configurazione. A differenza di un'applicazione desktop, non puoi semplicemente aprire dev tools sul tuo dispositivo mobile e avviare il debug, per fortuna ci sono alcuni grandi alternative.
+
+## iOS debug
+
+### Xcode
+
+Con Xcode è possibile eseguire il debug lato iOS nativo dell'applicazione di Cordova. Assicurarsi che la zona di Debug è mostrando (vista-> zona di Debug). Una volta che l'app è in esecuzione sul dispositivo (o simulatore), è possibile visualizzare l'output del registro della zona di debug. Questo è dove si stamperà eventuali errori o avvisi. È inoltre possibile impostare punti di interruzione all'interno del file di origine. Questo vi permetterà di scorrere il codice una riga alla volta e Mostra lo stato delle variabili a quel tempo. Lo stato delle variabili è mostrato nella zona debug quando viene raggiunto un punto di interruzione. Una volta che l'app è in esecuzione sul dispositivo, si può portare ispettore web di Safari (come descritto di seguito) per eseguire il debug lato webview e js dell'applicazione. Per ulteriori dettagli, vedere la guida di Xcode: [Xcode debug guida][15]
+
+ [15]: https://developer.apple.com/library/mac/documentation/ToolsLanguages/Conceptual/Xcode_Overview/DebugYourApp/DebugYourApp.html#//apple_ref/doc/uid/TP40010215-CH18-SW1
+
+### Safari Remote Debugging con Web Inspector
+
+Con ispettore web di Safari è possibile eseguire il debug di codice webview e js nell'applicazione di Cordova. Questo funziona solo su OSX e solo con iOS 6 (e superiori). Usa Safari per connettersi al dispositivo (o il simulatore) e collegherà strumenti di sviluppo del browser per l'applicazione di Cordova. Si ottiene che cosa vi aspettate da dev tools - DOM ispezione/manipolazione, un debugger JavaScript, ispezione di rete, console e altro. Come Xcode, con ispettore web di Safari è possibile impostare punti di interruzione nel codice JavaScript e visualizzare lo stato delle variabili a quel tempo. È possibile visualizzare eventuali errori, avvisi o messaggi che vengono stampati nella console. L'app è in esecuzione, è possibile eseguire comandi JavaScript direttamente dalla console. Per ulteriori dettagli su come impostarlo e cosa si può fare, vedere questo ottimo blog post: <http://moduscreate.com/enable-remote-web-inspector-in-ios-6/> e questa guida: [Guida di Safari Web In
 spector][16]
+
+ [16]: https://developer.apple.com/library/safari/documentation/AppleApplications/Conceptual/Safari_Developer_Guide/Introduction/Introduction.html
+
+## Debug remoto cromo
+
+Praticamente lo stesso della versione di Safari, questo funziona solo con Android, ma può essere utilizzato da qualsiasi sistema operativo desktop. Si richiede un minimo di Android 4.4 (KitKat), minimo livello di API di 19 e 30 + Chrome (sul desktop). Una volta collegato, si ottiene la stessa esperienza di Chrome Dev Tools per le applicazioni mobili come si fa con le applicazioni desktop. Ancora meglio, il Chrome Dev Tools hanno un'opzione di specchio che mostra l'app in esecuzione sul dispositivo mobile. Questo è più appena di un vista - potete scorrere e fare clic su da dev tools e aggiorna il dispositivo mobile. Maggiori dettagli su Chrome debug remoto possono essere trovati qui: <https://developers.google.com/chrome/mobile/docs/debugging>
+
+È possibile utilizzare Chrome Dev Tools per controllare applicazioni iOS, attraverso un proxy di WebKit: <https://github.com/google/ios-webkit-debug-proxy/>
+
+## Ripple
+
+Ripple è un emulatore basato su desktop per progetti di Cordova. Essenzialmente esso consente di eseguire un'applicazione di Cordova nell'applicazione desktop e falsi varie caratteristiche di Cordova. Ad esempio, consente di simulare l'accelerometro per verificare gli eventi agitare. Finge la fotocamera API consentendo di selezionare una foto dal disco rigido. Ti permette di ondulazione che concentra più sul codice personalizzato, piuttosto che preoccuparsi di plugin di Cordova. Potete trovare maggiori informazioni su Ripple qui: <http://ripple.incubator.apache.org/>
+
+## Weinre
+
+Weinre crea un server locale che può ospitare un debug remoto client per le applicazioni di Cordova. Dopo aver installato e avviato esso, potete copiare una riga di codice nella vostra applicazione di Cordova e poi riavviarlo. È possibile aprire un pannello di strumento dev sul tuo desktop per utilizzare l'applicazione. Weinre non è abbastanza come fantasia come Chrome e Safari Remote debugging, ma ha il vantaggio di lavorare con una gamma molto maggiore di piattaforme e sistemi operativi. Ulteriori informazioni possono essere trovate qui: <http://people.apache.org/~pmuellr/weinre/docs/latest/>
+
+## Altre opzioni
+
+*   BlackBerry 10 supporta il debug anche: [documentazione][17]
+*   È possibile eseguire il debug utilizzando Firefox App Manager pure, vedere [questo post sul blog][18] e questo [articolo MDN][19].
+*   Per ulteriori esempi e spiegazione dei suggerimenti sopra di debug, vedere: <http://developer.telerik.com/featured/a-concise-guide-to-remote-debugging-on-ios-android-and-windows-phone/>
+
+ [17]: https://developer.blackberry.com/html5/documentation/v2_0/debugging_using_web_inspector.html
+ [18]: https://hacks.mozilla.org/2014/02/building-cordova-apps-for-firefox-os/
+ [19]: https://developer.mozilla.org/en-US/Apps/Tools_and_frameworks/Cordova_support_for_Firefox_OS#Testing_and_debugging
+
+# Interfaccia utente
+
+Creazione di un'applicazione di Cordova che sembra piacevole su mobile può essere una sfida, soprattutto per gli sviluppatori. Molte persone hanno scelto di utilizzare un framework di interfaccia utente per rendere questo più facile. Ecco un breve elenco di opzioni che si possono prendere in considerazione.
+
+*   [jQuery Mobile][9] - jQuery Mobile aumenta automaticamente il layout per l'ottimizzazione mobile. Gestisce anche la creazione di una SPA per voi automaticamente.
+*   [ionico][20] -questo potente framework di interfaccia utente in realtà ha la propria CLI per gestire la creazione del progetto. 
+*   [Ratchet][21] - di chi ha creato il Bootstrap. 
+*   [Kendo UI][5] - Open source UI e ambito di applicazione da Telerik.
+*   [Topcoat][22]
+*   [ReactJS][7]
+
+ [20]: http://ionicframework.com/
+ [21]: http://goratchet.com/
+ [22]: http://topcoat.io
+
+Quando si costruisce l'interfaccia utente, è importante pensare a tutte le piattaforme che vi si rivolgono e le differenze tra le aspettative dell'utente. Ad esempio, un'applicazione Android che ha un'interfaccia utente stile iOS probabilmente non andrà bene con gli utenti. Questo a volte è anche applicato i vari negozi di applicazione. Per questo motivo, è importante rispettare le convenzioni di ciascuna piattaforma e pertanto hanno familiarità con i vari Human Interface Guidelines:
+
+*   [iOS][23]
+*   [Android][24]
+*   [Windows Phone][25]
+
+ [23]: https://developer.apple.com/library/ios/documentation/userexperience/conceptual/MobileHIG/index.html
+ [24]: https://developer.android.com/designWP8
+ [25]: http://dev.windowsphone.com/en-us/design/library
+
+## UI ulteriori articoli e risorse
+
+Sebbene motori browser diventano più denuncia standard, viviamo ancora in un mondo con prefisso (-webkit e - ms.) il seguente articolo è prezioso quando lo sviluppo di UI in per attraversare apps browser: <http://blogs.windows.com/windows_phone/b/wpdev/archive/2012/11/15/adapting-your-webkit-optimized-site-for-internet-explorer-10.aspx>
+
+# Considerazioni speciali
+
+Sebbene Cordova facilita lo sviluppo multipiattaforma, non solo è possibile fornire 100% isolamento dalla piattaforma nativa sottostante. Quindi essere consapevoli delle restrizioni.
+
+## Piattaforma stranezze
+
+Durante la lettura della documentazione, cercare sezioni che delineano i requisiti su più piattaforme o comportamenti diversi. Se presenti, questi sarebbero in una sezione intitolata "Quirks Android", "iOS Quirks", ecc. Leggere queste stranezze ed essere consapevoli di loro come si lavora con Cordova.
+
+## Caricamento di contenuto remoto
+
+Il richiamo di funzioni Cordova JavaScript da una pagina HTML caricata da remoto (una pagina HTML non memorizzata localmente sul dispositivo) è una configurazione non supportata. Questo è perché Cordova non è stato progettato per questo, e la comunità Apache Cordova non fa nessun test di questa configurazione. Mentre si può lavorare in alcune circostanze, non è raccomandato né sostenuto. Ci sono sfide con lo stesso criterio di origine, mantenendo il JavaScript e porzioni nativi di Cordova sincronizzato presso la stessa versione (poiché essi sono accoppiati tramite API private che possono cambiare), l'affidabilità del contenuto remoto chiamando funzioni native locali e potenziale rifiuto di app store.
+
+Visualizzati da remoto-caricato contenuti HTML in un webview dovrebbero essere fatto utilizzando InAppBrowser di Cordova. Il InAppBrowser è progettato in modo che JavaScript in esecuzione ci non ha accesso al Cordova JavaScript APIs per i motivi sopra elencati. Fare riferimento alla guida alla sicurezza.
+
+# Tenere il passo
+
+Ecco alcuni modi per tenersi aggiornati con Cordova.
+
+*   Iscriviti al [blog di Cordova][26].
+*   Iscriversi alla [lista di sviluppatore][27]. Nota - non si tratta di un gruppo di sostegno! Si tratta piuttosto di un luogo dove si è discusso lo sviluppo di Cordova.
+
+ [26]: http://cordova.apache.org/#news
+ [27]: http://cordova.apache.org/#mailing-list
+
+# Come ottenere aiuto
+
+I seguenti link sono i posti migliori per ottenere aiuto per Cordova:
+
+*   StackOverflow: <http://stackoverflow.com/questions/tagged/cordova> utilizzando il tag di Cordova, è possibile visualizzare e sfogliare tutte le domande di Cordova. Si noti che StackOverflow converte automaticamente il tag "Phonegap" a "Cordova", così in questo modo sarete in grado di accedere anche questioni storiche
+*   PhoneGap gruppo Google: [https://groups.Google.com/forum/#!Forum/Leaflet-JS! forum/phonegap][28] questo gruppo di Google è stato il vecchio forum di supporto quando Cordova si chiamava ancora PhoneGap. Mentre ci sono ancora un sacco di utenti di Cordova che frequentano questo gruppo, la comunità di Cordova ha espresso un interesse in concentrandosi meno su questo gruppo e utilizzando invece StackOverflow per supporto
+*   Meetup: <http://phonegap.meetup.com> - prendere in considerazione trovare un gruppo meetup di Cordova/PhoneGap locale
+
+ [28]: https://groups.google.com/forum/#!forum/phonegap
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/it/6.0.0/guide/overview/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/6.0.0/guide/overview/index.md b/www/docs/it/6.0.0/guide/overview/index.md
new file mode 100644
index 0000000..db12334
--- /dev/null
+++ b/www/docs/it/6.0.0/guide/overview/index.md
@@ -0,0 +1,77 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+title: Panoramica
+---
+
+# Panoramica
+
+Apache Cordova è un framework di sviluppo mobile open source. Esso consente di utilizzare tecnologie standard web come HTML5, CSS3 e JavaScript per lo sviluppo di piattaforme, evitando il linguaggio di sviluppo nativo di ogni mobile platforms. Le applicazioni vengono eseguite nel wrapper mirati per ogni piattaforma e si basano su standard-compliant associazioni API per accedere ai sensori ogni dispositivo, dati e lo stato della rete.
+
+Apache Cordova laureato in ottobre 2012 come un progetto di alto livello all'interno della Apache Software Foundation (ASF). Attraverso l'ASF, sviluppo futuro di Cordova garantirà aperto gestione responsabile del progetto. Rimarrà sempre libero e open source sotto licenza Apache, versione 2.0. Visitare [cordova.apache.org][1] per ulteriori informazioni.
+
+ [1]: http://cordova.apache.org
+
+Usare Apache Cordova se siete:
+
+*   impostare un sviluppatore mobile e si desidera estendere un'applicazione in più di una piattaforma, senza dover reimplementare con lingua e strumento di ogni piattaforma.
+
+*   un sviluppatore web e si desidera distribuire una web app che è confezionata per la distribuzione in varie app store portali.
+
+*   uno sviluppatore mobile interessato nella miscelazione di componenti dell'applicazione nativa con una *WebView* (finestra del browser speciali) che può accedere alle API di livello dispositivo, o se si desidera sviluppare un'interfaccia plugin tra nativi e componenti WebView.
+
+## Componenti di base
+
+Cordova Apache applicazioni si basano su una comune `config.xml` file che fornisce informazioni sull'app e specifica i parametri che interessano come funziona, come se esso risponde all'orientamento si sposta. Questo file conforme alla specifica di [Confezionato Web App][2]o *widget*, di W3C.
+
+ [2]: http://www.w3.org/TR/widgets/
+
+La stessa applicazione viene implementato come una pagina web, per impostazione predefinita un file locale denominato *index. html*, che fa riferimento a qualunque CSS, JavaScript, immagini, file multimediali o altre risorse sono necessarie per essere eseguito. L'app viene eseguita come una *WebView* all'interno del wrapper di applicazione nativa, che distribuiscono ai negozi di app.
+
+WebView Cordova abilitato può fornire l'applicazione con l'intera interfaccia utente. Su alcune piattaforme, può anche essere un componente all'interno di un'applicazione ibrida più grande, che mescola WebView con componenti dell'applicazione nativa. (Per dettagli, vedere visualizzazioni Web Embedding.)
+
+Un'interfaccia del *plugin* è disponibile per Cordova e componenti nativi comunicare con a vicenda. Ciò consente di richiamare codice nativo da JavaScript. Idealmente, l'API JavaScript per quel codice nativo sono coerenti attraverso più piattaforme. A partire dalla versione 3.0, plugins fornire associazioni al dispositivo standard API. Plugin di terze parti forniscono ulteriori associazioni a caratteristiche non necessariamente disponibile su tutte le piattaforme. Potete trovare questi plugin di terze parti nel [Registro dei plugin][3] e utilizzarli nell'applicazione. È inoltre possibile sviluppare il proprio plugins, come descritto nella guida lo sviluppo di Plugin. Plugin può essere necessario, ad esempio, per comunicare tra Cordova e componenti personalizzati nativi.
+
+ [3]: http://plugins.cordova.io
+
+**Nota**: a partire dalla versione 3.0, quando si crea un progetto di Cordova non ha alcun plugin presenti. Questo è il nuovo comportamento predefinito. Tutti i plugin che desideri, anche i plugin di nucleo, devono essere aggiunto in modo esplicito.
+
+Cordova non fornisce alcuna interfaccia utente widget o MV * quadri. Cordova fornisce solo il runtime in cui quelli possono eseguire. Se si desidera utilizzare widget UI e/o un quadro MV *, devi selezionare quelli e includerli nell'applicazione voi stessi come materiale di terze parti.
+
+## Percorsi di sviluppo
+
+A partire dalla versione 3.0, è possibile utilizzare due flussi di lavoro fondamentali per creare un'app mobile. Mentre è spesso possibile utilizzare sia del flusso di lavoro per eseguire lo stesso compito, ognuno di essi offerta vantaggi:
+
+*   **Flusso di lavoro cross-platform (CLI)**: uso questo flusso di lavoro app per funzionare su sistemi operativi diversi come molti mobili possibili, con poco necessario per lo sviluppo di specifiche della piattaforma. Questo flusso di lavoro centri intorno il `cordova` utilità, altrimenti noto come il Cordova *CLI*, introdotta con la 3.0 di Cordova. Il CLI è uno strumento ad alto livello che consente di costruire progetti per numerose piattaforme contemporaneamente, astraendo tanto lontano delle funzionalità di script di shell di basso livello. CLI copia una serie comune di risorse web in sottodirectory per ogni piattaforma mobile, rende le modifiche di configurazione necessarie per ciascuno, esegue gli script di compilazione per generare binari di applicazione. CLI fornisce anche un'interfaccia comune per applicare il plugin all'app. Per maggiori dettagli su CLI, vedere l'interfaccia della riga di comando. Se non avete una necessità per il workflow di piattaforma-centrato, 
  consigliato il flusso di lavoro multi-piattaforma.
+
+*   **Piattaforma centrata sul flusso di lavoro**: utilizzare questo flusso di lavoro se si desidera concentrarsi sulla costruzione di un app per una singola piattaforma e devono essere in grado di modificarlo a un livello inferiore. È necessario utilizzare questo approccio, ad esempio, se si desidera che l'app per miscelare i componenti nativi personalizzati con componenti basati su web di Cordova, come discusso in visualizzazioni Web Embedding. Come regola generale, utilizzare questo flusso di lavoro, se è necessario modificare il progetto all'interno del SDK. Questo flusso di lavoro si basa su un insieme di script di shell di basso livello che sono su misura per ogni piattaforma supportata e un'utilità separata Plugman che consente di applicare il plugin. Mentre è possibile utilizzare questo flusso di lavoro per costruire applicazioni multipiattaforma, è generalmente più difficile perché la mancanza di uno strumento di livello superiore significa cicli compilazione separat
 a e modificazioni del plugin per ogni piattaforma. Ancora, questo flusso di lavoro consente un maggiore accesso alle opzioni di sviluppo fornito da ogni SDK ed è essenziale per applicazioni ibride complesse. Vedere le varie guide di piattaforma per dettagli su utility di shell disponibili su ogni piattaforma.
+
+Quando prima di partire, potrebbe essere più semplice utilizzare il flusso di lavoro multi-piattaforma per creare un'app, come descritto in l'interfaccia della riga di comando. Poi hai la possibilità di passare a una piattaforma centrata del flusso di lavoro se è necessario il SDK fornisce un controllo maggiore. Utility shell di basso livello sono disponibili presso [cordova.apache.org][1] in una distribuzione separata rispetto la CLI. Per i progetti inizialmente generati da CLI, questi strumenti di shell sono disponibili anche in progetto di varie `platforms/*/cordova` directory.
+
+**Nota**: una volta che si passa dal flusso di lavoro basato su CLI a uno centrato il SDK della piattaforma-specifiche e strumenti di guscio, non si può andare indietro. CLI mantiene un insieme comune di codice sorgente di piattaforme, che su ogni compilazione si utilizza per scrivere codice sorgente specifiche della piattaforma. Per conservare le modifiche apportate alle attività specifiche della piattaforma, è necessario passare agli strumenti centrato piattaforma shell, che ignorano il codice sorgente della multipiattaforma, e invece si basa sul codice sorgente di specifiche della piattaforma.
+
+## L'installazione di Cordova
+
+L'installazione di Cordova sarà diverso a seconda del flusso di lavoro sopra che si sceglie:
+
+*   Flusso di lavoro cross-piattaforma: vedere l'interfaccia della riga di comando.
+
+*   Piattaforma centrata sul flusso di lavoro: vedere le guide di piattaforma.
+
+Dopo l'installazione di Cordova, si consiglia di consultare le guide di piattaforma per le piattaforme mobili che si verranno sviluppando per. Si raccomanda inoltre di esaminare anche la guida Privacy, Security [Guide](../../index.html) e prossimi passi. Per la configurazione di Cordova, vedere il File config. Xml. Per accedere a una funzione nativa su un dispositivo da JavaScript, vedere il Plugin APIs. E consultare le altre guide incluse come necessario.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/it/6.0.0/guide/platforms/amazonfireos/config.md
----------------------------------------------------------------------
diff --git a/www/docs/it/6.0.0/guide/platforms/amazonfireos/config.md b/www/docs/it/6.0.0/guide/platforms/amazonfireos/config.md
new file mode 100644
index 0000000..44ad293
--- /dev/null
+++ b/www/docs/it/6.0.0/guide/platforms/amazonfireos/config.md
@@ -0,0 +1,71 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you 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.
+
+title: Configurazione di fuoco OS Amazon
+---
+
+# Configurazione di fuoco OS Amazon
+
+La `config.xml` file controlla le impostazioni di base di un'app che si applicano a ogni applicazione e istanza di CordovaWebView. Costruisce le preferenze di dettagli questa sezione che si applicano solo al sistema operativo di fuoco di Amazon. Per informazioni sulle opzioni di configurazione globale, vedere [il File config. XML][1] .
+
+ [1]: config_ref_index.md.html#The%20config.xml%20File
+
+*   `KeepRunning`(boolean, impostazioni predefinite a `true` ): determina se l'applicazione rimane in esecuzione in background anche dopo un `[pause](../../../cordova/events/events.pause.html)` evento incendi. Questa impostazione `false` non uccide l'app dopo un `[pause](../../../cordova/events/events.pause.html)` evento, ma semplicemente verrà interrotto l'esecuzione del codice all'interno di cordova webview mentre l'app è in background.
+    
+        <preference name="KeepRunning" value="false"/>
+        
+
+*   `ErrorUrl`(URL, impostazioni predefinite a `null` ): se impostato, visualizzerà la pagina di riferimento su di un errore dell'applicazione invece di una finestra di dialogo con il titolo "Errore dell'applicazione".
+    
+        <preference name="ErrorUrl" value="error.html"/>
+        
+
+*   `LoadingDialog`(stringa, valore predefinito del `null` ): se impostato, viene visualizzato un dialogo con il titolo specificato e il messaggio e un filatore, durante il caricamento della pagina prima di un'applicazione. Il titolo e il messaggio sono separati da una virgola in questa stringa di valore, e quello virgola viene rimosso prima che venga visualizzata la finestra di dialogo.
+    
+        <preference name="LoadingDialog" value="Please wait, the app is loading"/>
+        
+
+*   `LoadingPageDialog`(stringa, valore predefinito del `null` ): lo stesso di `LoadingDialog` , ma per ogni pagina di caricamento dopo la prima pagina dell'applicazione.
+    
+        <preference name="LoadingPageDialog" value="Please wait, the data is loading"/>
+        
+
+*   `LoadUrlTimeoutValue`(numero, valore di default è `20000` ): durante il caricamento di una pagina, la quantità di tempo di attesa prima di generare un errore di timeout. Questo esempio specifica 10 secondi anziché 20:
+    
+        <preference name="LoadUrlTimeoutValue" value="10000"/>
+        
+
+*   `SplashScreen`: Il nome del file meno sua estensione nella `res/drawable` directory. Vari beni devono condividere questo nome comune nelle varie sottodirectory.
+    
+        <preference name="SplashScreen" value="splash"/>
+        
+
+*   `SplashScreenDelay`(numero, di default è `5000` ): la quantità di tempo consente di visualizzare l'immagine della schermata iniziale.
+    
+        <preference name="SplashScreenDelay" value="10000"/>
+        
+
+*   `ShowTitle`(boolean, impostazioni predefinite a `false` ): Visualizza il titolo nella parte superiore dello schermo.
+    
+        <preference name="ShowTitle" value="true"/>
+        
+
+*   `LogLevel`(stringa, valore predefinito del `ERROR` ): imposta il livello di log minimo attraverso cui registro verranno filtrati i messaggi dall'applicazione. I valori validi sono `ERROR` , `WARN` , `INFO` , `DEBUG` , e`VERBOSE`.
+    
+        <preference name="LogLevel" value="VERBOSE"/>
\ No newline at end of file


---------------------------------------------------------------------
To unsubscribe, e-mail: commits-unsubscribe@cordova.apache.org
For additional commands, e-mail: commits-help@cordova.apache.org


Mime
View raw message