cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [02/51] [partial] added 3.4.0 for other languages
Date Mon, 24 Feb 2014 18:37:22 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/amazonfireos/webview.md b/docs/it/3.4.0/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..e921ef7
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/amazonfireos/webview.md
@@ -0,0 +1,116 @@
+---
+
+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.
+---
+
+# Amazon fuoco OS visualizzazioni Web
+
+A partire da 3.0.0, è possibile utilizzare Cordova come componente nelle applicazioni OS fuoco Amazon. Amazon fuoco OS si riferisce a questo componente come `CordovaWebView` . `CordovaWebView`estende WebView Amazon che è costruito sul cromo progetto open source. Sfruttando questa caratteristica, le applicazioni web possono utilizzare i più recenti standard del web HTML5 in esecuzione in un motore di runtime del web moderno.
+
+## Prerequisiti
+
+*   Cordova 3.0.0 o maggiore
+
+*   Android SDK aggiornato all'ultimo SDK
+
+*   Amazon WebView SDK
+
+## Guida all'utilizzo di CordovaWebView in un progetto di OS del fuoco Amazon
+
+1.  Scarica espandere [Amazon WebView SDK][1] , quindi copiare il awv_interface.jar in `/framework/libs` directory. Creare un libs / cartella se non esiste.
+
+2.  `cd`in `/framework` ed eseguire `ant jar` per costruire il barattolo di cordova. Crea il file. jar formato come `cordova-x.x.x.jar` nel `/framework` directory.
+
+3.  Modifica dell'applicazione `main.xml` file (sotto `/res/layout` ) per essere simile alla seguente, con la `layout_height` , `layout_width` e `id` modificato per soddisfare la vostra applicazione:
+    
+        <org.apache.cordova.CordovaWebView
+            android:id="@+id/tutorialView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+        
+
+4.  Modificare la vostra attività che implementa il `CordovaInterface` . È necessario implementare i metodi inclusi. Si potrebbe desiderare di copiarli da `/framework/src/org/apache/cordova/CordovaActivity.java` , o implementarle sul proprio. Il frammento di codice riportato di seguito viene illustrata un'applicazione di base che utilizza l'interfaccia. Si noti come l'id di riferimento vista corrisponde la `id` attributo specificato nel frammento XML sopra indicato:
+    
+        public class CordovaViewTestActivity extends Activity implements CordovaInterface {
+            CordovaWebView cwv;
+            /* Called when the activity is first created. */
+            @Override
+            public void onCreate(Bundle savedInstanceState) {
+                super.onCreate(savedInstanceState);
+                setContentView(R.layout.main);
+                cwv = (CordovaWebView) findViewById(R.id.tutorialView);
+                Config.init(this);
+                cwv.loadUrl(Config.getStartUrl());
+            }
+        
+
+ [1]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html#installawv
+
+Se si utilizza la fotocamera, è necessario implementare anche questo:
+
+        @Override
+        public void setActivityResultCallback(CordovaPlugin plugin) {
+            this.activityResultCallback = plugin;
+        }
+        /**
+         * Launch an activity for which you would like a result when it finished. When this activity exits,
+         * your onActivityResult() method is called.
+         *
+         * @param command           The command object
+         * @param intent            The intent to start
+         * @param requestCode       The request code that is passed to callback to identify the activity
+         */
+        public void startActivityForResult(CordovaPlugin command, Intent intent, int requestCode) {
+            this.activityResultCallback = command;
+            this.activityResultKeepRunning = this.keepRunning;
+    
+            // If multitasking turned on, then disable it for activities that return results
+            if (command != null) {
+                this.keepRunning = false;
+            }
+    
+            // Start activity
+            super.startActivityForResult(intent, requestCode);
+        }
+    
+        @Override
+        /**
+         * Called when an activity you launched exits, giving you the requestCode you started it with,
+         * the resultCode it returned, and any additional data from it.
+         *
+         * @param requestCode       The request code originally supplied to startActivityForResult(),
+         *                          allowing you to identify who this result came from.
+         * @param resultCode        The integer result code returned by the child activity through its setResult().
+         * @param data              An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
+         */
+        protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+            super.onActivityResult(requestCode, resultCode, intent);
+            CordovaPlugin callback = this.activityResultCallback;
+            if (callback != null) {
+                callback.onActivityResult(requestCode, resultCode, intent);
+            }
+        }
+    
+
+Infine, ricordarsi di aggiungere il pool di thread, altrimenti il plugin non hanno nessun thread per eseguire:
+
+        @Override
+        public ExecutorService getThreadPool() {
+            return threadPool;
+        }
+    
+
+1.  Copiare i file dell'applicazione HTML e JavaScript al progetto Amazzonia fuoco OS `/assets/www` directory.
+
+2.  Copia `config.xml` dal `/framework/res/xml` al tuo progetto `/res/xml` directory.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/android/config.md b/docs/it/3.4.0/guide/platforms/android/config.md
new file mode 100644
index 0000000..278d651
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/android/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.
+---
+
+# Android configurazione
+
+La `config.xml` file controlla le impostazioni di base di un'app che si applicano a ogni applicazione e istanza di CordovaWebView. In questa sezione i dettagli delle preferenze che si applicano solo a Build di Android. Vedere il file config. XML File per informazioni sulle opzioni di configurazione globale.
+
+*   `KeepRunning`(boolean, impostazioni predefinite a `true` ): determina se l'applicazione rimane in esecuzione in background anche dopo un `pause` evento incendi. Nota: questa impostazione su false non ucciderà l'app dopo un evento di pausa, arresterà solo l'esecuzione di codice in webview cordova mentre l'app è in background.
+    
+        <preference name="KeepRunning" value="false"/>
+        
+
+*   `LoadUrlTimeoutValue`(numero in millisecondi, per impostazione predefinita `20000` , 20 secondi): 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`(stringa, valore predefinito del `splash` ): 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="mySplash"/>
+        
+
+*   `SplashScreenDelay`(numero in millisecondi, di default è `3000` ): la quantità di tempo consente di visualizzare l'immagine della schermata iniziale.
+    
+        <preference name="SplashScreenDelay" value="10000"/>
+        
+
+*   `InAppBrowserStorageEnabled`(boolean, impostazioni predefinite a `true` ): controlli se pagine aperto all'interno di un InAppBrowser possono accedere la stessa localStorage e archiviazione WebSQL come pagine aperte con il browser predefinito.
+    
+        <preference name="InAppBrowserStorageEnabled" value="true"/>
+        
+
+*   `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="My Title,My Message"/>
+        
+
+*   `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="My Title,My Message"/>
+        
+
+*   `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="myErrorPage.html"/>
+        
+
+*   `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"/>
+        
+
+*   `SetFullscreen`(boolean, impostazioni predefinite a `false` ): come il `Fullscreen` parametro nella configurazione globale di questo file xml. Questo elemento specifico Android è deprecato in favore del global `Fullscreen` elemento e verrà rimossa in una versione futura.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/android/index.md b/docs/it/3.4.0/guide/platforms/android/index.md
new file mode 100644
index 0000000..c89156a
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/android/index.md
@@ -0,0 +1,194 @@
+---
+
+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.
+---
+
+# Guida piattaforma Android
+
+Questa guida illustra come impostare il vostro ambiente di sviluppo SDK per distribuire Cordova apps per dispositivi Android. Si cammina attraverso il processo di installare Android SDK, aprendo un progetto Android in Eclipse SDK e distribuendo un emulatore o dispositivo. Devi seguire questa guida per installare almeno il SDK di Android, indipendentemente dal flusso di lavoro che si sta seguendo. (Entrambi i workflow *Web progetto Dev* e *Nativo Dev Platform* richiedono il SDK di Android essere installato e accessibile tramite il percorso).
+
+Vedere la seguente per informazioni più dettagliate specifiche della piattaforma:
+
+*   Android configurazione
+*   Visualizzazioni Web Android
+*   Plugin Android
+*   L'aggiornamento di Android
+*   Android strumenti da riga di comando
+
+Gli strumenti della riga di comando qui sopra si riferiscono a versioni precedenti alla 3.0 di Cordova. Per informazioni sull'interfaccia corrente, vedere l'interfaccia della riga di comando.
+
+## Requisiti e supporto
+
+Vedere i [requisiti di sistema][1] per il SDK di Android.
+
+ [1]: http://developer.android.com/sdk/index.html
+
+Cordova supporta Android 2.2, 2.3 e 4. x. Come regola generale, le piattaforme sono obsoleti come essi tuffo sotto il 5% di Google [dashboard di distribuzione][2].
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+<!--
+NOTE, doc said:
+- Android 2.1 (Deprecated May 2013)
+- Android 3.x (Deprecated May 2013)
+-->
+
+Gli sviluppatori devono utilizzare il `cordova` utilità in combinazione con il SDK di Android. L'interfaccia della riga di comando per informazioni, vedere come installarlo, aggiungere progetti, quindi compilare e distribuire un progetto.
+
+Installare il SDK di Android da [Developer.Android.com/SDK][3]. il sdk di android è distribuito come un ' adt-bundle -<os>-<arch>-<ver>' file. Su windows, l'adt-bundle è confezionato con un programma di installazione. Su OSX e Linux, semplicemente scompattare l'adt-bundle nel percorso si memorizzano gli strumenti di sviluppo. [Informazioni dettagliate sull'installazione di Android SDK possono essere trovati qui][4]
+
+ [3]: http://developer.android.com/sdk/
+ [4]: http://developer.android.com/sdk/installing/bundle.html
+
+Per strumenti da riga di comando di Cordova a lavorare, è necessario includere il SDK `tools` e `platform-tools` le directory nel tuo ambiente PATH. Su Mac, è possibile utilizzare un editor di testo per creare o modificare il `~/.bash_profile` file, aggiungendo una riga come la seguente, a seconda di dove viene installato il SDK:
+
+    Export PATH = ${PATH}: / / adt-bundle/sdk/piattaforma-strumenti di sviluppo: / sviluppo/adt-bundle/sdk/tools
+    
+
+Questo espone strumenti SDK in windows terminal inaugurato di recente. In caso contrario eseguire questo per renderli disponibili nella sessione corrente:
+
+    $ fonte ~/.bash_profile
+    
+
+Per modificare l'ambiente del percorso su Windows 7:
+
+*   Fare clic su **Start nell'angolo inferiore sinistro del desktop** , tasto destro del mouse su **Computer**, quindi fare clic su **proprietà**.
+
+*   Fare clic su **Impostazioni di sistema avanzate** nella colonna a sinistra.
+
+*   Nella finestra di dialogo risultante, premere **Le variabili di ambiente**.
+
+*   Selezionare la variabile **PATH** e premere **Modifica**.
+
+*   Aggiungere quanto segue al percorso basato su cui è installato il SDK, per esempio:
+    
+        ;C:\Development\adt-bundle\sdk\platform-tools;C:\Development\adt-bundle\sdk\tools
+        
+
+*   Salvare il valore e chiudere le due finestre di dialogo.
+
+Potrebbe essere necessario abilitare Java e Ant. Apri un prompt dei comandi e digitare `java` e anche di tipo `ant` . Aggiungere al percorso qualunque non riescono ad eseguire:
+
+        ;%JAVA_HOME%\bin;%ANT_HOME%\bin
+    
+
+## Aprire un progetto in SDK
+
+Uso il `cordova` utility per impostare un nuovo progetto, come descritto in The Cordova le Command-Line Interface. Ad esempio, in una directory del codice sorgente:
+
+        $ cordova create hello com.example.hello "HelloWorld"
+        $ cd hello
+        $ cordova platform add android
+        $ cordova build
+    
+
+Una volta creato, ecco come utilizzare il SDK per modificarlo:
+
+*   Avviare l'applicazione di **Eclipse** .
+
+*   Selezionare la voce di menu **Nuovo progetto** .
+
+*   Scegliere **Progetto Android da codice esistente** nella finestra di dialogo risultante e premere **avanti**: ![][5]
+
+*   Passare a `hello` , o qualunque directory creata per il progetto, poi per il `platforms/android` sottodirectory.
+
+*   Assicurarsi che sia `hello` e `hello-CordovaLib` progetti sono selezionati per essere importati. Il `hello-CordovaLib` progetto è necessaria a partire da Cordova 3.3.0 perché Cordova è ora usato come una libreria di Android invece di un file. jar.
+
+*   Premere **fine**.
+
+ [5]: img/guide/platforms/android/eclipse_new_project.png
+
+Una volta che si apre la finestra di Eclipse può apparire una rossa **X** per indicare problemi irrisolti. Se è così, segui questi passaggi aggiuntivi:
+
+*   Tasto destro del mouse sulla directory del progetto.
+
+*   Nella finestra di dialogo **Proprietà** , selezionare **Android** dal riquadro di spostamento.
+
+*   Per il progetto di costruire la destinazione, selezionare il massimo livello di API di Android che è stato installato.
+
+*   Fare clic su **OK**.
+
+*   Dal menu **progetto** , selezionare **Clean** . Questo dovrebbe correggere tutti gli errori nel progetto.
+
+## Distribuire all'emulatore
+
+È possibile utilizzare il `cordova` utility per eseguire un'applicazione in un emulatore, o può essere eseguito all'interno del SDK. Ad ogni modo, il SDK in primo luogo deve essere configurato per almeno un dispositivo di visualizzazione. A tale scopo, utilizzare l'Android SDK Manager, un'applicazione Java che viene eseguita separatamente da Eclipse. Ci sono due modi per aprirlo:
+
+*   Eseguire `android` sulla riga di comando.
+
+*   All'interno di Eclipse, premere l'icona della barra degli strumenti:
+    
+    ![][6]
+
+ [6]: img/guide/platforms/android/eclipse_android_sdk_button.png
+
+Una volta aperto, l'Android SDK Manager visualizza varie librerie di runtime:
+
+![][7]
+
+ [7]: img/guide/platforms/android/asdk_window.png
+
+Scegliere **Strumenti → gestione AVDs** (dispositivi Android virtuale), quindi scegliere qualsiasi elemento da **Definizioni di dispositivo** nella finestra di dialogo risultante:
+
+![][8]
+
+ [8]: img/guide/platforms/android/asdk_device.png
+
+Stampa **Creare AVD**, eventualmente modificando il nome, quindi premere **OK** per accettare le modifiche:
+
+![][9]
+
+ [9]: img/guide/platforms/android/asdk_newAVD.png
+
+L'AVD poi appare nell'elenco dei **Dispositivi Android virtuale** :
+
+![][10]
+
+ [10]: img/guide/platforms/android/asdk_avds.png
+
+Per aprire l'emulatore come applicazione separata, selezionare l'AVD e premere **Start**. Si lancia proprio come farebbe sul dispositivo, con controlli aggiuntivi disponibili per i pulsanti hardware:
+
+![][11]
+
+ [11]: img/guide/platforms/android/asdk_emulator.png
+
+A questo punto è possibile utilizzare il `cordova` utility per distribuire l'applicazione nell'emulatore dalla riga di comando:
+
+        $ cordova emulate android
+    
+
+Se invece si lavora all'interno di Eclipse, il progetto di fare clic destro e scegliere **Esegui come → applicazione Android**. Può essere chiesto di specificare un AVD se nessuno è già aperto.
+
+Per un'esperienza più veloce, utilizzare un'immagine di emulatore basato su Intel:
+
+*   Installare uno o più `Intel x86 Atom` Immagini di sistema così come il `Intel Hardware Accelerated Execution Manager` , disponibile sotto **extra**.
+
+*   Eseguire il programma di installazione di Intel, che è disponibile all'interno del vostro Android SDK presso`extras/intel/Hardware_Accelerated_Execution_Manager`.
+
+*   Creare un nuovo AVD con l'obiettivo di impostare un'immagine di Intel.
+
+*   Quando si avvia l'emulatore, assicurarsi che non sono presenti messaggi di errore che indica un guasto per caricare i moduli HAX.
+
+## Distribuire al dispositivo
+
+Per spingere un app direttamente al dispositivo, assicurarsi che il debug USB è attivato sul tuo dispositivo come descritto sul [Sito per sviluppatori Android][12]e utilizzare un cavo mini USB per collegarlo al vostro sistema.
+
+ [12]: http://developer.android.com/tools/device.html
+
+Si può spingere l'app per il dispositivo dalla riga di comando:
+
+        $ cordova run android
+    
+
+Alternativamente all'interno di Eclipse, il progetto di fare clic destro e scegliere **Esegui come → applicazione Android**.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/android/plugin.md b/docs/it/3.4.0/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..ec8bd6d
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/android/plugin.md
@@ -0,0 +1,176 @@
+---
+
+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.
+---
+
+# Plugin Android
+
+In questa sezione vengono fornite informazioni dettagliate per come implementare il codice plugin nativo sulla piattaforma Android. Prima di leggere questo, vedere applicazione plugin per una panoramica della struttura del plugin e la sua interfaccia JavaScript comune. Questa sezione continua a dimostrare il plugin di esempio *eco* che comunica da Cordova webview alla piattaforma nativa e ritorno. Per un altro esempio, vedi anche i commenti di [CordovaPlugin.java][1].
+
+ [1]: https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
+
+Plugin Android sono basati su Android di Cordova, che consiste di una WebView Android con ganci collegati ad esso. Plugin sono rappresentati come mapping di classe nella `config.xml` file. Un plugin è costituito da almeno una classe Java che estende la `CordovaPlugin` classe, si esegue l'override di uno dei suoi `execute` metodi. Come migliore pratica, il plugin dovrebbe gestire anche `pause` e `resume` eventi, insieme a qualsiasi messaggio passando tra plugin. Plugin con richieste di lungo corso, attività di fondo quali la riproduzione multimediale, ascoltatori o stato interno dovrebbe implementare il `onReset()` metodo pure. Esegue quando la `WebView` si sposta su una nuova pagina o rinfresca, che ricarica il JavaScript.
+
+## Classe plugin Mapping
+
+Interfaccia JavaScript del plugin utilizza il `cordova.exec` metodo come segue:
+
+        exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+    
+
+Questo esegue il marshalling di una richiesta da WebView al lato nativo Android, efficacemente chiamando il `action` metodo sul `service` classe, con ulteriori argomenti passati nella `args` matrice.
+
+Se si distribuisce un plugin come Java file o come un file *jar* propria, il plugin deve essere specificato nell'applicazione Android-Cordova `res/xml/config.xml` file. Vedere applicazione plugin per ulteriori informazioni su come utilizzare il `plugin.xml` file per iniettare questo `feature` elemento:
+
+        <feature name="<service_name>">
+            <param name="android-package" value="<full_name_including_namespace>" />
+        </feature>
+    
+
+Il nome del servizio corrisponde a quello utilizzato in JavaScript `exec` chiamare. Il valore è l'identificatore dello spazio dei nomi completo della classe Java. In caso contrario, il plugin può compilare ma non essere ancora disponibile a Cordova.
+
+## Durata e inizializzazione di Plugin
+
+Viene creata un'istanza di un oggetto plugin per la vita di ogni `WebView` . Plugin non vengono create istanze fino a quando essi fanno riferimento in primo luogo una chiamata da JavaScript, a meno che non `<param>` con un `onload` `name` attributo è impostato su `"true"` in `config.xml` . Per esempio:
+
+    <feature name="Echo">
+        <param name="android-package" value="<full_name_including_namespace>" />
+        <param name="onload" value="true" />
+    </feature>
+    
+
+Plugin dovrebbe usare il `initialize` metodo per la loro logica di avviamento.
+
+    @override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        // your init code here
+    }
+    
+
+## Scrivere un Plugin Java Android
+
+Una chiamata JavaScript spara una richiesta di plugin al lato nativo, e il plugin di Java correspoinding è mappato correttamente nella `config.xml` file, ma cosa il finale Android Java Plugin classe aspetto? Qualunque cosa viene inviata al plugin con JavaScript `exec` funzione viene passato in classe plugin `execute` metodo. La maggior parte dei `execute` implementazioni assomigliano a questo:
+
+        @Override boolean pubblica esecuzione (azione String, args JSONArray, CallbackContext callbackContext) genera JSONException {se ("beep".equals(action)) {this.beep(args.getLong(0));
+                callbackContext.success();
+                restituire true;
+            } return false;  / / Restituzione risultati falsi in un errore di "MethodNotFound".
+        }
+    
+
+JavaScript `exec` della funzione `action` parametro corrisponde a un metodo di classe privata per spedire con parametri facoltativi.
+
+Quando cattura eccezioni e restituendo errori, è importante per motivi di chiarezza che gli errori restituiti ai nomi di eccezione di JavaScript match Java quanto più possibili.
+
+## Filettatura
+
+JavaScript del plugin fa *non* eseguire nel thread principale della `WebView` interfaccia; invece, gira sul `WebCore` filo, come fa il `execute` metodo. Se avete bisogno di interagire con l'interfaccia utente, è necessario utilizzare la seguente variazione:
+
+        @Override
+        public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+            if ("beep".equals(action)) {
+                final long duration = args.getLong(0);
+                cordova.getActivity().runOnUiThread(new Runnable() {
+                    public void run() {
+                        ...
+                        callbackContext.success(); // Thread-safe.
+                    }
+                });
+                return true;
+            }
+            return false;
+        }
+    
+
+Uso la seguente se non è necessario eseguire l'interfaccia principale di discussione, ma non voglio bloccare il `WebCore` filo sia:
+
+        @Override
+        public boolean execute(String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
+            if ("beep".equals(action)) {
+                final long duration = args.getLong(0);
+                cordova.getThreadPool().execute(new Runnable() {
+                    public void run() {
+                        ...
+                        callbackContext.success(); // Thread-safe.
+                    }
+                });
+                return true;
+            }
+            return false;
+        }
+    
+
+## Esempio di Plugin Android echo
+
+Per abbinare la caratteristica di *eco* dell'interfaccia JavaScript descritto nel plugin di applicazione, utilizzare il `plugin.xml` per iniettare una `feature` specifica per la piattaforma locale `config.xml` file:
+
+        <platform name="android">
+            <config-file target="config.xml" parent="/*">
+                <feature name="Echo">
+                    <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+                </feature>
+            </config-file>
+        </platform>
+    
+
+Quindi aggiungere il codice seguente per la `src/org/apache/cordova/plugin/Echo.java` file:
+
+        package org.apache.cordova.plugin;
+    
+        import org.apache.cordova.CordovaPlugin;
+        import org.apache.cordova.CallbackContext;
+    
+        import org.json.JSONArray;
+        import org.json.JSONException;
+        import org.json.JSONObject;
+    
+        /**
+         * This class echoes a string called from JavaScript.
+         */
+        public class Echo extends CordovaPlugin {
+    
+            @Override
+            public boolean execute(String action, JSONArray args, CallbackContext callbackContext) throws JSONException {
+                if (action.equals("echo")) {
+                    String message = args.getString(0);
+                    this.echo(message, callbackContext);
+                    return true;
+                }
+                return false;
+            }
+    
+            private void echo(String message, CallbackContext callbackContext) {
+                if (message != null && message.length() > 0) {
+                    callbackContext.success(message);
+                } else {
+                    callbackContext.error("Expected one non-empty string argument.");
+                }
+            }
+        }
+    
+
+Le importazioni necessarie nella parte superiore del file estende la classe da `CordovaPlugin` , di cui `execute()` metodo esegue l'override per ricevere messaggi da `exec()` . Il `execute()` metodo verifica innanzitutto il valore di `action` , per cui in questo caso c'è una sola valida `echo` valore. Qualsiasi altra azione restituisce `false` e si traduce in un `INVALID_ACTION` errore, che si traduce in un callback di errore richiamato sul lato JavaScript.
+
+Il metodo recupera successivamente l'eco stringa utilizzando la `args` dell'oggetto `getString` metodo, specificando il primo parametro passato al metodo. Dopo che il valore viene passato a un privato `echo` metodo, è parametro controllato per assicurarsi che non è `null` o una stringa vuota, nel qual caso `callbackContext.error()` richiama il callback di errore di JavaScript. Se passano i vari controlli, il `callbackContext.success()` passa l'originale `message` stringa al callback di successo di JavaScript come parametro.
+
+## Integrazione Android
+
+Caratteristiche Android un `Intent` sistema che consente di comunicare tra loro processi. Plugin hanno accesso a un `CordovaInterface` oggetto, che può accedere l'androide `Activity` che esegue l'applicazione. Questa è la `Context` necessaria per lanciare un nuovo Android `Intent` . Il `CordovaInterface` permette di plugin avviare un `Activity` per un risultato e impostare il plugin richiamata per quando il `Intent` restituisce all'applicazione.
+
+A partire da Cordova 2.0, plugin possono accedere non più direttamente il `Context` e l'eredità `ctx` membro è obsoleto. Tutti i `ctx` metodi esistano sulla `Context` , così entrambi `getContext()` e `getActivity()` può restituire l'oggetto richiesto.
+
+## Plugin Android debug
+
+Eclissi consente di eseguire il debug di plugin come sorgente Java incluso nel progetto. Solo l'ultima versione dell'Android Developer Tools consente di allegare il codice sorgente alle dipendenze *JAR* , quindi questa funzione non è ancora pienamente supportata.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/android/tools.md b/docs/it/3.4.0/guide/platforms/android/tools.md
new file mode 100644
index 0000000..340c9c7
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/android/tools.md
@@ -0,0 +1,68 @@
+---
+
+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.
+---
+
+# Android strumenti da riga di comando
+
+Il `cordova` l'utilità della riga di comando è uno strumento ad alto livello che consente di creare applicazioni su piattaforme diverse in una volta. Una versione precedente di Cordova framework fornisce il set di strumenti da riga di comando specifici per ogni piattaforma. Per utilizzarli come alternativa alla CLI, dovete scaricare questa versione di Cordova da [cordova.apache.org][1]. Il download contiene archivi separati per ciascuna piattaforma. Espandere la piattaforma che si desidera fare riferimento. Gli strumenti qui descritti sono in genere disponibili nel livello superiore `bin` directory, altrimenti consultare il file **Leggimi** per ulteriori indicazioni.
+
+ [1]: http://cordova.apache.org
+
+Per informazioni sull'interfaccia della riga di comando a basso livello che Abilita plugin, vedere utilizzando Plugman per gestire i plugin. Per una panoramica, vedere applicazione plugin.
+
+## Creare un progetto
+
+Eseguire il `create` comando, specificando il percorso esistente per il progetto, l'identificatore del pacchetto stile retro-dominio e nome visualizzato dell'app. Ecco la sintassi per Mac e Windows:
+
+    $ /path/to/cordova-android/bin/create /path/to/project com.example.project_name ProjectName
+    $ C:\path\to\cordova-android\bin\create.bat C:\path\to\project com.example.project_name ProjectName
+    
+
+## Costruire
+
+Questo pulisce poi costruisce un progetto.
+
+Debug, su Mac o Windows:
+
+    $ /path/to/project/cordova/build --debug
+    $ C:\path\to\project\cordova\build.bat --debug
+    
+
+Rilascio, su Mac o Windows:
+
+    $ /path/to/project/cordova/build --release
+    $ C:\path\to\project\cordova\build.bat --release
+    
+
+## Eseguire l'applicazione
+
+Il `run` comando accetta i seguenti parametri *facoltativi* :
+
+*   Destinazione specifica. Ciò include `--emulator` , `--device` , o`--target=<targetID>`.
+
+*   Costruire specifiche. Ciò include `--debug` , `--release` , o`--nobuild`.
+    
+    $ /path/to/project/cordova/run \[destinazione\] \[Build\] $ C:\path\to\project\cordova\run.bat \[destinazione\] \[Build\]
+
+Assicurarsi di creare almeno un Android Virtual Device, altrimenti viene richiesto di farlo con il `android` comando. Se più di una AVD è disponibile come un bersaglio, viene richiesto di selezionare uno. Per impostazione predefinita il `run` comando rileva un dispositivo collegato o un emulatore attualmente in esecuzione, se non viene trovato nessun dispositivo.
+
+## Registrazione
+
+    $ /path/to/project/cordova/log $ C:\path\to\project\cordova\log.bat
+    
+
+### Pulizia
+
+    $ /path/to/project/cordova/clean $ C:\path\to\project\cordova\clean.bat
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/android/upgrading.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/android/upgrading.md b/docs/it/3.4.0/guide/platforms/android/upgrading.md
new file mode 100644
index 0000000..b6a966b
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/android/upgrading.md
@@ -0,0 +1,430 @@
+---
+
+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.
+---
+
+# L'aggiornamento di Android
+
+Questa guida Mostra come modificare progetti Android per l'aggiornamento da versioni precedenti di Cordova. La maggior parte di queste istruzioni si applicano ai progetti creati con un vecchio set di strumenti da riga di comando che precedono la `cordova` utilità CLI. L'interfaccia della riga di comando per informazioni, vedere come aggiornare la versione di CLI.
+
+## L'aggiornamento a 3.3.0 da 3.2.0
+
+Seguire la stessa instructinos come per`3.2.0`.
+
+A partire da 3.3.0, il runtime di Cordova è ora compilato come una libreria di Android invece di un vaso. Questo dovrebbe avere alcun effetto per l'utilizzo della riga di comando, ma gli utenti IDE saranno necessario importare appena aggiunto `MyProject-CordovaLib` progetto nella loro area di lavoro.
+
+## L'aggiornamento a 3.2.0 da 3.1.0
+
+Per i progetti creati con il cordova CLI:
+
+1.  Aggiornamento del `cordova` versione CLI. Vedere l'interfaccia della riga di comando.
+
+2.  Eseguire`cordova platform update android`
+
+Per i progetti non creati con la CLI di cordova, eseguire:
+
+        bin/update <project_path>
+    
+
+## L'aggiornamento a 3.1.0 da 3.0.0
+
+Per i progetti creati con il cordova CLI:
+
+1.  Aggiornamento del `cordova` versione CLI. Vedere l'interfaccia della riga di comando.
+
+2.  Eseguire`cordova platform update android`
+
+Per i progetti non creati con la CLI di cordova, eseguire:
+
+        bin/update <project_path>
+    
+
+## Aggiornamento per il CLI (3.0.0) da 2.9.0
+
+1.  Creare un nuovo progetto di Apache Cordova 3.0.0 utilizzando la CLI, cordova, come descritto in l'interfaccia della riga di comando.
+
+2.  Aggiungere le piattaforme il progetto di cordova, per esempio:`cordova
+platform add android`.
+
+3.  Copiare il contenuto del tuo progetto `www` nella directory del `www` cartella alla radice del progetto cordova appena creato.
+
+4.  Copiare qualsiasi attività nativo dal tuo vecchio progetto nella directory appropriate sotto `platforms/android` : è la directory dove esiste il tuo progetto di cordova-android nativo.
+
+5.  Utilizzare lo strumento CLI di cordova per installare il plug-in che è necessario. Si noti che il CLI gestisce tutti i core API come plugin, così che può essere necessario aggiungere. Solo 3.0.0 plugin sono compatibili con il CLI.
+
+## Aggiornamento a 3.0.0 da 2.9.0
+
+1.  Creare un nuovo progetto Apache Cordova Android.
+
+2.  Copiare il contenuto del tuo `www` nella directory del nuovo progetto.
+
+3.  Copiare qualsiasi attività nativo Android dal tuo `res` nella directory del nuovo progetto.
+
+4.  Copia su qualsiasi plugin installato dalla `src` sottodirectory nel nuovo progetto.
+
+5.  Assicurarsi di aggiornare qualsiasi deprecato `<plugin>` riferimenti dal vecchio `config.xml` file per il nuovo `<feature>` specifica.
+
+6.  Aggiornare tutti i riferimenti per il `org.apache.cordova.api` pacchetto di`org.apache.cordova`.
+    
+    **Nota**: tutti i core API sono stati rimossi e devono essere installate come plugin. Per dettagli, vedere la Plugman usando per gestire guida Plugins.
+
+## Aggiornamento a 2.9.0 da 2.8.0
+
+1.  Eseguire`bin/update <project_path>`.
+
+## Aggiornamento a 2.8.0 da 2.7.0
+
+1.  Rimuovere `cordova-2.7.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.8.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+<!-- SS Eclipse -->
+
+1.  Copiare il nuovo `cordova.js` nel vostro progetto.
+
+2.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova.js` file.
+
+3.  Copia il `res/xml/config.xml` file per abbinare`framework/res/xml/config.xml`.
+
+4.  Aggiornamento `framework/res/xml/config.xml` per avere impostazioni simili, come ha fatto in precedenza.
+
+5.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.7.0 da 2.6.0
+
+1.  Rimuovere `cordova-2.6.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.7.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.7.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.7.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Aggiornamento `framework/res/xml/config.xml` per avere impostazioni simili, come ha fatto in precedenza.
+
+8.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.6.0 da 2.5.0
+
+1.  Rimuovere `cordova-2.5.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.6.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.6.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.6.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Aggiornamento `framework/res/xml/config.xml` per avere impostazioni simili, come ha fatto in precedenza.
+
+8.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+Eseguire `bin/update <project>` con il percorso del progetto elencati nella directory dei sorgenti di Cordova.
+
+## Aggiornamento a 2.5.0 da 2.4.0
+
+1.  Rimuovere `cordova-2.4.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.5.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.5.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.5.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Aggiornamento `framework/res/xml/config.xml` per avere impostazioni simili, come ha fatto in precedenza.
+
+8.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.4.0 da 2.3.0
+
+1.  Rimuovere `cordova-2.3.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.4.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.4.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.4.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.3.0 da 2.2.0
+
+1.  Rimuovere `cordova-2.2.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.3.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.3.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.3.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.2.0 da 2.1.0
+
+1.  Rimuovere `cordova-2.1.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.2.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.2.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.2.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.1.0 da 2.0.0
+
+1.  Rimuovere `cordova-2.0.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.1.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.1.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.1.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+7.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## Aggiornamento a 2.0.0 da 1.9.0
+
+1.  Rimuovere `cordova-1.9.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-2.0.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-2.0.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-2.0.0.js` file.
+
+6.  Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
+
+Nella 2.0.0 rilasciare, il `config.xml` file unisce e sostituisce `cordova.xml` e `plugins.xml` . I vecchi file sono obsolete e mentre lavorano ancora in 2.0.0, smetterà di funzionare in una versione futura.
+
+## Aggiornamento a 1.9.0 da 1.8.1
+
+1.  Rimuovere `cordova-1.8.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.9.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.9.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-1.9.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+A causa dell'introduzione della `CordovaWebView` nella 1.9.0 rilascio, plugin di terze parti potrebbero non funzionare. Questi plugin necessario per ottenere un contesto dalla `CordovaInterface` utilizzando `getContext()` o `getActivity()` . Se non sei un esperto sviluppatore Android, si prega di contattare il manutentore di plugin e aggiungere questo compito a loro tracciatore di bug.
+
+## Aggiornamento a 1.8.0 da 1.8.0
+
+1.  Rimuovere `cordova-1.8.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.8.1.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.8.1.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-1.8.1.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+## Aggiornamento a 1.8.0 da 1.7.0
+
+1.  Rimuovere `cordova-1.7.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.8.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.8.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-1.8.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+## Aggiornamento a 1.8.0 da 1.7.0
+
+1.  Rimuovere `cordova-1.7.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.8.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.8.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-1.8.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+## Aggiornamento a 1.7.0 da 1.6.1
+
+1.  Rimuovere `cordova-1.6.1.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.7.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.7.0.js` nel vostro progetto.
+
+5.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+## Aggiornamento a 1.6.1 da 1.6.0
+
+1.  Rimuovere `cordova-1.6.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.6.1.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.6.1.js` nel vostro progetto.
+
+5.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+## Aggiornamento a 1.6.0 da 1.5.0
+
+1.  Rimuovere `cordova-1.5.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.6.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.6.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-1.6.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Sostituire `res/xml/phonegap.xml` con `res/xml/cordova.xml` da abbinare`framework/res/xml/cordova.xml`.
+
+## Aggiornamento a 1.5.0 da 1.4.0
+
+1.  Rimuovere `phonegap-1.4.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `cordova-1.5.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `cordova-1.5.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `cordova-1.5.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Sostituire `res/xml/phonegap.xml` con `res/xml/cordova.xml` da abbinare`framework/res/xml/cordova.xml`.
+
+## Aggiornamento a 1.4.0 da 1.3.0
+
+1.  Rimuovere `phonegap-1.3.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `phonegap-1.4.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `phonegap-1.4.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `phonegap-1.4.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Aggiornamento `res/xml/phonegap.xml` per abbinare`framework/res/xml/phonegap.xml`.
+
+## Aggiornamento a 1.3.0 da 1.2.0
+
+1.  Rimuovere `phonegap-1.2.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `phonegap-1.3.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `phonegap-1.3.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `phonegap-1.2.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Aggiornamento `res/xml/phonegap.xml` per abbinare`framework/res/xml/phonegap.xml`.
+
+## Aggiornamento a 1.2.0 da 1.1.0
+
+1.  Rimuovere `phonegap-1.1.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `phonegap-1.2.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `phonegap-1.2.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `phonegap-1.2.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Aggiornamento `res/xml/phonegap.xml` per abbinare`framework/res/xml/phonegap.xml`.
+
+## Aggiornamento a 1.1.0 da 1.0.0
+
+1.  Rimuovere `phonegap-1.0.0.jar` del progetto `libs` directory.
+
+2.  Aggiungi `phonegap-1.1.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `phonegap-1.1.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `phonegap-1.1.0.js` file.
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+## Aggiornamento a 1.0.0 da 0.9.6
+
+1.  Rimuovere `phonegap-0.9.6.jar` del progetto `libs` directory.
+
+2.  Aggiungi `phonegap-1.0.0.jar` al progetto `libs` directory.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
+
+4.  Copiare il nuovo `phonegap-1.0.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo `phonegap-1.0.0.js` file.
+
+6.  Aggiungere il `res/xml/plugins.xml` corrispondere`framework/res/xml/plugins.xml`.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/android/webview.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/android/webview.md b/docs/it/3.4.0/guide/platforms/android/webview.md
new file mode 100644
index 0000000..7842eab
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/android/webview.md
@@ -0,0 +1,110 @@
+---
+
+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.
+---
+
+# Visualizzazioni Web Android
+
+In questa sezione viene illustrato come incorporare un componente WebView Cordova abilitato all'interno di un'applicazione Android più grande. Per dettagli su come questi componenti possono comunicare con a vicenda, vedere applicazione plugin.
+
+Se si ha familiarità con Android, si dovrebbe acquisire familiarità con la guida di piattaforma Android e avere l'ultimo Android SDK installato prima di tentare l'opzione di sviluppo più insolito di incorporare un WebView. A partire da 1,9 a Cordova, la piattaforma Android si basa su un `CordovaWebView` componente, che si basa su un retaggio `CordovaActivity` componente che pre-date la versione 1.9.
+
+1.  Per seguire queste istruzioni, assicuratevi di che avere l'ultima distribuzione di Cordova. Scaricare da [cordova.apache.org][1] e decomprimere il pacchetto di Android.
+
+2.  Spostarsi del package Android `/framework` directory ed eseguire `ant jar` . Crea il Cordova `.jar` file, costituita come`/framework/cordova-x.x.x.jar`.
+
+3.  Copia il `.jar` file al progetto Android `/libs` directory.
+
+4.  Aggiungere il seguente all'applicazione `/res/xml/main.xml` file, con la `layout_height` , `layout_width` e `id` modificato per soddisfare la domanda:
+    
+        <org.apache.cordova.CordovaWebView
+            android:id="@+id/tutorialView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+        
+
+5.  Modificare l'attività in modo che esso implementa il `CordovaInterface` . Deve implementare i metodi inclusi. Si potrebbe desiderare di copiarli da `/framework/src/org/apache/cordova/CordovaActivity.java` , o altrimenti li implementare sul proprio. Il codice di esempio riportato di seguito viene illustrata un'applicazione base che si basa sull'interfaccia. Si noti come l'id di riferimento vista corrisponde la `id` attributo specificato nel frammento XML sopra indicato:
+    
+        public class CordovaViewTestActivity extends Activity implements CordovaInterface {
+            CordovaWebView cwv;
+            /* Called when the activity is first created. */
+            @Override
+            public void onCreate(Bundle savedInstanceState) {
+                super.onCreate(savedInstanceState);
+                setContentView(R.layout.main);
+                cwv = (CordovaWebView) findViewById(R.id.tutorialView);
+                Config.init(this);
+                cwv.loadUrl(Config.getStartUrl());
+            }
+        
+
+6.  Se l'applicazione deve utilizzare la fotocamera, implementare le seguenti:
+    
+        @Override
+        public void setActivityResultCallback(CordovaPlugin plugin) {
+            this.activityResultCallback = plugin;
+        }
+        /**
+         * Launch an activity for which you would like a result when it finished. When this activity exits,
+         * your onActivityResult() method is called.
+         *
+         * @param command           The command object
+         * @param intent            The intent to start
+         * @param requestCode       The request code that is passed to callback to identify the activity
+         */
+        public void startActivityForResult(CordovaPlugin command, Intent intent, int requestCode) {
+            this.activityResultCallback = command;
+            this.activityResultKeepRunning = this.keepRunning;
+        
+            // If multitasking turned on, then disable it for activities that return results
+            if (command != null) {
+                this.keepRunning = false;
+            }
+        
+            // Start activity
+            super.startActivityForResult(intent, requestCode);
+        }   
+        
+        @Override
+        /**
+         * Called when an activity you launched exits, giving you the requestCode you started it with,
+         * the resultCode it returned, and any additional data from it.
+         *
+         * @param requestCode       The request code originally supplied to startActivityForResult(),
+         *                          allowing you to identify who this result came from.
+         * @param resultCode        The integer result code returned by the child activity through its setResult().
+         * @param data              An Intent, which can return result data to the caller (various data can be attached to Intent "extras").
+         */
+        protected void onActivityResult(int requestCode, int resultCode, Intent intent) {
+            super.onActivityResult(requestCode, resultCode, intent);
+            CordovaPlugin callback = this.activityResultCallback;
+            if (callback != null) {
+                callback.onActivityResult(requestCode, resultCode, intent);
+            }
+        }
+        
+
+7.  Infine, ricordarsi di aggiungere il pool di thread, altrimenti il plugin non hanno nessun thread su cui eseguire:
+    
+        @Override
+        public ExecutorService getThreadPool() {
+            return threadPool;
+        }
+        
+
+8.  Copiare i file dell'applicazione HTML e JavaScript per il progetto Android `/assets/www` directory.
+
+9.  Copia il `config.xml` del file da `/framework/res/xml` per il progetto `/res/xml` directory.
+
+ [1]: http://cordova.apache.org
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/blackberry/config.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/blackberry/config.md b/docs/it/3.4.0/guide/platforms/blackberry/config.md
new file mode 100644
index 0000000..440dc75
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/blackberry/config.md
@@ -0,0 +1,22 @@
+---
+
+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.
+---
+
+# Configurazione di blackBerry
+
+BlackBerry supporta pienamente il [W3C Widget specifica][1] così come le estensioni proprietarie di RIM. Si prega di consultare il completo [per quanto riguarda la documentazione di BlackBerry WebWorks config. xml][2] per i dettagli.
+
+ [1]: http://www.w3.org/TR/widgets/
+ [2]: https://developer.blackberry.com/html5/documentation/working_with_config_xml_file_1866970_11.html
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/blackberry/index.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/blackberry/index.md b/docs/it/3.4.0/guide/platforms/blackberry/index.md
new file mode 100644
index 0000000..8524b1e
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/blackberry/index.md
@@ -0,0 +1,158 @@
+---
+
+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.
+---
+
+# Guida piattaforma blackBerry
+
+Questa guida viene illustrato come configurare un ambiente SDK per le applicazioni di destinazione per la piattaforma BlackBerry precedenti alla versione 10. Se volete la versione più recente di destinazione, vedere la guida di piattaforma BlackBerry 10. Vedere la seguente per informazioni più dettagliate specifiche della piattaforma:
+
+*   Configurazione di blackBerry
+*   L'aggiornamento di BlackBerry
+*   BlackBerry Plugins
+*   Strumenti della riga di comando di blackBerry
+
+Gli strumenti della riga di comando qui sopra si riferiscono a versioni precedenti alla 3.0 di Cordova. Per informazioni sull'interfaccia corrente, vedere l'interfaccia della riga di comando.
+
+## Requisiti e supporto
+
+Questa versione di BlackBerry non è supportata dalla `cordova` utilità descritto in l'interfaccia della riga di comando, ma da un insieme distinto di strumenti da riga di comando. Scaricare la distribuzione di Cordova da [cordova.apache.org][1].
+
+ [1]: http://cordova.apache.org/#download
+
+Cordova per BlackBerry si basa sul [quadro BlackBerry WebWorks][2], che è disponibile per Windows XP (32-bit), Windows 7 (32-bit e 64-bit) e Mac (OS X 10.6.4+). WebWorks applicazioni può *solo* essere distribuiti sulle seguenti piattaforme BlackBerry:
+
+ [2]: https://bdsc.webapps.blackberry.com/html5
+
+*   BlackBerry OS 5.0 e superiori
+*   BlackBerry PlayBook
+*   BlackBerry 10 (QNX)
+
+WebWorks richiede il Java Development Kit (JDK). Per Windows, utilizzare la versione a 32 bit del [JDK Oracle][3]. In Java è installato di default su Mac OS X fino alla versione 10.7, che richiede [un'installazione separata][4]. Si richiede inoltre di Apache Ant, che su Mac fa parte dell'installazione Java. La versione di Windows è disponibile da [ant.apache.org][5].
+
+ [3]: http://www.oracle.com/technetwork/java/javase/downloads/index.html#jdk
+ [4]: http://support.apple.com/kb/DL1421
+ [5]: http://ant.apache.org/bindownload.cgi
+
+## Installare il SDK
+
+Scaricare e installare l'appropriato WebWorks SDK per lo sviluppo. BlackBerry PlayBook e BlackBerry Smartphone WebWorks SDK può essere scaricato dai seguenti percorsi.
+
+*   \[BlackBerry PlayBook SDK\] (https://developer.blackberry.com/html5/download/#playbook) e [Adobe Air SDK][6]
+
+*   \[BlackBerry smartphone SDK\] (https://developer.blackberry.com/html5/download/#smartphones)
+
+ [6]: http://www.adobe.com/devnet/air/air-sdk-download.html
+
+## Registrati per chiavi di firma
+
+Se si desidera pubblicare l'applicazione su BlackBerry App World, o su un dispositivo reale, è necessario registrarsi per un set di chiavi di firma codice libero. Per farlo, compila il [Modulo d'ordine tasti BlackBerry][7]. Dopo aver ricevuto le chiavi di firma, essi richiedono l'installazione. Vedere il [sito web BlackBerry HTML5/WebWorks][8] per informazioni.
+
+ [7]: https://www.blackberry.com/SignedKeys
+ [8]: https://developer.blackberry.com/html5/documentation/signing_setup_bb10_apps_2008396_11.html
+
+## Installare Cordova
+
+Scaricare ed estrarre l'ultima copia di [Cordova][1].
+
+## Impostare un nuovo progetto
+
+*   Aprire un terminale da riga di comando e spostarsi dove avete estratto di Cordova.
+
+*   C'è una directory per ogni piattaforma che supporta di Cordova. Passare al `blackberry` directory.
+
+*   Il `blackberry` directory contiene diverse sottodirectory. Il `example` directory contiene un progetto completo di Cordova. Copia il `example` directory in un'altra posizione sul computer e navigare lì.
+
+*   Modificare il `project.properties` file per specificare WebWorks SDK si utilizza. Ad esempio, qui sono le rispettive impostazioni per BlackBerry PlayBook, Smartphone BlackBerry (OS5-7) o BlackBerry 10 (QNX):
+    
+        playbook.bbwp.dir=C:\\Program Files\\Research In Motion\\BlackBerry WebWorks SDK per il Tablet 2.1.0.6\\bbwp blackberry.bbwp.dir=C:\\Program Files\\Research In Motion\\BlackBerry WebWorks Packager qnx.bbwp.dir=C:\\Program Files (x86) \\Research In Motion\\BlackBerry 10 WebWorks SDK 1.0.2.9
+        
+
+Questi corrispondono ai parametri specificati quando si compila il progetto. La prima volta che si eseguono questi comandi, che generano un'applicazione "HelloWorld":
+
+        Cordova/compilazione playbook cordova/compilazione blackberry cordova/compilazione qnx
+    
+
+Insieme al SDK, è inoltre necessario registrare una chiave di firma codice e token di debug. La chiave di firma consente di distribuire applicazioni attraverso il mondo BlackBerry. Il token di debug consente di testare le applicazioni unsigned su un emulatore di BlackBerry o un dispositivo. Non è necessario creare e installare il token di debug da soli; Se la password del keystore, lo script di compilazione crea e installa il token di debug per voi. Per impostare la chiave di firma, visitare il sito Web di BlackBerry per ottenerlo, facendo attenzione a conservare la password specificata. Quindi eseguire il `blackberry-signer` utilità che è incluso con il SDK. BlackBerry fornisce ulteriori informazioni qui:
+
+*   [Registrati per il chiave di firma del codice][9]
+
+*   [Configurare il computer per la firma del codice][10]
+
+*   [guida completa alla creazione di ambiente SDK][11]
+
+ [9]: https://www.blackberry.com/SignedKeys/codesigning.html
+ [10]: http://developer.blackberry.com/html5/documentation/set_up_for_signing.html
+ [11]: http://developer.blackberry.com/native/documentation/bb10/com.qnx.doc.native_sdk.quickstart/topic/set_up_your_environment.html
+
+## Distribuire all'emulatore
+
+Emulatori di smartphone blackBerry sono disponibili solo su Windows. Emulatori di blackBerry PlayBook richiedono VMWare Player (Windows) o VMWare Fusion (Mac OS X). WebWorks SDK fornisce un emulatore di default, ma altri emulatori sono [disponibili tramite BlackBerry][12].
+
+ [12]: http://us.blackberry.com/developers/resources/simulators.jsp
+
+Dalla directory del progetto, digitare `./cordova/run <target>` , sostituendo `<target>` con uno `qnx` , `playbook` , o `blackberry` . Si noti che per 10 BlackBerry e PlayBook, l'immagine virtuale emulatore deve già avviato.
+
+Vedere le seguenti per ulteriori informazioni:
+
+*   [BlackBerry PlayBook][13]
+
+*   [Smartphone blackBerry][14]
+
+ [13]: https://developer.blackberry.com/html5/documentation/using_the_tablet_simulator_1866980_11.html
+ [14]: https://developer.blackberry.com/html5/documentation/run_your_app_on_smartphone_sim_1876976_11.html
+
+Per BlackBerry Playbook, modificare il `project.properties` file per personalizzare il `playbook.sim.ip` e `playbook.sim.password` proprietà. Indirizzo IP dell'emulatore è disponibile attraverso l'applicazione **Impostazioni** sulla schermata home. Abilitare il **sicurezza e Privacy → modalità di sviluppo** opzione per visualizzare l'indirizzo. La password può essere impostata anche nella scheda **sicurezza e Privacy** .
+
+Smartphone BlackBerry, modificare il `project.properties` file per personalizzare il `blackberry.sim.dir` e `blackberry.sim.bin` proprietà. Avete bisogno di fuggire i delimitatori del percorso quando si specificano i percorsi di directory su Windows, ad esempio:`C:\\Program
+Files\\BlackBerry\\Simulator`.
+
+Una volta che l'emulatore è installato e in esecuzione, eseguire uno dei seguenti per installare un'applicazione alla schermata iniziale:
+
+        blackberry cordova esecuzione/Cordova/Esegui playbook
+    
+
+Se viene richiesto se un dispositivo è collegato al computer, rispondere no.
+
+**Nota:** Su BlackBerry OS 5, l'applicazione viene installata nella `Downloads` directory.
+
+## Distribuire al dispositivo
+
+Per distribuire l'applicazione a un dispositivo, deve essere collegato, e devi essere registrato per codice chiavi di firma, come descritto sopra. Inoltre, per distribuire le applicazioni su BlackBerry PlayBook, il **Impostazioni → sicurezza → modalità di sviluppo** opzione deve essere attivata.
+
+Sul BlackBerry PlayBook, modificare il `project.properties` del file e modificare il seguente per riflettere il dispositivo IP e password come descritto sopra, insieme con la firma chiave password si imposta:
+
+Dalla directory del progetto, digitare `./cordova/run <target>` , sostituendo `<target>` con uno `qnx` , `playbook` , o`blackberry`.
+
+BlackBerry smartphone (OS5-7), specificare la `blackberry.sigtool.password` proprietà come password firma chiave.
+
+Poi dalla directory del progetto, eseguire uno dei comandi che si farebbe per visualizzare le app in un emulatore:
+
+        blackberry cordova esecuzione/Cordova/Esegui playbook
+    
+
+Se viene richiesto se un dispositivo è collegato al computer, rispondete sì.
+
+**Nota:** Su BlackBerry OS 5, l'applicazione viene installata nella `Downloads` directory.
+
+## Informazioni aggiuntive
+
+Gli articoli seguenti possono contribuire a risolvere problemi comuni durante lo sviluppo di applicazioni create per BlackBerry WebWorks framework:
+
+*   [BlackBerry WebWorks sviluppo insidie][15]
+
+*   [Consigliate per applicazioni WebWorks di imballaggio][16]
+
+ [15]: http://supportforums.blackberry.com/t5/Web-and-WebWorks-Development/Common-BlackBerry-WebWorks-development-pitfalls-that-can-be/ta-p/624712
+ [16]: https://bdsc.webapps.blackberrycom/html5/documentation/ww_developing/bestpractice_compiling_ww_apps_1873324_11.html
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/blackberry/plugin.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/blackberry/plugin.md b/docs/it/3.4.0/guide/platforms/blackberry/plugin.md
new file mode 100644
index 0000000..60d2a38
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/blackberry/plugin.md
@@ -0,0 +1,102 @@
+---
+
+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.
+---
+
+# BlackBerry Plugins
+
+Questa guida illustra come sviluppare un plugin Echo sul BlackBerry. La guida allo sviluppo di Plugin fornisce un'ampia panoramica con cui si dovrebbe già avere familiarità, e questa guida riprende da dove lascia fuori. Inoltre, scaricare la [repository di Cordova BlackBerry][1].
+
+ [1]: https://git-wip-us.apache.org/repos/asf?p=cordova-blackberry-webworks.git;a=summary
+
+Il `Cordova-BlackBerry` progetto consente di distribuire ai dispositivi BlackBerry come la torcia, grassetto e Playbook. Il Playbook utilizza un diverso codice base rispetto ad altri dispositivi palmari BlackBerry, per cui è necessario duplicare i vostri sforzi di sviluppo. Questa guida si concentra su dispositivi palmari anziché compresse. (In futuro, questa guida dovrebbe coprire entrambe le piattaforme).
+
+Il plugin Echo restituisce essenzialmente qualunque messaggio un utente fornisce per la `window.echo` funzione:
+
+    window.echo = function(str, callback) {
+        cordova.exec(callback, function(err) {
+            callback('Nothing to echo.');
+        }, "Echo", "echo", [str]);
+    };
+    
+
+## Modifica plugins
+
+Il progetto `www/plugins.xml` directory contiene tutti i riferimenti necessari plugins del vostro progetto di Cordova. Aggiungere un ulteriore riferimento così che quando `cordova.exec` è chiamato, Cordova conosce come mappare il `Echo` argomento di `cordova.exec` per la `Echo` classe che vogliamo scrivere nativamente:
+
+    <feature name="Echo">
+        <param name="blackberry-package" value="org.apache.cordova.echo.Echo" />
+    </feature>
+    
+
+## L'aggiunta di Echo.java
+
+Se si nota la struttura dell'attributo value, vedrete un percorso definito che conduce al plugin Echo. Nella directory radice del repo Cordova BlackBerry WebWorks, cercare una directory chiamata `framework` . Questa directory contiene tutto il codice sorgente che gira nativamente su BlackBerry. Passare a `framework/ext/src/org/apache/cordova` . A questo punto, vedrete tutti i plugin directorys, che all'interno della quale è il codice sorgente. Quindi aggiungere l'eco directory per `framework/ext/src/org/apache/cordova/echo` e creare un file chiamato `Echo.java` a`framework/ext/src/org/apache/cordova/echo/Echo.java`.
+
+## Scrittura Echo.java
+
+L'idea base scrivendo un plugin è quello di creare una classe che estende la classe Plugin e un metodo chiamato `execute` per restituire un `PluginResult` classe. Tutte le chiamate a `cordova.exec` passa nell'azione da eseguire all'interno della classe, così come gli argomenti. In questo caso, "eco" è l'azione che vogliamo eseguire all'interno della classe "Echo" e [str] sono gli argomenti che stiamo passando in.
+
+    package org.apache.cordova.echo;
+    
+    import org.apache.cordova.api.Plugin;
+    import org.apache.cordova.api.PluginResult;
+    import org.apache.cordova.json4j.JSONArray;
+    import org.apache.cordova.json4j.JSONException;
+    import org.apache.cordova.json4j.JSONObject;
+    /**
+     * A simple plugin to demonstrate how to build a plugin for BlackBerry
+     * Basically echos back the msg that a user calls to this plugin
+     */
+    public final class Echo extends Plugin {
+    
+        public static final String echo = "echo";
+    
+        public PluginResult execute(String action, JSONArray args, String callbackId) {
+            PluginResult result = new PluginResult(PluginResult.Status.INVALID_ACTION, "Echo: Invalid action:" + action);
+            if(action.equals(echo)){
+                try {
+                    String theMsg = args.getString(0);
+                    if(theMsg!= null || theMsg.length()>0){
+                        result = new PluginResult(PluginResult.Status.OK, theMsg);
+                    }else{
+                        result = new PluginResult(PluginResult.Status.ERROR, "Nothing to echo.");
+                    }
+                } catch (JSONException e) {
+                    result = new PluginResult(PluginResult.Status.JSON_EXCEPTION, e.getMessage());
+                }
+            }
+    
+            return result;
+        }
+    
+    }
+    
+
+Così se guardiamo il codice qui sopra, possiamo vedere che all'interno del metodo execute, prima cerchiamo quali azioni stanno arrivando. Il plugin Echo ha solo una azione, `echo` , quindi ci sarà il solo check per quello. Se il nostro plugin aveva più azioni, è semplicemente una questione di aggiungere ulteriori test condizionali per verificare tali azioni.
+
+Abbiamo poi intenzione di afferrare il messaggio proveniente dal argomenti che viene fornito dal parametro args. Noi possiamo afferrare il primo argomento facendo semplicemente`String theMsg = args.getString(0);`.
+
+Faremo qualche errore controllo e se il messaggio sembra OK, ci sarà istanziare un nuovo PluginResult con uno status ok: `PluginResult.Status.OK` e restituire il messaggio: `theMsg` . Dopo questo, abbiamo restituito il risultato che da passare a JavaScript di essere licenziato nel callback di successo. Se qualcosa non riesce, possiamo tornare varie eccezioni di stato come `PluginResult.Status.ERROR` , `PluginResult.Status.JSON_EXCEPTION` , o `PluginResult.Status.INVALID_ACTION` . Quando passato indietro, questi tipi di risultati fuoco il callback di fallire in JavaScript.
+
+## Aggiornando il. jar nella directory www del progetto
+
+L'aggiunto `Echo.java` deve essere aggiornato nel tuo progetto. Per costruire il `.jar` del file, passare alla directory principale di repo BlackBerry WebWorks ed eseguire il `ant` comando:
+
+    ant update -Dproject.path="~/path_to_my_project"
+    
+
+Questo crea un nuovo `.jar` del file nella `build/ext` directory. Copia il `build/ext/cordova.jar` del file nel tuo `project/www/ext` directory.
+
+Se tutto va bene, che permette di utilizzare il plugin Echo in BlackBerry.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/2506e7b9/docs/it/3.4.0/guide/platforms/blackberry/tools.md
----------------------------------------------------------------------
diff --git a/docs/it/3.4.0/guide/platforms/blackberry/tools.md b/docs/it/3.4.0/guide/platforms/blackberry/tools.md
new file mode 100644
index 0000000..1b3c803
--- /dev/null
+++ b/docs/it/3.4.0/guide/platforms/blackberry/tools.md
@@ -0,0 +1,60 @@
+---
+
+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.
+---
+
+# Strumenti della riga di comando di blackBerry
+
+Il `cordova` l'utilità della riga di comando è uno strumento ad alto livello che consente di creare applicazioni su piattaforme diverse in una volta. Una versione precedente di Cordova framework fornisce il set di strumenti da riga di comando specifici per ogni piattaforma. Per utilizzarli come alternativa alla CLI, dovete scaricare questa versione di Cordova da [cordova.apache.org][1]. Il download contiene archivi separati per ciascuna piattaforma. Espandere la piattaforma che si desidera fare riferimento. Gli strumenti qui descritti sono in genere disponibili nel livello superiore `bin` directory, altrimenti consultare il file **Leggimi** per ulteriori indicazioni.
+
+ [1]: http://cordova.apache.org
+
+## Creare un progetto
+
+Eseguire il `create` comando, specificando il percorso esistente per il progetto, l'identificatore del pacchetto stile retro-dominio e nome visualizzato dell'app. Ecco la sintassi per Mac e Windows:
+
+    $ /path/to/cordova-blackberry-webworks/bin/create /path/to/my_new_project com.example.project_name ProjectName
+    $ /path/to/cordova-blackberry-webworks/bin/create.bat /path/to/my_new_project com.example.project_name ProjectName
+    
+
+**Nota:** La piattaforma BlackBerry ignora il segnaposto del nome di pacchetto ( `com.example.project_name` ), ma è ancora necessario per l'uso di strumenti multipiattaforma.
+
+## Costruire un progetto
+
+Per i progetti di BlackBerry, assicurati di personalizzare il `project.properties` file nella directory radice del progetto Cordova. Devi farlo per fornire il vostro BlackBerry firma chiave password e specificare i percorsi per il BlackBerry WebWorks SDK e BlackBerry emulatore file eseguibili.
+
+    $ /path/to/my_new_project/cordova/build <platform>
+    $ /path/to/my_new_project/cordova/build.bat <platform>
+    
+
+## Avviare l'emulatore
+
+Per i progetti di BlackBerry, assicurati di personalizzare il `project.properties` file nella radice della directory del progetto di Cordova. Devi farlo per fornire il vostro BlackBerry firma chiave password e specificare i percorsi per il BlackBerry WebWorks SDK e BlackBerry emulatore file eseguibili.
+
+    $ /path/to/my_new_project/cordova/run <platform>
+    
+
+e poi scegliere 'no' quando richiesto con:
+
+    Avete un dispositivo BlackBerry collegato al computer? (y/n) $ /path/to/my_new_project/cordova/run < piattaforma >
+    
+
+e poi scegliere 'no' quando richiesto con:
+
+    Avete un dispositivo BlackBerry collegato al computer? (y/n)
+    
+
+## Registrazione
+
+Purtroppo, registri direttamente dal dispositivo in streaming è attualmente supportato. Tuttavia, BlackBerry offre supporto integrato Web Inspector per Playbook e BlackBerry dispositivi smartphone in esecuzione BlackBerry OS 7.0 e superiori. È possibile accedere anche i log dell'applicazione (compresi eventuali chiamate al `console.log` ) sul vostro dispositivo tenendo premuto il tasto 'ALT ' dalla schermata iniziale e digitando i tasti ' lglg '.
\ No newline at end of file


Mime
View raw message