cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [02/52] [abbrv] [partial] docs commit: CB-12747: added 7.x docs
Date Thu, 04 May 2017 15:01:43 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/it/7.x/guide/platforms/amazonfireos/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/amazonfireos/index.md b/www/docs/it/7.x/guide/platforms/amazonfireos/index.md
new file mode 100644
index 0000000..b67f1ef
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/amazonfireos/index.md
@@ -0,0 +1,192 @@
+---
+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: Amazon fuoco piattaforma OS guida
+---
+
+# Amazon fuoco piattaforma OS guida
+
+Questa guida illustra come impostare il vostro ambiente di sviluppo SDK per distribuire Cordova apps per dispositivi Amazon fuoco OS come il Kindle Fire HDX.
+
+Vedere la seguente per informazioni più dettagliate specifiche della piattaforma:
+
+*   [Configurazione di fuoco OS Amazon](config.html)
+*   [Amazon fuoco OS visualizzazioni Web](webview.html)
+*   [Amazon fuoco OS Plugins](plugin.html)
+
+## Introduzione
+
+Prendendo di mira la piattaforma Amazon fuoco OS, gli sviluppatori Cordova possono creare ibridi web apps che sfruttano il motore web avanzati integrato in dispositivi Kindle Fire. Amazon WebView API (LCG) è un derivato cromo web runtime esclusivo per OS di fuoco. Un rimpiazzo per il WebView che viene fornito con dispositivi Android, LCG permette di creare l'esecuzione migliore e più potente ibrido web apps fornendo il supporto per un motore JavaScript più veloce (V8), il debug remoto e le ottimizzazioni di hardware per dispositivi Kindle Fire, tra cui un'accelerata 2D Canvas e accesso alle funzionalità di HTML5 non supportate da Android costruito in WebView come: Calc CSS, validazione dei Form, getUserMedia, IndexedDB, Web lavoratori, WebSockets e WebGL.
+
+Per ulteriori informazioni sull'API WebView Amazon, consulta del portale sviluppatore Amazon [pagina applicazioni ibride di HTML5][1]. Per domande su come ottenere iniziato e altre edizioni di sostegno, vedere Amazon Developer Portal [forum - HTML5 ibrido Apps][2].
+
+ [1]: https://developer.amazon.com/public/solutions/platforms/android-fireos/docs/building-and-testing-your-hybrid-app
+ [2]: http://forums.developer.amazon.com/forums/category.jspa?categoryID=41
+
+## Requisiti e supporto
+
+Lo sviluppo di app di Cordova per Amazon fuoco OS richiede l'installazione di una varietà di file di supporto, compreso tutto il necessario per lo sviluppo di Android, così come Amazon WebView SDK. Controllare la lista qui sotto per il necessario installa:
+
+*   [L'interfaccia della riga di comando](../../cli/index.html)
+*   [Android SDK][3]
+*   [Apache Ant][4]
+*   [Amazon WebView SDK][1]
+
+ [3]: http://developer.android.com/sdk/
+ [4]: http://ant.apache.org
+
+## Installazione
+
+### Android SDK e Apache Ant
+
+Installare il SDK di Android da [developer.android.com/sdk][3]. Altrimenti può essere presentato con una scelta di dove installare il SDK, spostare lo scaricato `adt-bundle` albero ovunque si memorizzare gli strumenti di sviluppo.
+
+Dovrai eseguire Android SDK Manager ( `android` da una riga di comando) almeno una volta prima di iniziare il vostro progetto di Cordova. Assicurarsi di installare la versione più recente di Android SDK Tools e SDK Platform **in particolare livello di API 19**. Portale per sviluppatori Amazon per ulteriori informazioni sull'impostazione di ambiente di sviluppo per dispositivi Kindle Fire OS vedere [impostazione il tuo ambiente di sviluppo][5] .
+
+ [5]: https://developer.amazon.com/public/resources/development-tools/ide-tools/tech-docs/01-setting-up-your-development-environment
+
+Installare Apache Ant costruire tool [scaricando una distribuzione binaria Ant][6], decompresso in una directory, è possibile fare riferimento a più tardi. Vedere il [manuale di formica][7] per più informazioni.
+
+ [6]: http://ant.apache.org/bindownload.cgi
+ [7]: http://ant.apache.org/manual/index.html
+
+Per strumenti da riga di comando di Cordova a lavorare, è necessario includere il SDK di Android `tools` , `platform-tools` e `apache-ant/bin` le directory nel tuo ambiente PATH.
+
+#### Percorso Mac/Linux
+
+Su Mac, Linux o altre piattaforme Unix-like, è possibile utilizzare un editor di testo per creare o modificare il `~/.bash_profile` file, aggiungendo una riga come la seguente, a seconda di dove sono installate il SDK e la formica:
+
+    Export PATH = ${PATH}: / / adt-bundle/sdk/piattaforma-strumenti di sviluppo: / / adt-bundle/sdk/strumenti di sviluppo: / sviluppo/apache-ant/bin
+    
+
+Questo espone strumenti SDK in windows terminal inaugurato di recente. In caso contrario eseguire questo per renderli disponibili nella sessione corrente:
+
+    $ source ~/.bash_profile
+    
+
+#### Percorso di Windows
+
+Per modificare l'ambiente del percorso su Windows:
+
+*   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 è stato installato il SDK e la formica, ad esempio:
+    
+        ;C:\Development\adt-bundle\sdk\platform-tools;C:\Development\adt-bundle\sdk\tools;C:\Development\apache-ant\bin
+        
+
+*   Salvare il valore e chiudere le due finestre di dialogo.
+
+*   Inoltre devi abilitare Java. Aprire un prompt dei comandi e digitare `java` , se non viene eseguito, aggiungere il percorso dei binari Java al vostro percorso pure. Rendere %JAVA_HOME% sia rivolto verso il JDK installato nella directory. Potrebbe essere necessario aggiungere separatamente variabile di ambiente JAVA_HOME.
+    
+        ; %JAVA_HOME%\bin
+        
+
+### Amazon WebView SDK
+
+Al fine di creare app di Cordova la destinazione della piattaforma Amazon fuoco OS, sarà necessario scaricare, scompattare e installare i file di supporto di Amazon WebView SDK. Solo questo passo dovrà essere fatto per il primo progetto di Amazon fuoco OS.
+
+*   Scaricare il SDK di WebView Amazon [Amazon Developer Portal][1].
+
+*   Copia `awv_interface.jar` da SDK scaricato nella directory di lavoro di Cordova. Creare la cartella commonlibs(shown below) se non esiste:
+    
+    **Mac/Linux:** `~/.cordova/lib/commonlibs/`
+    
+    **Windows:** `%USERPROFILE%\.cordova\lib\commonlibs`
+
+## Crea nuovo progetto per Amazon fuoco OS
+
+Uso il `cordova` utility per impostare un nuovo progetto, come descritto in Cordova The Command-Line Interface. Ad esempio, in una directory del codice sorgente:
+
+    $ cordova create hello com.example.hello "HelloWorld"
+    $ cd hello
+    $ cordova platform add amazon-fireos
+    $ cordova build
+    
+
+***Nota:*** La prima volta che la piattaforma amazon-fireos è installata sul vostro sistema, Scarica i file appropriati per la directory di lavoro di Cordova, ma mancherà poi come manca i file di supporto AWV SDK (vedi sopra). Seguire le istruzioni riportate sopra per installare il `awv_interface.jar` , quindi rimuovere e aggiungere nuovamente la piattaforma amazon-fireos al progetto. Solo questo passaggio dovrà essere fatto per il primo progetto di Amazon fuoco OS.
+
+## 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][8]e utilizzare un cavo mini USB per collegarlo al vostro sistema.
+
+ [8]: http://developer.android.com/tools/device.html
+
+Si può spingere l'app per il dispositivo dalla riga di comando:
+
+    $ cordova eseguire amazon-fireos
+    
+
+Alternativamente all'interno di Eclipse, il progetto di fare clic destro e scegliere **Esegui come → applicazione Android**.
+
+**Nota**: attualmente, testing tramite un emulatore non è supportato per Amazon WebView basati su applicazioni, inoltre le API di Amazon WebView è disponibile solo sui dispositivi antincendio OS. Per ulteriori informazioni, vedere la documentazione [SDK API di Amazon WebView][1] .
+
+### Eseguire flag
+
+Il comando run accetta i parametri facoltativi come specificato nel documento Cordova Command Line Interface, fuoco OS accetta anche un ulteriore `--debug` bandiera che consentirà Developer Tools di Chromium per il debug remoto web.
+
+Per utilizzare gli strumenti per sviluppatori, immettere:
+
+    $ cordova run --debug amazon-fireos
+    
+
+Ciò consentirà gli strumenti client in esecuzione. Può quindi connettersi al client di inoltro porta utilizzando l'Android Debug Bridge (adb) riferendosi al nome del pacchetto dell'applicazione.
+
+Ad esempio:
+
+    ADB tcp:9222 avanti localabstract:com.example.helloworld.devtools
+    
+
+È quindi possibile utilizzare il DevTools tramite un browser basato su Chromium spostandosi a:`http://localhost:9222`.
+
+### Supporto opzionale di Eclipse
+
+Una volta creato, è possibile utilizzare l'eclissi che arriva con il SDK di Android per modificare il progetto. Fate attenzione che le modifiche apportate attraverso Eclipse saranno sovrascritto se si continua a utilizzare gli strumenti della riga di comando Cordova.
+
+*   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**: ![][9]
+
+*   Passare a `hello` , o qualunque directory creata per il progetto, poi per il `platforms/amazon-fireos` sottodirectory.
+
+*   Eclisse vi mostrerà Ciao Ciao-CorddovaLib - 2 progetti e da aggiungere. Aggiungere entrambi.
+
+*   Premere **fine**.
+
+ [9]: {{ site.baseurl }}/static/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 target di compilazione del progetto, selezionare il livello più alto di Android API (attualmente API livello 19) sia installato.
+
+*   Fare clic su **OK**.
+
+*   Dal menu **progetto** , selezionare **Clean** . Questo dovrebbe correggere tutti gli errori nel progetto.

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/it/7.x/guide/platforms/amazonfireos/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/amazonfireos/plugin.md b/www/docs/it/7.x/guide/platforms/amazonfireos/plugin.md
new file mode 100644
index 0000000..dda38e4
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/amazonfireos/plugin.md
@@ -0,0 +1,106 @@
+---
+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: Amazon fuoco OS Plugins
+---
+
+# Amazon fuoco OS Plugins
+
+Seguire le istruzioni fornite nella guida Plugins Android per una panoramica di sviluppo plugin personalizzato.
+
+## Esempio di Plugin Echo Amazon fuoco OS
+
+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="amazon-fireos">
+        <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.");
+            }
+        }
+    }
+    
+
+Se si desidera riutilizzare codice Android Plugin per la piattaforma Amazon fuoco OS poi modificare il plugin per puntare il `android` file origine specifica. Ad esempio,
+
+    <platform name="amazon-fireos">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Echo">
+                <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+            </feature>
+        </config-file>
+        <source-file src="src/android/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+    </platform>
+    
+
+Se volete scrivere un plugin su misura per la piattaforma Amazon fuoco OS quindi creare una cartella denominata `amazon` sotto il vostro plugin src / cartella e modificare il plugin per puntare il `amazon` file origine specifica. Ad esempio,
+
+    <platform name="amazon-fireos">
+        <config-file target="config.xml" parent="/*">
+            <feature name="Echo">
+                <param name="android-package" value="org.apache.cordova.plugin.Echo"/>
+            </feature>
+        </config-file>
+        <source-file src="src/amazon/Echo.java" target-dir="src/org/apache/cordova/plugin" />
+    </platform>
+    
+
+## Utilizzando Amazon WebView nel vostro plugin
+
+Cordova per OS fuoco Amazon fa uso di personalizzato WebView Amazon che è costruito sul progetto open source Chromium. È la GPU accelerati e ottimizzato per prestazioni fluide sul Kindle Fire.
+
+Per capire come utilizzare al meglio Amazon WebView nel vostro progetto, controllare il [Portale per sviluppatori di Amazon][1].
+
+ [1]: https://developer.amazon.com/sdk/fire/IntegratingAWV.html
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/it/7.x/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/amazonfireos/webview.md b/www/docs/it/7.x/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..f61efd0
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/amazonfireos/webview.md
@@ -0,0 +1,129 @@
+---
+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: Amazon fuoco OS visualizzazioni Web
+---
+
+# Amazon fuoco OS visualizzazioni Web
+
+A partire da 3.3.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.
+
+Se si ha familiarità con Amazon fuoco OS, in primo luogo è necessario acquisire familiarità con la guida di piattaforma Amazon fuoco OS e avere il SDK più recente installato prima di tentare l'opzione di sviluppo più insolito di incorporare un WebView.
+
+## Prerequisiti
+
+*   Cordova 3.3.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.  Per seguire queste istruzioni, assicuratevi di che avere l'ultima distribuzione di Cordova. Scaricare da [cordova.apache.org][1] e decomprimere il pacchetto Amazon fuoco OS.
+
+2.  Scarica espandere [Amazon WebView SDK][2] , quindi copiare il awv_interface.jar in `/framework/libs` directory. Creare un libs / cartella se non esiste.
+
+3.  Spostarsi del pacchetto `/framework` directory ed eseguire `ant jar` . Crea il Cordova `.jar` file, costituita come`/framework/cordova-x.x.x.jar`.
+
+4.  Copia il `.jar` file al progetto Android `/libs` directory.
+
+5.  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" />
+        
+
+6.  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]: http://cordova.apache.org
+ [2]: 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/5ad93d20/www/docs/it/7.x/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/android/config.md b/www/docs/it/7.x/guide/platforms/android/config.md
new file mode 100644
index 0000000..a2ccb12
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/android/config.md
@@ -0,0 +1,95 @@
+---
+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 Android
+---
+
+# Configurazione Android
+
+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. 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"/>
+
+
+*   `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](../../../cordova/storage/localstorage/localstorage.html) 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.
+
+*   `AndroidLaunchMode`(stringa, valore predefinito del `singleTop` ): imposta l'attività `android:launchMode` attributo. Questo cambia la cosa succede quando l'applicazione viene avviata da icona app o intenti ed è già in esecuzione. I valori validi sono `standard` , `singleTop` , `singleTask` ,`singleInstance`.
+
+        <preference name="AndroidLaunchMode" value="singleTop"/>
+
+
+*   `DefaultVolumeStream`(stringa, valore predefinito del `default` , aggiunto in cordova-Androide 3.7.0): imposta il volume il volume di hardware pulsanti linkare. Per impostazione predefinita questo è "chiamata" per telefoni cellulari e "media" per compresse. Impostare questo parametro su "media" per avere i tasti del volume dell'app sempre cambiare il volume del contenuto multimediale. Si noti che quando si utilizza il plugin media di Cordova, i pulsanti del volume cambierà dinamicamente a controllo del volume di media quando tutti gli oggetti di Media sono attivi.
+
+*   `OverrideUserAgent` (stringa, non impostato per impostazione predefinita): se impostato, il valore sostituirà il vecchio UserAgent di webview. È utile identificare la richiesta dal browser e app quando si richiedono pagine remoti. Usare con cautela, questo maggio causa compitiable problema con server web. Per la maggior parte dei casi, utilizzare AppendUserAgent.
+
+        <preference name="OverrideUserAgent" value="Mozilla/5.0 My Browser" />
+
+
+*   `AppendUserAgent` (stringa, non impostato per impostazione predefinita): se impostato, il valore verrà aggiunte alla fine del vecchio UserAgent di webview. Quando si utilizza con OverrideUserAgent, questo valore verrà ignorato.
+
+        <preference name="AppendUserAgent" value="My Browser" />

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/it/7.x/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/android/index.md b/www/docs/it/7.x/guide/platforms/android/index.md
new file mode 100644
index 0000000..586dc8a
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/android/index.md
@@ -0,0 +1,276 @@
+---
+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 piattaforma Android
+toc_title: Android
+---
+
+# Guida piattaforma Android
+
+Questa guida illustra come impostare il tuo ambiente SDK per distribuire Cordova apps per dispositivi Android e come eventualmente utilizzare strumenti da riga di comando di Android-centrata nel vostro flusso di lavoro di sviluppo. È necessario installare il SDK di Android indipendentemente dal fatto se si desidera utilizzare questi strumenti centrato piattaforma shell o piattaforme Cordova CLI per lo sviluppo. Per un confronto tra i percorsi di due sviluppo, vedere la panoramica. Per ulteriori informazioni su CLI, vedere l'interfaccia della riga di comando.
+
+## Requisiti e supporto
+
+Cordova per Android richiede il SDK di Android che potrebbe essere installato sul sistema operativo OS X, Linux o Windows. Vedere sul SDK di Android [requisiti di sistema][1].
+
+ [1]: http://developer.android.com/sdk/index.html#Requirements
+
+Cordova supporta Android 4.0. x (a partire dal livello API Android 14) e superiori. Come regola generale, versioni Android diventano non supportati da Cordova come essi tuffo sotto il 5% di Google [dashboard di distribuzione][2]. Android versioni precedenti di API di livello 10, e le versioni 3. x (Honeycomb, livelli API 11-13) cadono significativamente inferiore a quella soglia del 5%.
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+## Installare strumenti di Cordova Shell
+
+Se si desidera utilizzare strumenti shell Android-centrata di Cordova in concomitanza con il SDK, scaricare Cordova da [cordova.apache.org][3]. In caso contrario ignorare questa sezione se si prevede di utilizzare lo strumento CLI multipiattaforma descritto in l'interfaccia della riga di comando.
+
+ [3]: http://cordova.apache.org
+
+Il download di Cordova contiene archivi separati per ciascuna piattaforma. Assicurarsi di espandere l'archivio appropriato, `android` in questo caso, all'interno di una directory vuota. L'utility eseguibile pertinenti sono disponibili nel primo livello `bin` directory. (Se necessario per indicazioni più dettagliate, consultare il file **Leggimi** .)
+
+Questi strumenti shell consentono di creare, compilare ed eseguire applicazioni Android. Per informazioni sull'interfaccia della riga di comando aggiuntiva che attiva il plugin funzionalità su tutte le piattaforme, vedere utilizzando Plugman per gestire i plugin. Per dettagli su come sviluppare plugin, vedere applicazione plugin.
+
+## Installare il Java Development Kit (JDK)
+
+Installare il [Java Development Kit (JDK) 7][4] o versioni successive.
+
+ [4]: http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
+
+Quando si installa su Windows è necessario anche impostare `JAVA_HOME` ambiente variabile secondo il percorso di installazione del JDK (ad esempio C:\Program Files\Java\jdk1.7.0_75).
+
+## Installare il SDK di Android
+
+Installare gli [strumenti di Android SDK autonomo][5] o [Studio Android][6]. Procceed con `Studio Android` se si prevede di sviluppare nuovo Cordova per Android plugin o utilizzando gli strumenti nativi di eseguire ed eseguire il debug piattaforma Android. In caso contrario, `Android strumenti SDK autonomo` sono sufficienti per creare e distribuire applicazioni Android.
+
+ [5]: http://developer.android.com/sdk/installing/index.html?pkg=tools
+ [6]: http://developer.android.com/sdk/installing/index.html?pkg=studio
+
+Istruzioni dettagliate sull'installazione sono disponibili come parte del link di installazione sopra.
+
+Per strumenti da riga di comando di Cordova a lavorare, o CLI che si basa su di loro, è necessario includere la directory di `strumenti` e `strumenti di piattaforma` di SDK nel tuo `percorso`. Su un Mac o Linux, è 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}:/Development/android-sdk/platform-tools:/Development/android-sdk/tools
+
+
+Questa linea in `~/.bash_profile` espone questi strumenti in windows terminal inaugurato di recente. Se la finestra del terminale è già aperta in OSX, o per evitare un logout/login su Linux, eseguire questo per renderli disponibili nella finestra del terminale corrente:
+
+        $ source ~/.bash_profile
+
+
+Per modificare il `PATH` in ambiente Windows:
+
+1.  Fare clic su **Start nell'angolo inferiore sinistro del desktop** , tasto destro del mouse su **Computer**, quindi selezionare **proprietà**.
+
+2.  Selezionare **Impostazioni di sistema avanzate** nella colonna a sinistra.
+
+3.  Nella finestra di dialogo risultante, premere **Le variabili di ambiente**.
+
+4.  Selezionare la variabile **PATH** e premere **Modifica**.
+
+5.  Aggiungere quanto segue per il `PATH` basato su cui è installato il SDK, per esempio:
+
+        ;C:\Development\android-sdk\platform-tools;C:\Development\android-sdk\tools
+
+
+6.  Salvare il valore e chiudere le due finestre di dialogo.
+
+## Installare i pacchetti SDK
+
+Aprire Android SDK Manager (ad esempio, tramite terminale: `android`) e installare:
+
+1.  5.1.1 Android (22 API) piattaforma SDK
+2.  Versione di Android SDK strumenti di compilazione 19.1.0 o superiore
+3.  Supporto Android Repository (extra)
+
+Per ulteriori informazioni, vedere [Installare pacchetti SDK][7] .
+
+ [7]: http://developer.android.com/sdk/installing/adding-packages.html
+
+## Configurare un emulatore
+
+Android sdk non fornisce alcuna istanza di emulatore predefinito per impostazione predefinita. È possibile creare una nuova eseguendo `android` sulla riga di comando. Stampa **Strumenti → gestire AVDs** (dispositivi Android virtuale), quindi scegliere qualsiasi elemento da **Definizioni di dispositivo** nella finestra di dialogo risultante:
+
+![][8]
+
+ [8]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_device.png
+
+Stampa **Creare AVD**, eventualmente modificando il nome, quindi premere **OK** per accettare le modifiche:
+
+![][9]
+
+ [9]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_newAVD.png
+
+L'AVD poi appare nell'elenco dei **Dispositivi Android virtuale** :
+
+![][10]
+
+ [10]: {{ site.baseurl }}/static/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]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_emulator.png
+
+Per un'esperienza più veloce, è possibile utilizzare l' `Accelerazione della macchina virtuale` per migliorare la velocità di esecuzione. Molte moderne CPU forniscono estensioni per eseguire macchine virtuali in modo più efficiente. Prima di utilizzare questo tipo di accelerazione, è necessario stabilire se la CPU del sistema attuale sviluppo, uno supporta le seguenti tecnologie di virtualizzazione:
+
+*   **Tecnologia di virtualizzazione Intel** (VT-x, vmx) → [Intel VT-x supportati elenco processore][12]
+*   **AMD Virtualization** (SVM, AMD-V), supportato solo per Linux (dal maggio 2006, tutte le CPU AMD includono AMD-V, ad eccezione di Sempron).
+
+ [12]: http://ark.intel.com/products/virtualizationtechnology
+
+Un altro modo per scoprire se il processore Intel supporta la tecnologia VT-x, si eseguendo l' `Utility di identificazione dei processori Intel`, per `Windows`è possibile scaricarlo dal [Download Center][13]di Intel, o è possibile utilizzare l' [utilità di avvio][14], che è `Indipendente dal sistema operativo`.
+
+ [13]: https://downloadcenter.intel.com/Detail_Desc.aspx?ProductID=1881&DwnldID=7838
+ [14]: https://downloadcenter.intel.com/Detail_Desc.aspx?ProductID=1881&DwnldID=7840&lang=eng
+
+Dopo installare ed eseguire la `Intel Processor Identification Utility` per Windows, si otterrà la seguente finestra, al fine di verificare se la tua CPU supporta le tecnologie di virtualizzazione:
+
+![][15]
+
+ [15]: {{ site.baseurl }}/static/img/guide/platforms/android/intel_pid_util_620px.png
+
+Al fine di accelerare l'emulatore, è necessario scaricare e installare una o più immagini di sistema `Atom Intel x86` , come pure l' `Intel Hardware accelerato l'esecuzione Manager (HAXM)`.
+
+Aprire il vostro Android SDK Manager e selezionare l'immagine di sistema `Atom Intel x86` , per qualsiasi versione che si desidera testare. Poi andare in `extra` selezionare `Intel x86 Emulator Accelerator (HAXM)`e installare questi pacchetti:
+
+![][16]
+
+ [16]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_man_intel_image_haxm.png
+
+Dopo il download, eseguire il programma di installazione di Intel, che è disponibile all'interno del vostro Android SDK in `Extra/intel/Hardware_Accelerated_Execution_Manager`. **Nota**:`se avete problemi installando il pacchetto, potete trovare ulteriori informazioni e istruzioni passo passo controllare questo` [Articolo Intel][17].
+
+ [17]: http://software.intel.com/en-us/android/articles/speeding-up-the-android-emulator-on-intel-architecture
+
+1.  Installare una o più immagini di sistema `Atom Intel x86` , come pure la `Gestione esecuzione accelerata Hardware di Intel`, disponibile sotto **extra**.
+
+2.  Eseguire il programma di installazione di Intel, che è disponibile all'interno del vostro Android SDK in `Extra/intel/Hardware_Accelerated_Execution_Manager`.
+
+3.  Creare un nuovo AVD con l'obiettivo di impostare un'immagine di Intel.
+
+4.  Quando si avvia l'emulatore, assicurarsi che non sono presenti messaggi di errore che indica un guasto per caricare i moduli HAX.
+
+## Creare un nuovo progetto
+
+A questo punto, per creare un nuovo progetto è possibile scegliere tra le piattaforme CLI strumento descritto in l'interfaccia della riga di comando, o il set di strumenti shell Android-specifiche. All'interno di una directory del codice sorgente, ecco l'approccio CLI:
+
+        $ cordova create hello com.example.hello HelloWorld
+        $ cd hello
+        $ cordova platform add android
+        $ cordova prepare              # or "cordova build"
+
+
+Qui è l'approccio di shell-strumento di basso livello corrispondente per Unix e Windows:
+
+        $ /path/to/cordova-android/bin/create /path/to/new/hello com.example.hello HelloWorld
+        C:\path\to\cordova-android\bin\create.bat C:\path\to\new\hello com.example.hello HelloWorld
+
+
+## Generare il progetto
+
+Se si utilizza la CLI in sviluppo, directory di primo livello `www` della directory progetto contiene i file di origine. Eseguire una qualsiasi di queste all'interno della directory di progetto per ricostruire l'app:
+
+        $ cordova build                   # build all platforms that were added
+        $ cordova build android           # build debug for only Android
+        $ cordova build android --debug   # build debug for only Android
+        $ cordova build android --release # build release for only Android
+
+
+Se si utilizza l'Android-shell strumenti specifici nello sviluppo, c'è un approccio diverso. Una volta che si genera il progetto, sorgente dell'app predefinita è disponibile nella sottodirectory `beni/www` . Comandi successivi sono disponibili nella sua sottodirectory di `cordova` .
+
+Il comando di `costruire` pulisce i file di progetto e ricostruisce l'app. Ecco la sintassi per Mac e Windows. La prima coppia di esempi genera informazioni di debug, e la seconda costruisce le apps per il rilascio:
+
+        $ /path/to/project/cordova/build --debug
+        C:\path\to\project\cordova\build.bat --debug
+
+        $ /path/to/project/cordova/build --release
+        C:\path\to\project\cordova\build.bat --release
+
+
+## Distribuire l'app
+
+È possibile utilizzare l'utilità di `cordova` CLI per distribuire l'applicazione nell'emulatore o il dispositivo da riga di comando:
+
+        $ cordova emulate android       #to deploy the app on a default android emulator
+        $ cordova run android --device  #to deploy the app on a connected device
+
+
+In caso contrario, utilizzare l'interfaccia shell alternativa:
+
+        $ /path/to/project/cordova/run --emulator
+        $ /path/to/project/cordova/run --device
+
+
+È possibile utilizzare **cordova run android --list** per vedere tutte le destinazioni disponibili e **cordova run android --target=target_name** per eseguire l'applicazione su un dispositivo specifico o l'emulatore (per esempio, `cordova run android --target="Nexus4_emulator"`).
+
+È possibile utilizzare anche **cordova run --help** vedere compilazione supplementari ed eseguire le opzioni.
+
+Questo spinge l'app alla schermata iniziale e si lancia:
+
+![][18]
+
+ [18]: {{ site.baseurl }}/static/img/guide/platforms/android/emulator2x.png
+
+Quando si `run` l'applicazione, è anche `build` esso. È possibile aggiungere ulteriori `--debug`, `--rilascio`e `--nobuild` flag per controllare come è costruito, o anche se una ricostruzione è necessaria:
+
+        $ /path/to/project/cordova/run --emulator --nobuild
+
+
+## Altri comandi
+
+Il seguente genera un log dettagliato delle app come funziona:
+
+        $ /path/to/project/cordova/log
+        C:\path\to\project\cordova\log.bat
+
+
+Il seguente pulisce i file di progetto:
+
+        $ /path/to/project/cordova/clean
+        C:\path\to\project\cordova\clean.bat
+
+
+## Aprire un nuovo progetto in SDK
+
+Una volta che la piattaforma android è aggiunto al progetto, è possibile aprirlo dall'interno [Studio Android][6]:
+
+1.  Lanciare l'applicazione **Android di Studio** .
+
+2.  Selezionare il **Progetto di importazione (Eclipse ADT, Gradle, ecc.)**.
+
+    ![][19]
+
+3.  Selezionare il percorso dove la piattaforma android è memorizzato (`tuo/progetto/platforms/android`).
+
+    ![][20]
+
+4.  Per la questione `Gradle Sync` si può semplicemente rispondere **Sì**.
+
+ [19]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_project.png
+ [20]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_select_location.png
+
+Sono tutti insieme ora e consente di compilare ed eseguire le app direttamente da `Android Studio`.
+
+![][21]
+
+ [21]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_done.png
+
+Vedere [Android Studio Overview][22] ed ed [ed eseguiti dalla Studio Android][23] per maggiori dettagli.
+
+ [22]: http://developer.android.com/tools/studio/index.html
+ [23]: http://developer.android.com/tools/building/building-studio.html

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/it/7.x/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/android/plugin.md b/www/docs/it/7.x/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..1f7dd94
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/android/plugin.md
@@ -0,0 +1,183 @@
+---
+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: Plugin Android
+toc_title: Android
+---
+
+# 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](../../../cordova/events/events.pause.html)` e `[resume](../../../cordova/events/events.resume.html)` 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 >, < servizio >, < azione >, [< 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 corrispondente plugin Java è 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/5ad93d20/www/docs/it/7.x/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/android/tools.md b/www/docs/it/7.x/guide/platforms/android/tools.md
new file mode 100644
index 0000000..26fb4c1
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/android/tools.md
@@ -0,0 +1,205 @@
+---
+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: Shell Android strumento guida
+---
+
+# Shell Android strumento guida
+
+Questa guida illustra come utilizzare set di Cordova di piattaforma-centrato shell strumenti per sviluppare applicazioni Android. Questo percorso di sviluppo, discusso nella panoramica, può offrire una maggiore gamma di opzioni di sviluppo che le piattaforme CLI strumento descritto in l'interfaccia della riga di comando. Ad esempio, è necessario utilizzare strumenti di shell quando si distribuisce un'usanza Cordova WebView accanto alle componenti nativi. Prima di utilizzare qualsiasi percorso di sviluppo, è innanzitutto necessario configurare l'ambiente Android SDK come descritto nella guida alla piattaforma Android.
+
+Per attivare strumenti di shell per Android, scaricare Cordova da [cordova.apache.org][1]. Il download contiene archivi separati per ciascuna piattaforma. Espandere ciascuna si desidera fare riferimento, `android` in questo caso. Gli strumenti pertinenti sono in genere disponibili nel primo livello `bin` directory, altrimenti consultare il file **Leggimi** per ulteriori indicazioni.
+
+ [1]: http://cordova.apache.org
+
+Questi strumenti consentono di creare, compilare ed eseguire applicazioni Android. Per informazioni sull'interfaccia della riga di comando aggiuntiva che attiva il plugin funzionalità su tutte le piattaforme, vedere utilizzando Plugman per gestire i plugin. Per dettagli su come sviluppare plugin, 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/Linux e Windows:
+
+        $ /path/to/cordova-android/bin/create /path/to/project com.example.project_name ProjectName
+    
+        C:\>\path\to\cordova-android\bin\create.bat \path\to\project com.example.project_name ProjectName
+    
+
+## Costruire
+
+Questo pulisce poi costruisce un progetto.
+
+Debug, su Windows o Mac/Linux:
+
+        $ /path/to/project/cordova/build --debug
+    
+        C:\>\path\to\project\cordova\build.bat --debug
+    
+
+Rilascio, su Windows o Mac/Linux:
+
+        $ /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 [Target] [Build]
+        
+        C:\>\path\to\project\cordova\run.bat [Target] [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.
+
+## Firma l'App
+
+È possibile rivedere Android app firma requisiti qui: http://developer.android.com/tools/publishing/app-signing.html
+
+Per firmare un'applicazione, è necessario i seguenti parametri:
+
+*   Keystore ( `--keystore` ): percorso di un file binario che può contenere un insieme di chiavi.
+
+*   Password del keystore ( `--storePassword` ): Password per l'archivio chiavi
+
+*   Alias ( `--alias` ): l'id che specifica la chiave privata utilizzata per il canto.
+
+*   Password ( `--password` ): Password per la chiave privata specificata.
+
+*   Tipo del keystore ( `--keystoreType` ): pkcs12, jks (Default: rilevamento automatico basato sull'estensione del file)
+
+Questi parametri possono essere specificati utilizzando gli argomenti della riga di comando sopra a `build` o `run` script.
+
+In alternativa, è possibile specificare loro in un file (build.json) di configurazione compilazione utilizzando ( `--buildConfig` ) argomento. Ecco un esempio di un file di configurazione di compilazione:
+
+    {
+         "android": {
+             "debug": {
+                 "keystore": "..\android.keystore",
+                 "storePassword": "android",
+                 "alias": "mykey1",
+                 "password" : "password",
+                 "keystoreType": ""
+             },
+             "release": {
+                 "keystore": "..\android.keystore",
+                 "storePassword": "",
+                 "alias": "mykey2",
+                 "password" : "password",
+                 "keystoreType": ""
+             }
+         }
+     }
+    
+
+Per la firma di rilascio, le password possono essere esclusi e il sistema di compilazione emetterà un avviso chiedendo la password.
+
+C'è anche il supporto di mescolare e abbinare gli argomenti della riga di comando e i parametri nel file di build.json. Valori da argomenti della riga di comando avranno la precedenza. Questo può essere utile per specificare le password sulla riga di comando.
+
+## 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
+    
+
+## Compilazione con Gradle
+
+A partire dal cordova-android@4.0.0, compilazione di progetto utilizzando [Gradle][2]. Per istruzioni sull'edificio con ANT, fare riferimento alle versioni precedenti della documentazione.
+
+ [2]: http://www.gradle.org/
+
+### Proprietà Gradle
+
+Queste [Proprietà][3] possono essere impostate per personalizzare la compilazione:
+
+ [3]: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
+
+*   **cdvBuildMultipleApks** (impostazione predefinita: false)
+    
+    Se questo è impostato, quindi verranno generati i file APK multipli: uno per ogni piattaforma nativa supportata da progetti libreria (x86, ARM, ecc). Questo può essere importante se il progetto utilizza grandi librerie native, che possono aumentare drasticamente le dimensioni dell'APK generato.
+    
+    Se non è impostata, quindi verrà generato un APK singola che può essere utilizzato su tutti i dispositivi.
+
+*   **cdvVersionCode**
+    
+    Esegue l'override di versionCode impostata`AndroidManifest.xml`
+
+*   **cdvReleaseSigningPropertiesFile** (impostazione predefinita: rilascio-signing.properties)
+    
+    Percorso di un file. Properties che contiene informazioni di firma per rilascio costruisce. Il file dovrebbe essere simile:
+    
+        storeFile=relative/path/to/keystore.p12
+        storePassword=SECRET1
+        storeType=pkcs12
+        keyAlias=DebugSigningKey
+        keyPassword=SECRET2
+        
+    
+    `storePassword`e `keyPassword` sono facoltativi e verrà chiesto se omesso.
+
+*   **cdvDebugSigningPropertiesFile** (impostazione predefinita: debug-signing.properties)
+    
+    Come cdvReleaseSigningPropertiesFile, ma per il debug si basa. Utile quando è necessario condividere una chiave di firma con altri sviluppatori.
+
+*   **cdvMinSdkVersion**
+    
+    Sostituisce il valore di `minSdkVersion` nella `AndroidManifest.xml` . Utile quando si creano più APKs basato sulla versione SDK.
+
+*   **cdvBuildToolsVersion**
+    
+    Eseguire l'override rilevato automaticamente `android.buildToolsVersion` valore.
+
+*   **cdvCompileSdkVersion**
+    
+    Eseguire l'override rilevato automaticamente `android.compileSdkVersion` valore.
+
+### Estensione build.gradle
+
+Se avete bisogno di personalizzare `build.gradle` , piuttosto che modificare direttamente, è necessario creare un file di pari livello denominato `build-extras.gradle` . Questo file verrà incluso dai principali `build.gradle` quando è presente. Ecco un esempio:
+
+    # Example build-extras.gradle
+    # This file is included at the beginning of `build.gradle`
+    ext.cdvDebugSigningPropertiesFile = '../../android-debug-keys.properties'
+    # When set, this function allows code to run at the end of `build.gradle`
+    ext.postBuildExtras = {
+        android.buildTypes.debug.applicationIdSuffix = '.debug'
+    }
+    
+
+Si noti che il plugin può anche includere `build-extras.gradle` file tramite:
+
+    <framework src="some.gradle" custom="true" type="gradleReference" />
+    
+
+### Esempio di compilazione
+
+    export ORG_GRADLE_PROJECT_cdvMinSdkVersion=14
+    cordova build android -- --gradleArg=-PcdvBuildMultipleApks=true
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/5ad93d20/www/docs/it/7.x/guide/platforms/android/upgrade.md
----------------------------------------------------------------------
diff --git a/www/docs/it/7.x/guide/platforms/android/upgrade.md b/www/docs/it/7.x/guide/platforms/android/upgrade.md
new file mode 100644
index 0000000..27d110e
--- /dev/null
+++ b/www/docs/it/7.x/guide/platforms/android/upgrade.md
@@ -0,0 +1,500 @@
+---
+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'aggiornamento di Android
+---
+
+# 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](../../cli/index.html) per informazioni, vedere come aggiornare la versione di CLI.
+
+## L'aggiornamento a 4.0.0
+
+Ci sono passaggi di aggiornamento specifici necessari per sfruttare i cambiamenti significativi in 4.0.0. In primo luogo, le comuni operazioni di aggiornamento sono necessari come sotto.
+
+Per i progetti non-CLI, eseguire:
+
+        bin/update percorso/per/progetto
+    
+
+Per i progetti CLI:
+
+1.  Aggiornamento del `cordova` versione CLI. Vedere l'interfaccia della riga di comando.
+
+2.  Eseguire `cordova platform update android` nei progetti esistenti.
+
+### L'aggiornamento della Whitelist
+
+Tutte le funzionalità di whitelist è ora implementata tramite plugin. Senza un plugin, l'app non è più protetto da una whitelist dopo l'aggiornamento a 4.0.0. Cordova ha due plugin whitelist, che forniscono diversi livelli di protezione.
+
+1.  Il plugin di `cordova-plugin-whitelist` *(consigliato)*
+    
+    *   Questo plugin è altamente raccomandato, come è più sicuro e configurabile di whitelist nelle versioni precedenti
+    *   Vedere [cordova-plugin-whitelist][1] per dettagli sulle modifiche di configurazione necessarie
+    *   Eseguire: `cordova plugin add cordova-plugin-crosswalk-webview`
+
+2.  Il plugin di `cordova-plugin-eredità-whitelist`
+    
+    *   Questo plugin fornisce lo stesso comportamento di whitelist come le versioni precedenti. Vedere [cordova-plugin-legacy-whitelist][2]
+    *   Nessuna modifica di configurazione è necessaria, ma offre meno protezione rispetto il plugin consigliato
+    *   Eseguire: `cordova plugin add cordova-plugin-legacy-whitelist`
+
+ [1]: https://github.com/apache/cordova-plugin-whitelist
+ [2]: https://github.com/apache/cordova-plugin-legacy-whitelist
+
+### Utilizzando il Crosswalk WebView
+
+Per impostazione predefinita, l'app continua a utilizzare il sistema WebView previsto dal dispositivo. Se si desidera invece utilizzare WebView Crosswalk, basta aggiungere il plugin Crosswalk:
+
+    cordova plugin add cordova-plugin-crosswalk-webview
+    
+
+Dopo l'aggiunta di plugin, app otterrà WebView Crosswalk installato e configurato correttamente.
+
+### L'aggiornamento per il Plugin di Splashscreen
+
+Se l'app fa uso di una schermata iniziale, che la funzionalità è stata spostata in un plugin. Le opzioni di configurazione per schermate iniziali sono invariate. Il passaggio di solo aggiornamento richiesto è quello di aggiungere il plugin:
+
+    cordova plugin add cordova-plugin-splashscreen
+    
+
+## L'aggiornamento alla 3.7.1 da 3.6.0
+
+Per i progetti non-CLI, eseguire:
+
+        bin/update percorso/per/progetto
+    
+
+Per i progetti CLI:
+
+1.  Aggiornamento del `cordova` versione CLI. Vedere l'interfaccia della riga di comando.
+
+2.  Eseguire `cordova platform update android` nei progetti esistenti.
+
+## L'aggiornamento a 3.3.0 da 3.2.0
+
+Seguire le stesse istruzioni per quanto riguarda `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 il progetto `MyProject CordovaLib` appena aggiunto nella loro area di lavoro.
+
+## L'aggiornamento a 3.2.0 da 3.1.0
+
+Per i progetti che sono stati creati con la CLI, cordova:
+
+1.  Aggiornamento il `cordova` versione CLI. Vedere l'interfaccia della riga di comando.
+
+2.  Eseguire `cordova platform update android`
+
+Per i progetti non creati con la CLI, cordova, eseguire:
+
+        bin/update <project_path>
+    
+
+**ATTENZIONE:** A 4.4 Android - Android 4.4.3, creando un file di input elemento con tipo = "file" non si apre la finestra di dialogo di selezione file. Questa è una regressione con cromo su Android e il problema può essere riprodotto nel browser Chrome standalone su Android (vedi http://code.google.com/p/android/issues/detail?id=62220) la soluzione suggerita è di usare il plugin FileTransfer e File per Android 4.4. È possibile attendere un evento onClick dal tipo di input = "file" e poi aprirà una selezione di file UI. Per legare i dati del modulo con il caricamento, è possibile utilizzare JavaScript per fissare i valori in formato multi-parte richiesta POST che rende FileTransfer.
+
+## L'aggiornamento a 3.1.0 da 3.0.0
+
+Per i progetti che sono stati creati con la CLI, cordova:
+
+1.  Aggiornamento il `cordova` versione CLI. Vedere l'interfaccia della riga di comando.
+
+2.  Eseguire `cordova platform update android`
+
+Per i progetti non creati con la CLI, 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 della directory `www` del progetto alla radice del progetto cordova che appena creata nella directory `www` .
+
+4.  Copiare qualsiasi attività nativo dal tuo vecchio progetto nella directory appropriate sotto `piattaforme/android`: è la directory dove esiste il tuo progetto di cordova-android nativo.
+
+5.  Utilizzare lo strumento CLI cordova per installare alcun plugin che necessario. Si noti che il CLI gestisce tutti i core API come plugin, quindi potrebbero dover essere aggiunto. 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 della directory `www` nel nuovo progetto.
+
+3.  Copiare qualsiasi attività Android nativo dalla directory `res` al nuovo progetto.
+
+4.  Copiare qualsiasi plugin installato dalla sottodirectory `src` nel nuovo progetto.
+
+5.  Assicurati di aggiornare qualsiasi deprecato `< plugin >` riferimenti dal file `config. xml` vecchia per la nuova `di <feature>` specifica.
+
+6.  Aggiornare tutti i riferimenti al pacchetto `org.apache.cordova.api` essere `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.
+
+## L'aggiornamento a 2.9.0 da 2.8.0
+
+1.  Run `bin/update <project_path>`.
+
+## L'aggiornamento a 2.8.0 da 2.7.0
+
+1.  Rimuovere `cordova-2.7.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.8.0.jar` directory `libs` del progetto.
+
+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 file di `cordova.js` .
+
+3.  Copia il file `res/xml/config.xml` 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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.7.0.jar` directory `libs` del progetto.
+
+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 file di `cordova-2.7.0.js` .
+
+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.
+
+## L'aggiornamento a 2.6.0 da 2.5.0
+
+1.  Rimuovere `cordova-2.5.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.6.0.jar` directory `libs` del progetto.
+
+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 < progetto >` con il percorso del progetto elencato nella directory dei sorgenti di Cordova.
+
+## L'aggiornamento a 2.5.0 da 2.4.0
+
+1.  Rimuovere `cordova-2.4.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.5.0.jar` directory `libs` del progetto.
+
+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.
+
+## L'aggiornamento a 2.4.0 da 2.3.0
+
+1.  Rimuovere `cordova-2.3.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.4.0.jar` directory `libs` del progetto.
+
+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.
+
+## L'aggiornamento a 2.3.0 da 2.2.0
+
+1.  Rimuovere `cordova-2.2.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.3.0.jar` directory `libs` del progetto.
+
+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.
+
+## L'aggiornamento alla 2.2.0 da 2.1.0
+
+1.  Rimuovere `cordova-2.1.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.2.0.jar` directory `libs` del progetto.
+
+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.
+
+## L'aggiornamento a 2.1.0 da 2.0.0
+
+1.  Rimuovere `cordova-2.0.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.1.0.jar` directory `libs` del progetto.
+
+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` da abbinare`framework/res/xml/config.xml`.
+
+7.  Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+
+## L'aggiornamento a 2.0.0 da 1.9.0
+
+1.  Rimuovere `cordova-1.9.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-2.0.0.jar` directory `libs` del progetto.
+
+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` da abbinare`framework/res/xml/config.xml`.
+
+Nella 2.0.0 release, il file `config. xml` unisce e sostituisce `cordova.xml` e `plugins`. 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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.9.0.jar` directory `libs` del progetto.
+
+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 file di `cordova-1.9.0.js` .
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.8.1.jar` directory `libs` del progetto.
+
+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 file di `cordova-1.8.1.js` .
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.8.0.jar` directory `libs` del progetto.
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.8.0.jar` directory `libs` del progetto.
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.7.0.jar` directory `libs` del progetto.
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.6.1.jar` directory `libs` del progetto.
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.6.0.jar` directory `libs` del progetto.
+
+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 file di `cordova-1.6.0.js` .
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Sostituire `res/xml/phonegap.xml` con `res/xml/cordova.xml` corrispondenza `framework/res/xml/cordova.xml`.
+
+## Aggiornamento a 1.5.0 da 1.4.0
+
+1.  Rimuovere `phonegap-1.4.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `cordova-1.5.0.jar` directory `libs` del progetto.
+
+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 file di `cordova-1.5.0.js` .
+
+6.  Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
+
+7.  Sostituire `res/xml/phonegap.xml` con `res/xml/cordova.xml` corrispondenza `framework/res/xml/cordova.xml`.
+
+## Aggiornamento a 1.4.0 da 1.3.0
+
+1.  Rimuovere `phonegap-1.3.0.jar` dalla directory `libs` del progetto.
+
+2.  Aggiungi `phonegap-1.4.0.jar` directory `libs` del progetto.
+
+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 file `phonegap-1.4.0.js` .
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `phonegap-1.3.0.jar` directory `libs` del progetto.
+
+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 file `phonegap-1.2.0.js` .
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `phonegap-1.2.0.jar` directory `libs` del progetto.
+
+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 file `phonegap-1.2.0.js` .
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `phonegap-1.1.0.jar` directory `libs` del progetto.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto di Eclipse e fare una pulizia.
+
+4.  Copiare il nuovo `phonegap-1.1.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo file `phonegap-1.1.0.js` .
+
+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` dalla directory `libs` del progetto.
+
+2.  Aggiungi `phonegap-1.0.0.jar` directory `libs` del progetto.
+
+3.  Se si utilizza Eclipse, si prega di aggiornare il progetto di Eclipse e fare una pulizia.
+
+4.  Copiare il nuovo `phonegap-1.0.0.js` nel vostro progetto.
+
+5.  Aggiorna il tuo HTML per utilizzare il nuovo file `phonegap-1.0.0.js` .
+
+6.  Aggiungere il `res/xml/plugins.xml` corrispondenza `framework/res/xml/plugins.xml`.
\ 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