You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@cordova.apache.org by sh...@apache.org on 2014/01/30 22:21:21 UTC
[29/57] [abbrv] CB-5931 1/28 push latest of edge for Italian Cordova
3.4
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/android/plugin.md b/docs/it/edge/guide/platforms/android/plugin.md
index 4c99354..ec8bd6d 100644
--- a/docs/it/edge/guide/platforms/android/plugin.md
+++ b/docs/it/edge/guide/platforms/android/plugin.md
@@ -16,148 +16,161 @@ license: Licensed to the Apache Software Foundation (ASF) under one or more cont
# Plugin Android
-Scrivere un plugin richiede una comprensione dell'architettura di Cordova-Android. Cordova-Android è costituito da una WebView Android con ganci collegati ad esso. Questi plugin sono rappresentati come mapping di classe nella `config.xml` file.
+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].
-Un plugin è costituito da almeno una classe Java che estende la `CordovaPlugin` classe. Un plugin deve eseguire l'override di uno dei `execute` metodi da `CordovaPlugin` . Come migliore pratica, dovrebbe gestire il plugin `pause` e `resume` eventi e 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.
+ [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
-La parte di JavaScript di un plugin utilizza sempre il `cordova.exec` metodo come segue:
+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:
- exec(<successFunction>, <failFunction>, <service>, <action>, [<args>]);
+ <feature name="<service_name>">
+ <param name="android-package" value="<full_name_including_namespace>" />
+ </feature>
-Questo esegue il marshalling di una richiesta da WebView sul lato nativo Android, più o meno bollente giù a chiamare il `action` metodo sul `service` classe, con gli argomenti passati nella `args` matrice.
+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.
-Se si distribuiscono vostro plugin come Java file o come un vaso proprio, deve essere aggiunto il plugin per la `config.xml` file nell'applicazione Android-Cordova `res/xml/` directory.
+## Durata e inizializzazione di Plugin
- <feature name="<service_name>">
+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>
-Il nome del servizio deve corrispondere a quello utilizzato in JavaScript `exec` chiamata e il valore è il nome completo della classi Java, tra cui lo spazio dei nomi. Altrimenti il plugin può compilare ma comunque irraggiungibile di Cordova.
+Plugin dovrebbe usare il `initialize` metodo per la loro logica di avviamento.
-## Scrivere un Plugin Java Android
+ @override
+ public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+ super.initialize(cordova, webView);
+ // your init code here
+ }
+
-JavaScript genera una richiesta di plugin al lato nativo. Il plugin Java Android è mappato correttamente tramite il `config.xml` file. Così ciò che fa apparire la classe finale di Android Java Plugin come?
+## Scrivere un Plugin Java Android
-Che cosa ottiene spedito al plugin tramite di JavaScript `exec` funzione viene passato in classe Plugin `execute` metodo. La maggior parte dei `execute` implementazioni assomigliano a questo:
+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".
- }
+ @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".
+ }
-Confrontiamo il valore dei `action` parametro e invio richiesta fuori per un metodo (privato) nella classe, facoltativamente passando alcuni dei parametri al metodo.
+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
+## Filettatura
-JavaScript in WebView fa *non* eseguito sul thread dell'interfaccia utente. Esso viene eseguito sul thread WebCore. Il `execute` metodo gestisce anche sul thread WebCore.
+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:
-Se avete bisogno di interagire con l'interfaccia utente, è necessario utilizzare il seguente:
-
- @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;
+ @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;
}
- return false;
- }
-Se non è necessario per l'esecuzione sul thread dell'interfaccia utente, ma non voglio bloccare il thread WebCore:
+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;
+ @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;
}
- return false;
- }
-### Esempio di Plugin Android echo
+## Esempio di Plugin Android echo
-Aggiungere quanto segue al nostro `config.xml` file:
+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:
- <feature name="Echo">
- <param name="android-package" value="org.apache.cordova.plugin.Echo" />
- </feature>
+ <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 seguente file `src/org/apache/cordova/plugin/Echo.java` all'interno della nostra applicazione Android-Cordova:
+Quindi aggiungere il codice seguente per la `src/org/apache/cordova/plugin/Echo.java` file:
- package org.apache.cordova.plugin;
+ package org.apache.cordova.plugin;
- import org.apache.cordova.CordovaPlugin;
- import org.apache.cordova.CallbackContext;
+ import org.apache.cordova.CordovaPlugin;
+ import org.apache.cordova.CallbackContext;
- import org.json.JSONArray;
- import org.json.JSONException;
- import org.json.JSONObject;
+ 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 {
+ /**
+ * 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;
+ @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;
}
- 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.");
+ 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.");
+ }
}
}
- }
-Diamo un'occhiata al codice. Il necessario `imports` sono al top. La nostra classe si estende da `CordovaPlugin` . Abbiamo l'override del metodo Execute () al fine di ricevere messaggi da exec (). Il nostro metodo confronta prima contro `action` : questo plugin supporta solo un'azione, la `echo` azione. Qualsiasi altra azione restituisce `false` , che si traduce in un errore di tipo `INVALID_ACTION` , che si traduce in una chiamata di callback errore sul lato JavaScript. Successivamente, si afferra l'eco stringa utilizzando il `getString` metodo sul nostro `args` , dicendo che vogliamo ottenere il parametro 0A nella matrice di parametri. Facciamo un po' di controllo parametro: assicurarsi che non è `null` e assicurarsi che non è una stringa di lunghezza zero. Se è, che noi chiamiamo `callbackContext.error()` (che, ormai, dovresti sapere richiama il callback di errore). Se tutti quei controlli passano, poi chiamiamo `callbackContext.success()` e passare il `message` abbiamo ricevu
to come parametro di stringa. Questo si traduce infine in una chiamata di callback di successo sul lato JavaScript. Passa anche il `message` parametro come parametro nella funzione di callback successo JavaScript.
-
-## Plugin debug
-
-Eclipse può essere utilizzato per eseguire il debug un progetto Android, e il plugin può eseguire il debug se il sorgente Java è incluso nel progetto. Per consentire l'attaccamento di codice sorgente alle dipendenze del vaso, quindi questo non è completamente supportato in questo momento è conosciuto solo l'ultima versione di Android strumenti di sviluppo.
-
-## Trabocchetti comuni
-
-* Plugin hanno accesso a un `CordovaInterface` oggetto. Questo oggetto ha accesso all'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 la `Intent` Torna all'applicazione. Questo è importante, dal momento che il `Intent` sistema s è come Android comunica tra processi.
+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.
-* Plugin non hanno accesso diretto alla `Context` che hanno in passato. L'eredità `ctx` membro è obsoleto e verrà rimosso sei mesi dopo 2.0 è rilasciato. Tutti i `ctx` metodi esistano sulla `Context` , così entrambi `getContext()` e `getActivity()` sono in grado di restituire l'oggetto corretto richiesto.
+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.
-## Utilizzare la fonte
+## Integrazione Android
-Uno dei modi migliori per prepararsi a scrivere il tuo plugin è di [guardare oltre i plugin esistenti][1].
+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.
- [1]: https://github.com/apache/cordova-android/tree/master/framework/src/org/apache/cordova
+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.
-È inoltre necessario leggere i commenti di [CordovaPlugin.java][2].
+## Plugin Android debug
- [2]: https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
\ No newline at end of file
+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/60194dbe/docs/it/edge/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/android/tools.md b/docs/it/edge/guide/platforms/android/tools.md
index a27e63f..340c9c7 100644
--- a/docs/it/edge/guide/platforms/android/tools.md
+++ b/docs/it/edge/guide/platforms/android/tools.md
@@ -20,6 +20,8 @@ Il `cordova` l'utilità della riga di comando è uno strumento ad alto livello c
[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:
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/android/upgrading.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/android/upgrading.md b/docs/it/edge/guide/platforms/android/upgrading.md
index 5829317..b6a966b 100644
--- a/docs/it/edge/guide/platforms/android/upgrading.md
+++ b/docs/it/edge/guide/platforms/android/upgrading.md
@@ -18,22 +18,43 @@ license: Licensed to the Apache Software Foundation (ASF) under one or more cont
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
+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:
-1. `bin/aggiornamento < project_path >`
+ 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. Aggiungi il tua piattaforme il progetto il cordova, ad esempio:`cordova
+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.
@@ -55,8 +76,8 @@ platform add android`.
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.
+
+ **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
@@ -68,17 +89,19 @@ platform add android`.
2. Aggiungi `cordova-2.8.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+3. Se si utilizza Eclipse, si prega di aggiornare il progetto Eclipse e fare una pulita.
-4. Copiare il nuovo `cordova.js` nel vostro progetto.
+<!-- SS Eclipse -->
-5. Aggiorna il tuo HTML per utilizzare il nuovo `cordova.js` file.
+1. Copiare il nuovo `cordova.js` nel vostro progetto.
-6. Copia il `res/xml/config.xml` file per abbinare`framework/res/xml/config.xml`.
+2. Aggiorna il tuo HTML per utilizzare il nuovo `cordova.js` file.
-7. Aggiornamento `framework/res/xml/config.xml` per avere impostazioni simili, come ha fatto in precedenza.
+3. Copia il `res/xml/config.xml` file per abbinare`framework/res/xml/config.xml`.
-8. Copiare i file da `bin/templates/cordova` per il progetto `cordova` directory.
+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
@@ -86,7 +109,7 @@ platform add android`.
2. Aggiungi `cordova-2.7.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -104,7 +127,7 @@ platform add android`.
2. Aggiungi `cordova-2.6.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -124,7 +147,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-2.5.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -142,7 +165,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-2.4.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -158,7 +181,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-2.3.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -174,7 +197,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-2.2.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -190,7 +213,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-2.1.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -206,7 +229,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-2.0.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -214,9 +237,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
6. Copia il `res/xml/config.xml` corrispondere`framework/res/xml/config.xml`.
-### Note sui 2.0.0 rilasciare
-
-`config.xml`sarà essere sostituendo `cordova.xml` e `plugins.xml` . Questo nuovo file è una combinazione delle due precedenti. Tuttavia, i vecchi file sono obsolete e mentre funzionano attualmente ancora, cesserà lavorando in una versione futura.
+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
@@ -224,7 +245,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
2. Aggiungi `cordova-1.9.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -232,9 +253,7 @@ Eseguire `bin/update <project>` con il percorso del progetto elencati nella dire
6. Aggiornamento `res/xml/plugins.xml` per abbinare`framework/res/xml/plugins.xml`.
-### Note sui 1.9.0 rilasciare
-
-A causa dell'introduzione della `CordovaWebView` , 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.
+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
@@ -242,7 +261,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.8.1.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -256,7 +275,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.8.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -270,7 +289,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.8.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -284,7 +303,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.7.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -296,7 +315,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.6.1.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -308,7 +327,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.6.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -324,7 +343,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `cordova-1.5.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -340,7 +359,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `phonegap-1.4.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -356,7 +375,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `phonegap-1.3.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -372,7 +391,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `phonegap-1.2.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -388,7 +407,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `phonegap-1.1.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
@@ -402,7 +421,7 @@ A causa dell'introduzione della `CordovaWebView` , plugin di terze parti potrebb
2. Aggiungi `phonegap-1.0.0.jar` al progetto `libs` directory.
-3. Se si utilizza Eclipse, si prega di aggiornare il vostro progetto di eclipse e fare una pulita.
+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.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/android/webview.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/android/webview.md b/docs/it/edge/guide/platforms/android/webview.md
index 6a83a2a..7842eab 100644
--- a/docs/it/edge/guide/platforms/android/webview.md
+++ b/docs/it/edge/guide/platforms/android/webview.md
@@ -16,23 +16,17 @@ license: Licensed to the Apache Software Foundation (ASF) under one or more cont
# Visualizzazioni Web Android
-Partire da 1,9 a Cordova, con l'assistenza della `CordovaActivity` , è possibile utilizzare Cordova come componente di un'applicazione Android nativa più grande. Android si riferisce a questo componente come il `CordovaWebView` . Nuove applicazioni basate su Cordova da 1,9 in poi utilizzano il `CordovaWebView` come visualizzazione principale, indipendentemente dal fatto che l'eredità `CordovaActivity` approccio viene utilizzato.
+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 lo sviluppo di applicazioni Android, Android piattaforma guida allo sviluppo di un'applicazione di Cordova prima di tentare di comprendere un WebView. Non è il modo principale per creare applicazioni Android Cordova. Queste istruzioni sono attualmente manuale, ma può essere eventualmente essere automatizzato.
+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.
-## Prerequisiti
+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.
-* Cordova 1,9 o maggiore
+2. Spostarsi del package Android `/framework` directory ed eseguire `ant jar` . Crea il Cordova `.jar` file, costituita come`/framework/cordova-x.x.x.jar`.
-* Android SDK aggiornato all'ultimo SDK
+3. Copia il `.jar` file al progetto Android `/libs` directory.
-## Guida all'utilizzo di CordovaWebView in un progetto Android
-
-1. `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.
-
-2. Copiare il barattolo di cordova nel vostro progetto Android `/libs` directory.
-
-3. Modifica dell'applicazione `main.xml` file (sotto `/res/xml` ) per essere simile alla seguente, con la `layout_height` , `layout_width` e `id` modificato per soddisfare la vostra applicazione:
+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"
@@ -40,7 +34,7 @@ Se si ha familiarità con lo sviluppo di applicazioni Android, Android piattafor
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:
+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;
@@ -55,8 +49,8 @@ Se si ha familiarità con lo sviluppo di applicazioni Android, Android piattafor
}
-Se si utilizza la fotocamera, è necessario implementare anche questo:
-
+6. Se l'applicazione deve utilizzare la fotocamera, implementare le seguenti:
+
@Override
public void setActivityResultCallback(CordovaPlugin plugin) {
this.activityResultCallback = plugin;
@@ -72,16 +66,16 @@ Se si utilizza la fotocamera, è necessario implementare anche questo:
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,
@@ -99,16 +93,18 @@ Se si utilizza la fotocamera, è necessario implementare anche questo:
callback.onActivityResult(requestCode, resultCode, intent);
}
}
-
-
-Infine, ricordarsi di aggiungere il pool di thread, altrimenti il plugin non hanno nessun thread per eseguire:
+
+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.
-1. Copiare i file dell'applicazione HTML e JavaScript del progetto Android `/assets/www` directory.
+9. Copia il `config.xml` del file da `/framework/res/xml` per il progetto `/res/xml` directory.
-2. Copia `config.xml` dal `/framework/res/xml` al tuo progetto `/res/xml` directory.
\ No newline at end of file
+ [1]: http://cordova.apache.org
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/blackberry10/config.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/blackberry10/config.md b/docs/it/edge/guide/platforms/blackberry10/config.md
index 7fc56e9..c4d1426 100644
--- a/docs/it/edge/guide/platforms/blackberry10/config.md
+++ b/docs/it/edge/guide/platforms/blackberry10/config.md
@@ -14,7 +14,7 @@ license: Licensed to the Apache Software Foundation (ASF) under one or more cont
under the License.
---
-# Configurazione di blackBerry
+# Configurazione di blackBerry 10
La `config.xml` file controlla le impostazioni di base di un'app che si applicano a ogni applicazione e istanza di CordovaWebView. Le preferenze di dettagli questa sezione che si applicano solo a BlackBerry 10 costruisce. Vedere il file config. XML File per informazioni sulle opzioni di configurazione globale.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/blackberry10/index.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/blackberry10/index.md b/docs/it/edge/guide/platforms/blackberry10/index.md
index 5730191..de25fd3 100644
--- a/docs/it/edge/guide/platforms/blackberry10/index.md
+++ b/docs/it/edge/guide/platforms/blackberry10/index.md
@@ -36,17 +36,13 @@ Su Windows:
* Aggiungere la directory di installazione di SDK nativo al percorso, ad esempio:
- ;C:\bbndk\host\_10\_1\_0\_132\darwin\x86\usr\bin\
+ ;C:\bbndk\host\_10\_2\_0\_132\darwin\x86\usr\bin\
Su Mac e Linux:
* Modificare il `~/.bash_profile` file, aggiungendo una riga come la seguente, a seconda di dove è stato installato il SDK nativo:
- esportazione $ PATH = ${PATH}: / applicazioni/bbndk/host\_10\_1\_0\_132/darwin/x86/usr/bin /
-
- o per il SDK nativo 10.2:
-
- esportazione di $ PATH=${PATH}:/Applications/Momentics.app/host\_10\_2\_0\_15/darwin/x86/usr/bin/
+ $ export PATH=${PATH}:/Applications/Momentics.app/host\_10\_2\_0\_15/darwin/x86/usr/bin/
* Eseguire le operazioni seguenti per applicare la modifica nella sessione corrente:
@@ -56,22 +52,25 @@ Su Mac e Linux:
Se si desidera testare su un dispositivo o distribuire applicazioni attraverso BlackBerry World, il sistema deve essere setup per la firma del codice.
-Per ottenere una chiave di firma, visitare il sito Web di BlackBerry e assicurarsi di mantenere la password specificata. Quindi eseguire il `blackberry-signer` utilità che è incluso con il SDK nativo BlackBerry.
+Per ottenere una chiave di firma, andare a \[BlackBerry chiavi modulo d'ordine\] (https://www.blackberry.com/SignedKeys/codesigning.html).
-Istruzioni dettagliate possono essere trovate qui:
+Selezionare la prima opzione: "per le applicazioni di BlackBerry10 sviluppati utilizzando BlackBerry NDK" e poi accedere o creare un BBID.
-* [Registrati per il codice chiave di firma.][2]
+Immettere una password e fare clic su "Ottieni Token" per scaricare bbidtoken.csk. Salvare il file nel percorso predefinito per il sistema operativo che verrà visualizzato sulla pagina di download.
-* [Configurare il sistema per la firma del codice.][3]
+Il passo finale è quello di generare un certificato di firma:
- [2]: https://www.blackberry.com/SignedKeys/codesigning.html
- [3]: https://developer.blackberry.com/html5/documentation/signing_setup_bb10_apps_2008396_11.html
+ $ blackberry-keytool -genkeypair -storepass <password> -author 'Your Name’
+
## Creare un progetto
Uso il `cordova` utility per impostare un nuovo progetto, come descritto in l'interfaccia della riga di comando. Ad esempio, in una directory del codice sorgente:
- $ cordova creare Ciao com.example.hello $ cd $ Ciao cordova piattaforma aggiungere compilazione di cordova $ blackberry10
+ $ cordova create hello com.example.hello
+ $ cd hello
+ $ cordova platform add blackberry10
+ $ cordova build
## Distribuire all'emulatore
@@ -79,96 +78,74 @@ Uso il `cordova` utility per impostare un nuovo progetto, come descritto in l'in
Se si desidera eseguire un emulatore del dispositivo, scaricare e installare il BlackBerry 10 simulatore.
* [Scarica][1]
-* [Guida introduttiva][4]
+* [Guida introduttiva][2]
- [4]: http://developer.blackberry.com/devzone/develop/simulator/blackberry_10_simulator_start.html
+ [2]: http://developer.blackberry.com/devzone/develop/simulator/blackberry_10_simulator_start.html
-Prima di testare un'app su un emulatore o un dispositivo, è necessario aggiungere una *destinazione* al progetto. Ognuno è identificato con un nome univoco e associato a un indirizzo IP. È necessario ottenere l'indirizzo IP dall'emulatore prima di utilizzarlo per visualizzare applicazioni.
+Prima di testare un'app su un emulatore o un dispositivo, è necessario attivare la modalità di sviluppo.
Lanciare l'immagine di emulatore, quindi scegliere **Impostazioni** dalla schermata iniziale:
-![][5]
-
- [5]: img/guide/platforms/blackberry10/bb_home.png
+![][3]
-Passare al **sicurezza e Privacy → modalità di sviluppo** sezione, attivare l'opzione e ottenere l'indirizzo IP:
+ [3]: img/guide/platforms/blackberry10/bb_home.png
-![][6]
+Passare al **sicurezza e Privacy → modalità di sviluppo** sezione e attivare l'opzione:
- [6]: img/guide/platforms/blackberry10/bb_devel.png
-
-Un ulteriore insieme di utilità della riga di comando sono inclusi quando si configura la piattaforma BlackBerry 10 per il progetto. Il comando riportato di seguito, in questo caso richiamato dalla directory principale del progetto, associa una destinazione denominata *UEM* con l'indirizzo IP visualizzato sopra.
-
-* Su Windows:
-
- $ platforms\blackberry10\cordova\target.bat aggiungere simulatore di emu 169.254.0.1 -t
+![][4]
-* Su Mac/Linux:
-
- $ piattaforme/blackberry10/cordova/destinazione aggiungere simulatore di emu 169.254.0.1 -t
+ [4]: img/guide/platforms/blackberry10/bb_devel.png
Quindi, eseguire il `emulate` comando per visualizzare l'app:
- $ cordova emulare blackberry10
+ $ cordova emulate blackberry10 --devicepass <password>
## Distribuire al dispositivo
-Per distribuire un dispositivo, assicurarsi che sia collegato al computer. Abilitare la modalità di sviluppo e ottenere l'indirizzo IP come desribed nella sezione emulatore precedente. Sarà inoltre necessario ottenere il PIN dall'applicazione **Impostazioni** sotto **circa → Hardware**:
-
-![][7]
-
- [7]: img/guide/platforms/blackberry10/bb_pin.png
+Per distribuire un dispositivo, assicurarsi che il computer è collegato ed è attivata la modalità di sviluppo.
-Eseguire l'utilità della riga di destinazione per associare un nome a un indirizzo IP, password dispositivo e PIN.
+Quindi, eseguire il `run` comando per visualizzare l'app:
-* Su Windows:
+ $ cordova run blackberry10 --devicepass <password>
- $ platforms\blackberry10\cordova\target.bat aggiungere mydevice 169.254.0.1 dispositivo di -t - password 123456 - perno FFFF972E
-* Su Mac/Linux:
-
- $ piattaforme/blackberry10/cordova/destinazione aggiungere mydevice 169.254.0.1 dispositivo di -t - password 123456 - perno FFFF972E
+Se un token di debug non è ancora impostata per il dispositivo, un messaggio di errore richiede di fornire la password è definito quando si configura il computer per firmare le applicazioni.
-dove:
+ $ cordova run blackberry10 --devicepass <password> --keystorepass <signing password>
+
-* `--password`si riferisce alla password per sbloccare il dispositivo.
+## Debug con WebInspector
-* `--pin`si riferisce al dispositivo PIN ottenuti dall'applicazione **Impostazioni** .
+Quando il debug sul dispositivo o un emulatore, è possibile eseguire WebInspector in remoto per visualizzare lo stato interno dell'applicazione. Un prompt dei comandi viene visualizzato l'URL che consente di connettersi all'app con un browser web standard. Per ulteriori informazioni, vedere [debug utilizzando WebInspector][5].
-Quindi, eseguire il `run` comando per visualizzare l'app:
+ [5]: http://developer.blackberry.com/html5/documentation/web_inspector_overview_1553586_11.html
- $ cordova eseguire blackberry10
-
+## Costruzione di una versione di rilascio
-Se un token di debug non è ancora impostato per il dispositivo, un messaggio di errore richiede di utilizzare la piattaforma di eseguire script con la password che hai fornito durante la registrazione per chiavi di firma.
+Per impostazione predefinita, esegue il `cordova build` comando crea un file di pacchetto non firmato *bar* adatto per il test su un dispositivo o un simulatore.
-* Su Windows:
-
- $ platforms\blackberry10\cordova\run.bat - dispositivo - keystorepass mysecret
+Uso `--release` per creare una versione non adatta per la distribuzione attraverso il mondo BlackBerry.
-* Su Mac/Linux:
+ $ cordova build --release --keystorepass <signing password>
- $ piattaforme/blackberry10/cordova/run - dispositivo - keystorepass mysecret
-## Debug con WebInspector
+Il `--keystorepass` opzione specifica la password che definito quando si configura il computer per firmare applicazioni.
-Quando il debug sul dispositivo o un emulatore, è possibile eseguire WebInspector in remoto per visualizzare lo stato interno dell'applicazione. Un prompt dei comandi viene visualizzato l'URL che consente di connettersi all'app con un browser web standard. Per ulteriori informazioni, vedere [debug utilizzando WebInspector][8].
+## Distribuire in altri percorsi
- [8]: http://developer.blackberry.com/html5/documentation/web_inspector_overview_1553586_11.html
+Le istruzioni di cui sopra assumono un dispositivo è collegato tramite USB o un simulatore è in esecuzione sul computer locale. È anche possibile distribuire ad altre posizioni.
-## Costruzione di una versione di rilascio
-
-Per impostazione predefinita, esegue il `cordova build` comando crea un file di pacchetto non firmato *bar* adatto per il test su un dispositivo o un simulatore.
-
-È necessario eseguire una diversa `build` comando per creare una versione non adatta per la distribuzione attraverso il mondo BlackBerry. Non fa affidamento sul `cordova` strumento CLI e invece utilizza la seguente sintassi:
+Un ulteriore insieme di utilità della riga di comando sono inclusi quando si configura la piattaforma BlackBerry 10 per il progetto. Il comando riportato di seguito, in questo caso richiamato dalla directory principale del progetto, associa una destinazione denominata *emu* con un indirizzo IP.
* Su Windows:
- $ platforms\blackberry10\cordova\build.bat - rilascio - keystorepass mysecret
+ $ platforms\blackberry10\cordova\target.bat add emu 192.168.2.24 -t simulator
* Su Mac/Linux:
- $ piattaforme/blackberry10/cordova/build--rilascio - keystorepass mysecret
+ $ platforms/blackberry10/cordova/target add emu 192.168.2.24 -t simulator
+
+Una volta definito l'obiettivo, è possibile fornire al comando di corsa con `--target` :
-Il `--keystorepass` opzione specifica la password che definito quando si configura il computer per firmare applicazioni.
\ No newline at end of file
+ $ cordova run blackberry10 --target=emu
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/blackberry10/plugin.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/blackberry10/plugin.md b/docs/it/edge/guide/platforms/blackberry10/plugin.md
index b2bb8d2..caeee7e 100644
--- a/docs/it/edge/guide/platforms/blackberry10/plugin.md
+++ b/docs/it/edge/guide/platforms/blackberry10/plugin.md
@@ -16,140 +16,185 @@ license: Licensed to the Apache Software Foundation (ASF) under one or more cont
# BlackBerry 10 plugin
-Questa è una continuazione della guida sviluppo Plugin per Cordova. Una volta che si hanno esaminato tale contenuto, ora facciamo guardare le cose che abbiamo bisogno di avere il plugin di Echo per la piattaforma BlackBerry 10. Ricordiamo che il plugin Echo restituisce praticamente qualunque stringa un utente fornisce per la `window.echo` funzione:
+In questa sezione vengono fornite informazioni dettagliate per come implementare il codice plugin nativo sulla piattaforma BlackBerry 10. 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.
- window.echo = function(str, callback) {
+Il plugin Echo restituisce praticamente qualunque stringa la `window.echo` funzione Invia da JavaScript:
+
+ window.echo = function(str, callback) {
cordova.exec(callback, function(err) {
callback('Nothing to echo.');
}, "Echo", "echo", [str]);
};
-Un nativo BlackBerry 10 plugin per Cordova contiene codice JavaScript e possa contenere anche codice nativo. L'esempio di plugin Echo viene illustrato come richiamare le funzionalità native da JavaScript. Native e codice JavaScript comunicano tra loro attraverso un quadro fornito da JNEXT. Ogni plugin deve includere anche un `plugin.xml` file.
+Un plugin di Cordova per BlackBerry 10 contiene JavaScript e codice nativo, che comunicano tra loro attraverso un quadro fornito da JNEXT. Ogni plugin deve includere anche un `plugin.xml` file.
-## Creazione parte nativa del vostro plugin
+## Creazione della classe nativa
-Per creare la parte nativa del vostro plugin, aprire il BlackBerry 10 NDK IDE e selezionare il File > New > BlackBerry progetto > estensione nativa > BlackBerry WebWorks. Immettere il nome del progetto desiderato / posizione e fare clic su fine.
+Per creare la parte nativa del vostro plugin, aprire il BlackBerry 10 NDK IDE e selezionare **File → nuovo → progetto BlackBerry → estensione nativa → BlackBerry 10**. Immettere il nome del progetto desiderato e posizione, quindi premere **fine**.
-Il progetto creato dall'IDE contiene codice di esempio per un plugin di memoria. Si può sostituire o modificare questi file per includere funzionalità personalizzate.
+Il progetto creato dall'IDE contiene codice di esempio per un plugin di memoria. Si può sostituire o modificare questi file per implementare funzionalità personalizzate:
* `*name*_js.hpp`: Intestazione C++ per il codice JNEXT.
* `*name*_js.cpp`: Codice C++ per JNEXT.
-L'interfaccia nativa per l'estensione JNEXT può essere visualizzato nel file di intestazione plugin nella directory pubblica del vostro progetto. Inoltre contiene costanti e funzioni di utilità che possono essere utilizzati nel codice nativo. Il plugin deve essere derivato da JSExt che è definito in plugin.h. Cioè, è necessario implementare la seguente classe:
+L'interfaccia nativa per l'estensione JNEXT può essere visualizzato nel file di intestazione plugin nella directory pubblica del progetto. Dispone anche di costanti e funzioni di utilità disponibili da codice nativo. Il plugin deve essere derivato da `JSExt` , che è definito `plugin.h` . Cioè, è necessario implementare la seguente classe:
- JSExt di classe {public: virtual ~JSExt() {};
- virtuale stringa InvokeMethod (const string & strCommand) = 0;
- Virtual bool CanDelete (void) = 0;
- privato: m_id std:: String;
- };
+ class JSExt
+ {
+ public:
+ virtual ~JSExt() {};
+ virtual string InvokeMethod( const string& strCommand ) = 0;
+ virtual bool CanDelete( void ) = 0;
+ private:
+ std::string m_id;
+ };
-Pertanto, l'estensione deve includere il file di intestazione plugin.h. Nell'esempio di Echo, si utilizza JSExt come segue nel file echo_js.hpp:
+L'estensione dovrebbe includere il `plugin.h` file di intestazione. Nella `Echo` esempio, si utilizza `JSExt` come segue nel `echo_js.hpp` file:
- #include ".../ public/plugin.h "#include < string > #ifndef ECHO_JS_H_ #define ECHO_JS_H_ classe Echo: pubblica JSExt {pubblica: Echo esplicita (const std:: String & id);
- Virtual ~ echo ();
- std:: String virtuale InvokeMethod (const std:: String & comando);
- Virtual bool CanDelete();
- privato: m_id std:: String;
- };
+ #include "../public/plugin.h"
+ #include <string>
+
+ #ifndef ECHO_JS_H_
+ #define ECHO_JS_H_
- #endif / / ECHO_JS_H_
+ class Echo : public JSExt
+ {
+ public:
+ explicit Echo(const std::string& id);
+ virtual ~Echo();
+ virtual std::string InvokeMethod(const std::string& command);
+ virtual bool CanDelete();
+ private:
+ std::string m_id;
+ };
+
+ #endif // ECHO_JS_H_
-Il `m_id` è un attributo che contiene l'id JNEXT per questo oggetto. L'id viene passato alla classe come argomento al costruttore. È necessario attivare eventi sul lato JavaScript da codice nativo. Il metodo di CanDelete è utilizzato da JNEXT per determinare se il vostro oggetto nativo può essere eliminato. La funzione InvokeMethod è chiamata come risultato da una richiesta da JavaScript per richiamare un metodo di questo particolare oggetto. L'unico argomento a questa funzione è una stringa passata da JavaScript che questo metodo dovrebbe analizzare al fine di determinare quale metodo dell'oggetto nativo deve essere eseguito. Ora abbiamo implementare queste funzioni in echo_js.cpp. Per l'esempio di Echo, implementiamo InvokeMethod funzione come segue:
+Il `m_id` attributo contiene il `JNEXT` id per l'oggetto che viene passato alla classe come argomento al costruttore. È necessario per il lato nativo per gli eventi di trigger sul lato JavaScript. Il `CanDelete` metodo determina se l'oggetto nativo può essere eliminato. Il `InvokeMethod` è chiamata funzione di conseguenza da una richiesta da JavaScript per richiamare un metodo di questo particolare oggetto. L'unico argomento a questa funzione è una stringa passata da JavaScript che questo metodo analizza per determinare quale dei metodi dell'oggetto nativo dovrebbe eseguire. Questi metodi sono implementati `echo_js.cpp` . Ecco il `InvokeMethod` funzione per il `Echo` esempio:
- String Echo::InvokeMethod (const string & comando) {//parse comando e args dall'indice di stringa int = command.find_first_of("");
- String strCommand = command.substr (0, indice);
- String strValue = command.substr (indice + 1, command.length());
+ string Echo::InvokeMethod(const string& command) {
+
+ //parse command and args from string
+ int index = command.find_first_of(" ");
+ string strCommand = command.substr(0, index);
+ string strValue = command.substr(index + 1, command.length());
- / / Determinare quale funzione dovrebbe essere eseguita se (strCommand = = "echo") {return strValue;
- } else {return "Metodo non supportato";
+ // Determine which function should be executed
+ if (strCommand == "echo") {
+ return strValue;
+ } else {
+ return "Unsupported Method";
+ }
}
- }
-Il vostro plugin nativo deve implementare anche le seguenti funzioni di callback:
+Il plugin nativo deve inoltre implementare le seguenti funzioni di callback:
* `extern char * onGetObjList (void);`
* `extern JSExt * onCreateObject (const string & strClassName, const string & strObjId);`
-il `onGetObjList` funzione restituisce un elenco separato da virgole delle classi supportate da JNEXT. JNEXT utilizza questa funzione per determinare il set di classi che è possibile creare un'istanza di JNEXT. Nel nostro plugin Echo, abbiamo il seguente `echo_js.cpp` :
+il `onGetObjList` funzione restituisce un elenco separato da virgole delle classi supportate da JNEXT. JNEXT utilizza questa funzione per determinare il set di classi che è possibile creare un'istanza di JNEXT. Il `Echo` plugin implementa i seguenti in `echo_js.cpp` :
- char * onGetObjList() {static char nome [] = "Echo";
- restituire il nome;
- }
+ char* onGetObjList() {
+ static char name[] = "Echo";
+ return name;
+ }
-il `onCreateObject` funzione accetta due parametri. Il primo parametro è il nome della classe che ha chiesto di essere creato dal lato JavaScript. Nomi validi sono quelli restituiti in `onGetObjList` . Il secondo parametro è l'id di oggetto univoco per la classe. Questo metodo restituisce un puntatore all'oggetto plugin creato. Nel nostro plugin Echo, abbiamo il seguente `echo_js.cpp` :
+il `onCreateObject` funzione accetta due parametri. Il primo è il nome della classe richiesta per essere creato dal lato JavaScript, con nomi validi come quelli restituiti `onGetObjList` . Il secondo parametro è l'id di oggetto unico di classe. Questo metodo restituisce un puntatore all'oggetto plugin creato. Il `Echo` plugin implementa i seguenti in `echo_js.cpp` :
- JSExt * onCreateObject (const string & className, const string & id) {se (className = = "Echo") {return nuovo Echo(id);
- } return NULL;
- }
+ JSExt* onCreateObject(const string& className, const string& id) {
+ if (className == "Echo") {
+ return new Echo(id);
+ }
+ return NULL;
+ }
-## Creare la parte di JavaScript del vostro plugin
+## Creazione JavaScript del Plugin
-La parte di JavaScript del vostro plugin deve contenere i seguenti file:
+Il plugin deve contenere i seguenti file JavaScript:
-* `client.js`: Questo è considerato il lato client e contiene le API che si può chiamare un'applicazione di Cordova. L'API in `client.js` chiamate effettua chiamate al `index.js` . L'API in `client.js` collega inoltre funzioni di callback agli eventi che fuoco i callback.
+* `client.js`: Questo è considerato il lato client e contiene le API disponibili per un'applicazione di Cordova. L'API in `client.js` chiamate effettua chiamate al `index.js` . L'API in `client.js` collega inoltre funzioni di callback agli eventi che fuoco i callback.
* `index.js`: Cordova carica `index.js` e rende accessibile attraverso il ponte di cordova.exec. La `client.js` file effettua chiamate all'API nella `index.js` file, che a sua volta chiamare al JNEXT per comunicare con il lato nativo.
-Il lato client e server ( `client.js` e `index.js` ) interagisce tramite la `Cordova.exec` funzione. Così, in `client.js` si richiama il `exec` di funzione di fornire gli argomenti necessari. Nel plugin Echo, abbiamo seguito nella `client.js` file:
+Il lato client e server ( `client.js` e `index.js` ) interagisce tramite la `Cordova.exec` funzione. Il `client.js` ha bisogno di richiamare il `exec` di funzione di fornire gli argomenti necessari. Il `Echo` plugin implementa i seguenti nella `client.js` file:
- var service = "org.apache.cordova.blackberry.echo",
- exec = cordova.require("cordova/exec");
+ var service = "org.apache.cordova.blackberry.echo",
+ exec = cordova.require("cordova/exec");
- module.exports = {
- echo: function (data, success, fail) {
- exec(success, fail, service, "echo", { data: data });
- }
- };
+ module.exports = {
+ echo: function (data, success, fail) {
+ exec(success, fail, service, "echo", { data: data });
+ }
+ };
-Ora, `index.js` interagisce con il lato nativo utilizzando JNEXT. Così allegare una funzione costruttore denominata eco a JNEXT. All'interno del costruttore è eseguire le seguenti operazioni chiave utilizzando la funzione init:
-
-* Specificare il modulo richiesto esportato dal lato nativo. Il nome del modulo richiesto deve corrispondere al nome di un file di libreria condivisa (file. so).
+Il `index.js` componente utilizza JNEXT per interagire con il lato nativo. Associare una funzione costruttore denominata `Echo` a JNEXT consente di eseguire le seguenti operazioni chiave utilizzando la `init` funzione:
-`JNEXT.require("libecho")`
-
-* Creare un oggetto utilizzando un modulo acquisito e salvare l'ID che viene restituito dalla chiamata. self.m_Id = JNEXT.createObject ("libecho.Echo"); Quando l'applicazione chiama la funzione echo in `client.js` , che a sua volta chiamata chiama la funzione echo in `index.js` , dove l'oggetto PluginResult invia una risposta (dati) a `client.js` . Poiché l'argomento args passato le funzioni è stato convertito da JSON.stringfy() e codificato come un componente URI, è necessario chiamare il seguente:
-
-`dati = JSON.parse(decodeURIComponent(args.data));`
-
-È ora possibile inviare i dati indietro. Mettiamolo tutti insieme:
+* Specificare il modulo richiesto esportato dal lato nativo. Il nome del modulo richiesto deve corrispondere al nome di un file di libreria condivisa ( `.so` file):
+
+ JNEXT.require("libecho")
+
- module.exports = {
+* Creare un oggetto utilizzando un modulo acquisito e salvare l'ID che viene restituito dalla chiamata:
- echo: function (success, fail, args, env) {
+ self.m_id = JNEXT.createObject("libecho.Echo");
+
- var result = new PluginResult(args, env),
- data = JSON.parse(decodeURIComponent(args.data)),
- response = echo.getInstance().echo(data);
- result.ok(response, false);
- }
- };
+ Quando l'applicazione chiama il `echo` funzione `client.js` , che a sua volta chiamare chiamate il `echo` funzione `index.js` , dove il `PluginResult` oggetto invia i dati come risposta `client.js` . Poiché il `args` argomento passato le funzioni fu convertito da `JSON.stringfy()` e codificato come un `URIcomponent` , è necessario chiamare il seguente:
+
+ data = JSON.parse(decodeURIComponent(args.data));
+
+
+È ora possibile inviare i dati indietro, come illustrato di seguito:
+
+ module.exports = {
+ echo: function (success, fail, args, env) {
+ var result = new PluginResult(args, env),
+ data = JSON.parse(decodeURIComponent(args.data)),
+ response = echo.getInstance().echo(data);
+ result.ok(response, false);
+ }
+ };
-## Architettura del plugin
+## Architettura a plugin
-È possibile posizionare i manufatti del plugin, che comprende il `plugin.xml` file, i file di origine (JavaScript, C++) e i file binari ( `.so` ) all'interno di qualsiasi struttura di directory, finchè si specificano correttamente i percorsi dei file nella `plugin.xml` file. Una tipica struttura assomiglia a questo:
+È possibile inserire gli artefatti del plugin, tra cui il `plugin.xml` file, i file sorgente JavaScript e C++ e il `.so` file binari all'interno di qualsiasi struttura di directory, purché si specificano correttamente i percorsi dei file nella `plugin.xml` file. Qui è una struttura tipica:
-***your\_project\_directory*** (> plugin)
+***project_directory*** (> plugin)
-* **www** (> client.js)
+* **www** (>client.js)
* **src**
* **blackberry10** (> index.js, **nativa** > *.cpp, *.hpp)
* **dispositivo** (>*binario file* *. so)
* **simulatore** (>*binario file* *. so)
-(L'elenco Mostra la relazione gerarchica tra le directory di livello superiore. La parentesi indica il contenuto di una directory specificata. Tutti i nomi di directory vengono visualizzati in grassetto. I nomi dei file sono preceduti dalla `>` segno.)
-
-## Contenuto della `plugin.xml` file
-
-La `plugin.xml` file contiene lo spazio dei nomi di estensione e altri metadati. Definire lo spazio dei nomi e specificare altri metadati per il plugin Echo come segue:
-
- < plugin xmlns = "http://www.phonegap.com/ns/plugins/1.0" id="org.apache.cordova.blackberry.echo" versione = "1.0.0" >< js-modulo src = "www/client.js" >< unioni destinazione = "navigator" / >< / js-modulo >< nome piattaforma = "blackberry10" >< file di origine src="src/blackberry10/index.js" / >< lib-file src="src/blackberry10/native/device/libecho.so" arco = "dispositivo" / >< lib-file src="src/blackberry10/native/simulator/libecho.so" arco = "simulator" / >< bersaglio-config-file = "www/config.xml" padre = "/ widget" >< presentano name="org.apache.cordova.blackberry.echo" value="org.apache.cordova.blackberry.echo" / >< / config-file >< /piattaforma >< / plugin >
\ No newline at end of file
+L'elenco Mostra la relazione gerarchica tra le cartelle di livello superiore. La parentesi indica il contenuto di una directory specificata. Tutti i nomi di directory vengono visualizzati in grassetto. I nomi dei file sono preceduti dalla `>` segno.
+
+## Il file di *plugin*
+
+La `plugin.xml` file contiene lo spazio dei nomi dell'estensione e altri metadati. Impostare il `Echo` plugin come segue:
+
+ <plugin xmlns="http://www.phonegap.com/ns/plugins/1.0"
+ id="org.apache.cordova.blackberry.echo"
+ version="1.0.0">
+ <js-module src="www/client.js">
+ <merges target="navigator" />
+ </js-module>
+ <platform name="blackberry10">
+ <source-file src="src/blackberry10/index.js" />
+ <lib-file src="src/blackberry10/native/device/libecho.so" arch="device" />
+ <lib-file src="src/blackberry10/native/simulator/libecho.so" arch="simulator" />
+ <config-file target="www/config.xml" parent="/widget">
+ <feature name="org.apache.cordova.blackberry.echo" value="org.apache.cordova.blackberry.echo" />
+ </config-file>
+ </platform>
+ </plugin>
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/blackberry10/tools.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/blackberry10/tools.md b/docs/it/edge/guide/platforms/blackberry10/tools.md
index 44f91e6..95b4fed 100644
--- a/docs/it/edge/guide/platforms/blackberry10/tools.md
+++ b/docs/it/edge/guide/platforms/blackberry10/tools.md
@@ -20,9 +20,11 @@ Il `cordova` l'utilità della riga di comando è uno strumento ad alto livello c
[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.
+
Se hai bisogno di aiuto con i comandi elencati di seguito, digitare il comando lungo con il `-h` o `-help` gli argomenti, che sono supportati da tutti i comandi e che forniscono descrizioni per ciascuno degli argomenti disponibili.
-## creare
+## Creare un'App
Il `create` comando crea un nuovo progetto:
@@ -37,9 +39,9 @@ dove
* `<project-name>`specifica il nome visualizzato di apps
-**Nota:** il `create` comando avvia installazione di dipendenza attraverso il `npm install` comando. A seconda delle autorizzazioni di directory e il sistema di installazione, questo può richiedere privilegi di amministratore. Se non c'è problema su OSX/Linux, eseguire `sudo npm install` prima di utilizzare il `create` comando. Su Windows, eseguire `npm install` inaugurato in un'utilità della riga di comando con privilegi di amministratore.
+**Nota**: il `create` comando avvia installazione di dipendenza attraverso il `npm install` comando. A seconda delle autorizzazioni di directory e il sistema di installazione, questo può richiedere privilegi di amministratore. Se non c'è problema su OSX/Linux, eseguire `sudo npm install` prima di utilizzare il `create` comando. Su Windows, eseguire `npm install` inaugurato in un'utilità della riga di comando con privilegi di amministratore.
-## destinazione
+## Creare una destinazione
Il `target` comando consente di gestire l'emulatore o dispositivi BlackBerry che si utilizzano per testare l'app. È possibile aggiungere o rimuovere una destinazione o impostare una destinazione come destinazione predefinita.
@@ -56,7 +58,7 @@ dove
* `-p | --password <password>`specifica la password per il dispositivo o nell'emulatore. È richiesto solo se il dispositivo o l'emulatore è protetto da password.
-* `--pin <device-pin>`specifica il PIN del dispositivo BlackBerry, che identifica tale dispositivo come un host valido per il token di debug. Questo argomento è obbligatorio solo se si crea un token di debug.
+* `--pin <device-pin>`specifica il PIN del dispositivo BlackBerry, che identifica tale dispositivo come un host valido per il token di debug. Questo argomento è obbligatorio solo quando si crea un token di debug.
### Rimuovere una destinazione
@@ -68,11 +70,11 @@ dove
< percorso a progetto >/cordova/destinazione predefinita < nome >
-## costruire
+## Costruire l'App
Il `build` comando compila il progetto come file bar. È possibile compilare l'applicazione in modalità di rilascio (che produce un file firmato bar) o in modalità di debug (che produce un file unsigned bar).
-### Compilare il progetto in modalità di rilascio
+### Compilare l'applicazione in modalità di rilascio
< percorso a progetto >/cordova/costruire il rilascio [-k | - keystorepass < password >] [-b | - buildId < numero >] [-p | - params < params-JSON-file >]
@@ -85,7 +87,7 @@ dove
* `-p | --params <params-JSON-file>`specifica un file JSON contenente ulteriori parametri da passare a strumenti a valle. Questo argomento è facoltativo.
-### Compilare il progetto in modalità di debug
+### Compilare il progetto in modalità di Debug
< percorso a progetto >/cordova/costruire debug [< target >] [-k | - keystorepass < password >] [-p | - params < params-JSON-file >] [-ll | - loglevel < error|warn|verbose >]
@@ -100,41 +102,37 @@ dove
* `-ll | --loglevel <level>`specifica il livello di log. Il livello di log può essere uno dei `error` , `warn` , o`verbose`.
-Se avete definito in precedenza una destinazione predefinita (e precedentemente installato un token di debug, se la destinazione è un dispositivo BlackBerry), è possibile eseguire lo script senza argomenti, e lo script verrà pacchetto app e distribuirlo alla destinazione predefinita. Ad esempio:
+Se avete precedentemente definito una destinazione predefinita (e precedentemente installato un token di debug, se la destinazione è un dispositivo BlackBerry), è possibile eseguire lo script con senza argomenti e i pacchetti script app e distribuisce alla destinazione predefinita. Ad esempio:
< percorso a progetto >/cordova/costruire debug
-## eseguire
+## Eseguire l'applicazione
-Il `run` comando consente di distribuire l'applicazione sul dispositivo BlackBerry specificato o un emulatore. Prima di distribuire l'applicazione, è necessario innanzitutto creare un target per il dispositivo o l'emulatore che si desidera distribuire app utilizzando lo script di destinazione. Lo script di distribuzione distribuirà la build più recente della tua app.
+Il `run` comando consente di distribuire il build più recente dell'applicazione sul dispositivo BlackBerry specificato o un emulatore. Per distribuire l'applicazione, è necessario specificare una destinazione per il dispositivo o l'emulatore:
< percorso a progetto >/cordova/eseguire < destinazione >
-dove
-
-* `<target>`specifica il nome di un target aggiunto precedentemente. Se `<target>` è un dispositivo, quindi che il dispositivo deve essere collegato al computer tramite collegamento USB o essere collegato alla stessa rete Wi-Fi come il computer.
-
-## plugin
+... dove `<target>` specifica il nome di un target aggiunto precedentemente. Se `<target>` è un dispositivo, quindi deve essere collegato al computer tramite cavo USB, oppure sulla stessa rete Wi-Fi sul computer.
-Il `target` comando consente di aggiungere e rimuovere plugin
+## Gestire i plugin
-### Recuperare un plugin ospitato localmente
+Il `target` comando consente di aggiungere e rimuovere il plugin. Per recuperare un plugin ospitato localmente:
< percorso a progetto >/cordova/plugin fetch < percorso-plugin >
-### Mostra un elenco dei plugin installati
+Mostra un elenco dei plugin installati:
< percorso a progetto >/cordova/plugin ls
-### Aggiungere un plugin
+Aggiungere un plugin:
< percorso a progetto > plugin/cordova/aggiungere < nome >
-### Rimuovere un plugin
+Rimuovere un plugin:
< percorso a progetto >/cordova/plugin rm < nome >
\ No newline at end of file
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/blackberry10/upgrading.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/blackberry10/upgrading.md b/docs/it/edge/guide/platforms/blackberry10/upgrading.md
index 5062529..e6d5b13 100644
--- a/docs/it/edge/guide/platforms/blackberry10/upgrading.md
+++ b/docs/it/edge/guide/platforms/blackberry10/upgrading.md
@@ -14,10 +14,23 @@ license: Licensed to the Apache Software Foundation (ASF) under one or more cont
under the License.
---
-# L'aggiornamento di BlackBerry
+# L'aggiornamento di BlackBerry 10
Questa guida Mostra come modificare i progetti di BlackBerry 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.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 blackberry`
+
+Per i progetti non creati con la CLI di cordova, eseguire:
+
+ bin/aggiornamento < project_path >
+
+
## Aggiornamento a 3.1.0 da 3.0.0
1. Creare un nuovo progetto di Apache Cordova 3.1.0 utilizzando la CLI, cordova, come descritto in l'interfaccia della riga di comando.
@@ -29,7 +42,7 @@ platform add blackberry10`.
4. Copiare o sovrascrivere qualsiasi attività nativo dal progetto originale ( `Resources` , ecc.)
-5. Copia il `config.xml` nel `www` directory e rimuovere eventuali definizioni di plugin. Si modificherà le impostazioni qui invece di directory della piattaforma.
+5. Copia il `config.xml` del file nella `www` directory e rimuovere eventuali definizioni di plugin. È necessario modificare le impostazioni qui piuttosto che all'interno della directory di piattaforma.
6. 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 plugin contrassegnato 3.0.0 e soprattutto sono compatibili con il CLI.
@@ -41,14 +54,14 @@ Si prega di notare che il CLI supporta la piattaforma BlackBerry10 esclusivament
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. Aggiungi il tua piattaforme il progetto il cordova, ad esempio:`cordova
+2. Aggiungere le piattaforme per il progetto di cordova, per esempio:`cordova
platform add blackberry10`.
3. Copiare il contenuto del progetto originale `www` nella directory del `www` cartella alla radice del progetto cordova appena creato.
4. Copiare o sovrascrivere qualsiasi attività nativo dal progetto originale ( `Resources` , ecc.)
-5. Copia il `config.xml` nel `www` directory e rimuovere eventuali definizioni di plugin. Si modificherà le impostazioni qui invece di directory della piattaforma.
+5. Copia il `config.xml` del file nella `www` directory e rimuovere eventuali definizioni di plugin. È necessario modificare le impostazioni qui piuttosto che all'interno della directory di piattaforma.
6. 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.
@@ -56,7 +69,7 @@ platform add blackberry10`.
## 2.8.0 All'aggiornamento di progetti a 2.9.0
-BlackBerry 10:
+Per BlackBerry 10:
1. Scaricare ed estrarre la sorgente di Cordova 2.9.0 in un percorso di directory permanente sul disco rigido, ad esempio`~/Cordova-2.9.0`.
@@ -70,7 +83,7 @@ BlackBerry 10:
6. Aggiornare il riferimento allo script di Cordova nel tuo `www/index.html` file (e qualsiasi altro file che contengono il riferimento allo script) per puntare al nuovo `cordova.js` file.
-### BlackBerryOS/Playbook
+Per BlackBerryOS/Playbook:
1. Scaricare ed estrarre la sorgente di Cordova 2.9.0 in un percorso di directory permanente sul disco rigido, ad esempio`~/Cordova-2.9.0`.
@@ -92,8 +105,6 @@ BlackBerry 10:
## All'aggiornamento 2.7.0 progetti per 2.8.0
-BlackBerry 10:
-
BlackBerry 10 utilizza i nuovi utensili CLI e gestisce core API come plugin. Le istruzioni migrano il progetto per un nuovo progetto, piuttosto che aggiornare un progetto esistente, a causa della complessità di un vecchio progetto di aggiornamento. Inoltre nota che il cordova js script file ora è chiamato 'cordova.js' e più non contiene una stringa di versione.
1. Scaricare ed estrarre la sorgente di Cordova 2.8.0 a una posizione permanente directory sul disco rigido, ad esempio`~/Cordova-2.8.0`.
@@ -108,7 +119,7 @@ BlackBerry 10 utilizza i nuovi utensili CLI e gestisce core API come plugin. Le
6. Aggiornare il riferimento allo script di Cordova nel tuo `www/index.html` file (e qualsiasi altro file che contengono il riferimento allo script) per puntare al nuovo `cordova.js` file.
-BlackBerryOS/Playbook:
+Per BlackBerryOS/Playbook:
1. Scaricare ed estrarre la sorgente di Cordova 2.8.0 a una posizione permanente directory sul disco rigido, ad esempio`~/Cordova-2.8.0`.
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/60194dbe/docs/it/edge/guide/platforms/index.md
----------------------------------------------------------------------
diff --git a/docs/it/edge/guide/platforms/index.md b/docs/it/edge/guide/platforms/index.md
index 17359a8..cda8545 100644
--- a/docs/it/edge/guide/platforms/index.md
+++ b/docs/it/edge/guide/platforms/index.md
@@ -22,6 +22,13 @@ Per sviluppare applicazioni di Cordova, è necessario installare il SDK per ogni
Ogni *Piattaforma guida* sottoelencate ti dice quello che dovete sapere per impostare sviluppo ambiente di ogni piattaforma: dove ottenere il SDK, come impostare emulatori, come collegare i dispositivi per test diretto e come gestire i requisiti chiave di firma. Guide aggiuntive forniscono informazioni su set unico di ogni piattaforma opzioni di configurazione, le istruzioni per aggiungere plugin, come aggiornare ogni piattaforma e strumenti della riga di comando specifici della piattaforma che servono come alternativa a basso livello del `cordova` utilità da riga di comando.
+## Amazon fuoco OS
+
+* Amazon fuoco piattaforma OS guida
+* Configurazione di fuoco OS Amazon
+* Amazon fuoco OS visualizzazioni Web
+* Amazon fuoco OS Plugins
+
## Android
* Guida piattaforma Android
@@ -31,19 +38,13 @@ Ogni *Piattaforma guida* sottoelencate ti dice quello che dovete sapere per impo
* Android strumenti da riga di comando
* L'aggiornamento di Android
-## BlackBerry
-
-* Guida piattaforma blackBerry
-* Configurazione di blackBerry
-* Strumenti della riga di comando di blackBerry
-* L'aggiornamento di BlackBerry
-
## BlackBerry 10
* Guida piattaforma blackBerry 10
* Configurazione di blackBerry 10
* BlackBerry 10 plugin
* Strumenti della riga di comando di blackBerry 10
+* L'aggiornamento di BlackBerry 10
## iOS
@@ -54,6 +55,10 @@ Ogni *Piattaforma guida* sottoelencate ti dice quello che dovete sapere per impo
* iOS Command-line Tools
* L'aggiornamento iOS
+## Ubuntu
+
+* Piattaforma ubuntu guida
+
## Windows Phone
* Guida di Windows Phone 8 piattaforma