cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [30/51] [abbrv] [partial] docs commit: added cordova 6.0.0 docs
Date Thu, 28 Jan 2016 18:11:07 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/platforms/amazonfireos/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/amazonfireos/index.md b/www/docs/es/6.0.0/guide/platforms/amazonfireos/index.md
new file mode 100644
index 0000000..737883b
--- /dev/null
+++ b/www/docs/es/6.0.0/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 fuego OS Platform Guide
+---
+
+# Amazon fuego OS Platform Guide
+
+Esta guía le muestra cómo configurar el entorno de desarrollo SDK para desplegar aplicaciones Cordova para dispositivos como el Kindle fuego HDX Amazon fuego OS.
+
+Vea el siguiente para obtener más información específica de la plataforma:
+
+*   [Amazon fuego OS configuración](config.html)
+*   [Amazon fuego OS WebViews](webview.html)
+*   [Amazon fuego OS Plugins](plugin.html)
+
+## Introducción
+
+Al dirigirse a la plataforma Amazon fuego OS, Cordova los desarrolladores pueden crear aplicaciones web híbridas que aprovechan el motor web avanzada integrado en los dispositivos Kindle Fire. Amazon WebView API (AWV) es un tiempo de ejecución derivados del cromo web exclusivo de fuego OS. Un reemplazo de sobreponer para la vista Web que viene con dispositivos Android, AWV hace posible crear realizar mejor y más poderoso híbrido web apps proporcionando apoyo para un rápido motor JavaScript (V8), depuración remota y optimizaciones de hardware para los dispositivos Kindle Fire incluyendo un lienzo 2D acelerado, y acceso a características de HTML5 no soportado por Android construido en WebView tales como: Calc CSS, validación de formularios, getUserMedia, IndexedDB, los trabajadores Web, WebSockets y WebGL.
+
+Para obtener más información acerca de la Amazonía WebView API, consulte del Portal Amazon desarrollador [aplicaciones híbridas HTML5 página][1]. Para preguntas sobre comenzó y otros problemas de soporte, consulte el Amazonas Developer Portal [foros - aplicaciones híbridas HTML5][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
+
+## Requisitos y apoyo
+
+Desarrollando aplicaciones Cordova para Amazon fuego OS requiere la instalación de una variedad de archivos de apoyo, incluyendo todo lo necesario para el desarrollo de Android, así como el Amazonas WebView SDK. Compruebe la lista de abajo para las instalaciones necesarias:
+
+*   [La interfaz de linea de comandos](../../cli/index.html)
+*   [SDK de Android][3]
+*   [Apache Ant][4]
+*   [Amazon WebView SDK][1]
+
+ [3]: http://developer.android.com/sdk/
+ [4]: http://ant.apache.org
+
+## Instalación
+
+### El SDK de Android y Apache Ant
+
+Instalar el SDK de Android desde [developer.android.com/sdk][3]. Puede presentarse con una elección de donde instalar el SDK, de lo contrario mover el árbol descargado `adt-bundle` a dondequiera que usted almacenar herramientas de desarrollo.
+
+Usted necesitará ejecutar el administrador de Android SDK ( `android` de línea de comandos) al menos una vez antes de comenzar su proyecto Cordova. Asegúrese de instalar la versión más reciente del Android SDK Tools y plataforma SDK **específicamente nivel API 19**. Consulte [configurar el entorno de desarrollo][5] de la Amazonía Developer Portal para obtener más información sobre cómo configurar su entorno de desarrollo para dispositivos Kindle fuego OS.
+
+ [5]: https://developer.amazon.com/public/resources/development-tools/ide-tools/tech-docs/01-setting-up-your-development-environment
+
+Instalar el Apache Ant construir herramienta de [descarga una distribución binaria de hormiga][6], descomprimir en un directorio que puede consultar posteriormente. Consulte el [manual de hormiga][7] para obtener más información.
+
+ [6]: http://ant.apache.org/bindownload.cgi
+ [7]: http://ant.apache.org/manual/index.html
+
+Cordova Herramientas de línea de comandos trabajar, es necesario incluir el SDK de Android `tools` , `platform-tools` y `apache-ant/bin` directorios en su entorno PATH.
+
+#### Ruta de Mac/Linux
+
+En Mac, Linux u otras plataformas Unix-like, puede utilizar un editor de texto para crear o modificar el `~/.bash_profile` archivo, añadir una línea como la siguiente, dependiendo de donde están instalados los SDK y la hormiga:
+
+    export PATH = ${PATH}: / / adt-bundle/sdk/plataforma-herramientas de desarrollo: / / adt-bundle/sdk/herramientas de desarrollo: / desarrollo/apache-ant/bin
+    
+
+Esto expone SDK tools en windows terminales recién inauguradas. De lo contrario corre para que estén disponibles en el actual período de sesiones:
+
+    $ source ~/.bash_profile
+    
+
+#### Windows Path
+
+Para modificar el entorno PATH en Windows:
+
+*   Haga clic en el menú de **Start** en la esquina inferior izquierda del escritorio, haga clic derecho en el **Computer**, haga clic en **Properties**.
+
+*   En la columna de la izquierda, haga clic en **Configuración avanzada del sistema**.
+
+*   En el cuadro de diálogo resultante, presione **Environment Variables**.
+
+*   Seleccione la variable **PATH** y pulse **Editar**.
+
+*   Agregue lo siguiente a la ruta basada en donde se ha instalado el SDK de la hormiga, por ejemplo:
+    
+        ;C:\Development\adt-bundle\sdk\platform-tools;C:\Development\adt-bundle\sdk\tools;C:\Development\apache-ant\bin
+        
+
+*   El valor de guardar y cerrar ambos cuadros de diálogo.
+
+*   Usted también necesitará habilitar Java. Abra un símbolo del sistema y el tipo `java` , si no funciona, anexar su camino así como la ubicación de los binarios de Java. Asegúrese de que JAVA_HOME % apunta al directorio JDK instalado. Tendrás que agregar separadamente variable de entorno JAVA_HOME.
+    
+        ; %JAVA_HOME%\bin
+        
+
+### Amazon WebView SDK
+
+Para crear aplicaciones de Córdoba con el objetivo de la plataforma de Amazon fuego OS, usted necesitará descargar, descomprimir e instalar los archivos de soporte de Amazon WebView SDK. Este paso sólo tendrá que ser hecho por tu primer proyecto Amazonas fuego OS.
+
+*   Descargue el SDK de WebView Amazonas del [Amazonas Developer Portal][1].
+
+*   Copia `awv_interface.jar` del SDK descargado al directorio de trabajo de Cordova. Crear carpeta commonlibs(shown below) si no existe:
+    
+    **Mac/Linux:** `~/.cordova/lib/commonlibs/`
+    
+    **Windows:** `%USERPROFILE%\.cordova\lib\commonlibs`
+
+## Crear nuevo proyecto para el Amazonas fuego OS
+
+Uso el `cordova` utilidad para configurar un nuevo proyecto, como se describe en el Córdoba la comando-línea interfaz. Por ejemplo, en un directorio de código fuente:
+
+    $ cordova create hello com.example.hello "HelloWorld"
+    $ cd hello
+    $ cordova platform add amazon-fireos
+    $ cordova build
+    
+
+***Nota:*** La primera vez que la plataforma amazon-fireos está instalada en su sistema, se descargará los archivos correspondientes en el directorio de trabajo de Córdoba, pero entonces fracasará como le faltan los archivos de soporte AWV SDK (véase arriba). Siga las instrucciones anteriores para instalar el `awv_interface.jar` , luego quitar y volver a agregar la plataforma amazon-fireos a su proyecto. Este paso sólo tendrá que hacerse para primer proyecto Amazonas fuego OS.
+
+## Desplegar en el dispositivo
+
+Para empujar una aplicación directamente al dispositivo, asegúrese de depuración USB está habilitado en el dispositivo como se describe en el [Sitio para desarrolladores de Android][8]y utilice un cable mini-USB para conectarlo a su sistema.
+
+ [8]: http://developer.android.com/tools/device.html
+
+Usted puede empujar la aplicación para el dispositivo de la línea de comandos:
+
+    $ cordova ejecutar Amazonas-fireos
+    
+
+Alternativamente dentro de Eclipse, haga clic derecho en el proyecto y elija **Run As → Android Application**.
+
+**Nota**: Actualmente, la prueba mediante un emulador no es compatible para Amazon WebView basados en aplicaciones, además la API WebView Amazon sólo está disponible en dispositivos fuego OS. Para obtener más información, consulte la documentación de [Amazon WebView API SDK][1] .
+
+### Ejecutar las banderas
+
+Ejecutar el comando acepta parámetros opcionales como se especifica en el documento de Cordova Command Line Interface, fuego OS también acepta un adicional `--debug` bandera que permitirá herramientas para desarrolladores de cromo para la depuración de web remoto.
+
+Para utilizar las herramientas para desarrolladores, escriba:
+
+    $ cordova run --debug amazon-fireos
+    
+
+Esto permitirá a las herramientas en el cliente ejecutando. Entonces puede conectar al cliente por el reenvío de puertos mediante el Android Debug Bridge (adb) refiriéndose al nombre del paquete de la aplicación.
+
+Por ejemplo:
+
+    ADB tcp:9222 delantero localabstract:com.example.helloworld.devtools
+    
+
+Puede utilizar el DevTools mediante un navegador basado en Chromium desplazándose a:`http://localhost:9222`.
+
+### Soporte opcional de Eclipse
+
+Una vez creado, puede utilizar el Eclipse que viene con el SDK de Android para modificar el proyecto. Tenga cuidado que las modificaciones efectuadas a través de Eclipse se sobrescribirán si continúa utilizando herramientas de línea de comandos de Córdoba.
+
+*   Inicie la aplicación de **Eclipse**.
+
+*   Seleccione el elemento de menú **Nuevo proyecto**.
+
+*   Elija **Proyecto Android de código existente** en el cuadro de diálogo resultante y pulse **siguiente**: ![][9]
+
+*   Vaya a `hello` , o cualquier directorio que creó para el proyecto, luego en el `platforms/amazon-fireos` subdirectorio.
+
+*   Eclipse le mostrará el Hola y Hola-CorddovaLib - 2 proyectos a agregarse. Añadir ambos.
+
+*   Pulse **Finish**.
+
+ [9]: {{ site.baseurl }}/static/img/guide/platforms/android/eclipse_new_project.png
+
+Una vez que se abre la ventana de Eclipse, puede aparecer una **X** de color rojo indicar los problemas irresueltos. Si es así, siga estos pasos adicionales:
+
+*   Haga clic en el directorio del proyecto.
+
+*   En el cuadro de diálogo **Properties** resultante, seleccione **Android** desde el panel de navegación.
+
+*   Para el objetivo de construir proyecto, seleccione el nivel más alto de Android API (actualmente API nivel 19) instalado.
+
+*   Haga clic en **OK**.
+
+*   Seleccione **Clean** en el menú **Project**. Esto debería corregir todos los errores en el proyecto.

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/platforms/amazonfireos/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/amazonfireos/plugin.md b/www/docs/es/6.0.0/guide/platforms/amazonfireos/plugin.md
new file mode 100644
index 0000000..616abed
--- /dev/null
+++ b/www/docs/es/6.0.0/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 fuego OS Plugins
+---
+
+# Amazon fuego OS Plugins
+
+Siga las instrucciones proporcionadas en la guía de Plugins de Android para tener una visión general de desarrollo de plugins personalizados.
+
+## Ejemplo de Plugin de fuego OS echo Amazon
+
+Para hacer coincidir la función de *Eco* de la interfaz JavaScript descrita en Plugins de aplicación, utilice el `plugin.xml` para inyectar un `feature` Especificación de la plataforma local `config.xml` archivo:
+
+    <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>
+    
+
+Luego agregar lo siguiente a la `src/org/apache/cordova/plugin/Echo.java` archivo:
+
+    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.");
+            }
+        }
+    }
+    
+
+Si quieres reutilizar código Android Plugin para la plataforma de Amazon fuego OS entonces modificar el plugin.xml para señalar el `android` archivo fuente específica. Por ejemplo,
+
+    <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>
+    
+
+Si desea escribir un plugin modificado para requisitos particulares para la plataforma Amazon fuego OS creará una carpeta llamada `amazon` bajo tu plugin src / carpeta y modificar el plugin.xml para señalar el `amazon` archivo fuente específica. Por ejemplo,
+
+    <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>
+    
+
+## Usando Amazon WebView en tu plugin
+
+Cordova para Amazon fuego OS hace uso de personalizado WebView de Amazon que está construido sobre el proyecto de código abierto de cromo. Es GPU acelerada y optimizado para funcionamiento fluido en Kindle Fire.
+
+Para entender cómo utilizar mejor Amazon WebView en su proyecto, revisa el [Amazonas Developer Portal][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/a201cf64/www/docs/es/6.0.0/guide/platforms/amazonfireos/webview.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/amazonfireos/webview.md b/www/docs/es/6.0.0/guide/platforms/amazonfireos/webview.md
new file mode 100644
index 0000000..7754021
--- /dev/null
+++ b/www/docs/es/6.0.0/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 fuego OS WebViews
+---
+
+# Amazon fuego OS WebViews
+
+Comenzando con 3.3.0, puede utilizar Cordova como componente de aplicaciones de Amazon fuego OS. Amazon fuego OS hace referencia a este componente como `CordovaWebView` . `CordovaWebView`se extiende WebView de Amazon que se construye en el cromo proyecto de código abierto. Aprovechando esta característica, sus aplicaciones web pueden utilizar los últimos estándares web HTML5 en un motor de tiempo de ejecución web moderno.
+
+Si no está familiarizado con Amazon fuego OS, primero debe familiarizarse con la Amazonía fuego OS Platform Guide y tener instalado los últimos SDK antes de intentar la opción de desarrollo más inusual de incrustar un WebView.
+
+## Pre-requisitos
+
+*   Cordova 3.3.0 o mayor
+
+*   SDK de Android actualizado al último SDK
+
+*   Amazon WebView SDK
+
+## Guía de uso de CordovaWebView en un proyecto Amazonas fuego OS
+
+1.  Para seguir estas instrucciones, asegúrate de que tienes la última distribución de Córdoba. Descargar desde [cordova.apache.org][1] y descomprime su paquete de Amazon fuego OS.
+
+2.  Descargar y expandir el [Amazonas WebView SDK][2] , luego copiar el awv_interface.jar en `/framework/libs` Directorio. Crear un libs / carpeta si no existe.
+
+3.  Desplácese hasta el paquete `/framework` Directorio y ejecute `ant jar` . Crea el Cordova `.jar` archivo, formado como`/framework/cordova-x.x.x.jar`.
+
+4.  Copia el `.jar` archivo del proyecto Android `/libs` Directorio.
+
+5.  Agregar lo siguiente a la aplicación `/res/xml/main.xml` archivo, con el `layout_height` , `layout_width` y `id` modificado para adaptarse al uso:
+    
+        <org.apache.cordova.CordovaWebView
+            android:id="@+id/tutorialView"
+            android:layout_width="match_parent"
+            android:layout_height="match_parent" />
+        
+
+6.  Modificar su actividad para que implementa la `CordovaInterface`. Debe implementar los métodos incluidos. Puede que desee copiar desde `/framework/src/org/apache/cordova/CordovaActivity.java` , o implementarlas en tu propio. El fragmento de código siguiente muestra una aplicación básica que utiliza la interfaz. Observe cómo el id de referencia vista coincide con el atributo `id` especificado en el fragmento XML que se muestra arriba:
+    
+        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
+
+Si se utiliza la cámara, también debe implementar esto:
+
+        @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);
+            }
+        }
+    
+
+Finalmente, no olvide añadir el grupo de subprocesos, de lo contrario los plugins no tienen hilos para correr en:
+
+        @Override
+        public ExecutorService getThreadPool() {
+            return threadPool;
+        }
+    
+
+1.  Copia archivos HTML y JavaScript de la aplicación de su proyecto Amazonas fuego OS `/assets/www` Directorio.
+
+2.  Copia `config.xml` de `/framework/res/xml` a de su proyecto `/res/xml` Directorio.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/platforms/android/config.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/android/config.md b/www/docs/es/6.0.0/guide/platforms/android/config.md
new file mode 100644
index 0000000..a070a5d
--- /dev/null
+++ b/www/docs/es/6.0.0/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: Configuración de Android
+---
+
+# Configuración de Android
+
+El archivo `config.xml` controla la configuración básica de una app que se aplican a través de cada aplicación y una instancia de CordovaWebView. Esta sección detalla las preferencias que se aplican sólo a estructuras Android. Consulte [el archivo config.xml][1] para obtener información sobre las opciones de configuración global.
+
+ [1]: config_ref_index.md.html#The%20config.xml%20File
+
+*   `KeepRunning` (por defecto valor booleano, `true`): determina si la aplicación queda funcionando en segundo plano, incluso después de un `[pause](../../../cordova/events/events.pause.html)` de evento se desencadena. Si se establece como `false` no mata la aplicación después de un `[pause](../../../cordova/events/events.pause.html)` evento, sino simplemente detiene ejecución de código en la vista Web cordova mientras la aplicación está en el fondo.
+
+        <preference name="KeepRunning" value="false"/>
+
+
+*   `LoadUrlTimeoutValue`(número en milisegundos, por defecto `20000` , 20 segundos): cuando se carga una página, la cantidad de tiempo de espera antes de tirar un error de tiempo de espera. Este ejemplo especifica 10 segundos en lugar de 20:
+
+        <preference name="LoadUrlTimeoutValue" value="10000"/>
+
+
+*   `SplashScreen`(string, el valor predeterminado de `splash` ): el nombre del archivo sin su extensión en el `res/drawable` Directorio. Varios activos deben compartir este nombre común en diferentes subdirectorios.
+
+        <preference name="SplashScreen" value="mySplash"/>
+
+
+*   `SplashScreenDelay`(número en milisegundos, por defecto `3000` ): la cantidad de tiempo que muestra la imagen en pantalla splash.
+
+        <preference name="SplashScreenDelay" value="10000"/>
+
+
+*   `InAppBrowserStorageEnabled`(por defecto es booleano, `true` ): controles si abrieron páginas dentro de un InAppBrowser pueden acceder el mismo [localStorage](../../../cordova/storage/localstorage/localstorage.html) y WebSQL almacenamiento de información como páginas abrió con el navegador por defecto.
+
+        <preference name="InAppBrowserStorageEnabled" value="true"/>
+
+
+*   `LoadingDialog`(string, el valor predeterminado de `null` ): Si conjunto, muestra un diálogo con el mensaje y título especificado y un hilandero, cuando cargue la primera página de una aplicación. El título y el mensaje están separados por una coma en esta cadena de valor, y eso coma se retira antes de que se muestre el cuadro de diálogo.
+
+        <preference name="LoadingDialog" value="My Title,My Message"/>
+
+
+*   `LoadingPageDialog`(string, el valor predeterminado de `null` ): lo mismo que `LoadingDialog` , pero para cargar cada página después de la primera página de la aplicación.
+
+        <preference name="LoadingPageDialog" value="My Title,My Message"/>
+
+
+*   `ErrorUrl`(URL, por defecto `null` ): Si establece, se visualizará la página que se hace referencia a un error en la aplicación en lugar de un diálogo con el título "Error de aplicación".
+
+        <preference name="ErrorUrl" value="myErrorPage.html"/>
+
+
+*   `ShowTitle`(por defecto es booleano, `false` ): Mostrar el título en la parte superior de la pantalla.
+
+        <preference name="ShowTitle" value="true"/>
+
+
+*   `LogLevel`(string, el valor predeterminado de `ERROR` ): establece el nivel de registro mínimo a través de registro que se filtrarán los mensajes de la aplicación. Los valores válidos son `ERROR` , `WARN` , `INFO` , `DEBUG` , y`VERBOSE`.
+
+        <preference name="LogLevel" value="VERBOSE"/>
+
+
+*   `SetFullscreen`(por defecto es booleano, `false` ): igual que el `Fullscreen` parámetro en la configuración global de este archivo xml. Este elemento específico de Android está obsoleta a favor de la global `Fullscreen` elemento y se quitará en una versión futura.
+
+*   `AndroidLaunchMode`(string, el valor predeterminado de `singleTop` ): establece la actividad `android:launchMode` atributo. Esto cambia lo que pasa cuando la aplicación se inicia desde el icono de la aplicación o intención y está ya en ejecución. Los valores válidos son `standard` , `singleTop` , `singleTask` ,`singleInstance`.
+
+        <preference name="AndroidLaunchMode" value="singleTop"/>
+
+
+*   `DefaultVolumeStream`(string, el valor predeterminado de `default` , agregado en Córdoba-android 3.7.0): establece que volumen el volumen de hardware vinculan los botones. Por defecto es "llamar" por "medios" para tablets y teléfonos. Ajuste este parámetro a "medios" para los botones de volumen de su aplicación siempre cambiar el volumen de los medios de comunicación. Tenga en cuenta que al usar el plugin de los medios de comunicación de Cordova, los botones de volumen cambiará dinámicamente para controlar el volumen de los medios de comunicación cuando los objetos a los medios de comunicación están activos.
+
+*   `OverrideUserAgent` (string, no establece de forma predeterminada): si se establece, el valor reemplazará el viejo UserAgent de webview. Es útil identificar la petición del navegador de la aplicación cuando solicita páginas remotas. Uso con precaución, esto puede causa compitiable problema con servidores web. Para la mayoría de los casos, utilice AppendUserAgent.
+
+        <preference name="OverrideUserAgent" value="Mozilla/5.0 My Browser" />
+
+
+*   `AppendUserAgent` (string, no establece de forma predeterminada): Si establece, el valor agregará al final del viejo UserAgent de webview. Cuando se utiliza con OverrideUserAgent, este valor se omitirá.
+
+        <preference name="AppendUserAgent" value="My Browser" />

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/platforms/android/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/android/index.md b/www/docs/es/6.0.0/guide/platforms/android/index.md
new file mode 100644
index 0000000..a1583b4
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/platforms/android/index.md
@@ -0,0 +1,275 @@
+---
+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: Guía de la plataforma Android
+---
+
+# Guía de la plataforma Android
+
+Esta guía muestra cómo configurar su entorno SDK para desplegar aplicaciones Cordova para dispositivos Android y cómo utilizar opcionalmente Android centrado en herramientas de línea de comandos en su flujo de trabajo de desarrollo. Tienes que instalar el SDK de Android sin importar si desea utilizar estas herramientas plataforma centrada en la cáscara o multiplataforma Cordova CLI para el desarrollo. Para una comparación de las trayectorias de dos desarrollo, vea la información general. Para más detalles sobre el CLI, vea la interfaz de línea de comandos.
+
+## Requisitos y apoyo
+
+Cordova para Android requiere el SDK de Android que puede ser instalado en sistema operativo OS X, Linux o Windows. Consulte del SDK de Android [requisitos del sistema][1].
+
+ [1]: http://developer.android.com/sdk/index.html#Requirements
+
+Cordova soporta Android 4.0 (empezando por Android API nivel 14) y superiores. Como regla general, las versiones de Android se convierten soportadas por Cordova como sumergen por debajo del 5% en del Google [tablero de distribución][2]. Las versiones de Android antes de las API de nivel 10, y las versiones 3.x (panal, los niveles API 11-13) caen significativamente por debajo de ese umbral de 5%.
+
+ [2]: http://developer.android.com/about/dashboards/index.html
+
+## Instalar las herramientas de Shell Cordova
+
+Si desea utilizar herramientas de Cordova cáscara Android-centrado en conjunción con el SDK, descargar Cordova desde [cordova.apache.org][3]. De lo contrario ignorar esta sección si va a utilizar la herramienta CLI multiplataforma descrita en la interfaz de línea de comandos.
+
+ [3]: http://cordova.apache.org
+
+La descarga de Cordova contiene archivos separados para cada plataforma. Asegúrese de expandir el archivo apropiado, `android` en este caso, dentro de un directorio vacío. Las utilidades ejecutables correspondientes están disponibles en el nivel superior `bin` Directorio. (Si es necesario para obtener instrucciones más detalladas, consulte el archivo **README** ).
+
+Estas herramientas de shell le permiten crear, construir y ejecutar aplicaciones Android. Para obtener información sobre la interfaz de línea de comandos adicional que permite plugin características en todas las plataformas, ver usando Plugman para gestionar Plugins. Ver aplicación Plugins para obtener más información sobre cómo desarrollar plugins.
+
+## Instale el Kit de desarrollo de Java (JDK)
+
+Instalar [Java Development Kit (JDK) 7][4] o posterior.
+
+ [4]: http://www.oracle.com/technetwork/java/javase/downloads/jdk7-downloads-1880260.html
+
+Cuando se instala en Windows también tienes que definir la Variable de entorno `JAVA_HOME` según la ruta de instalación de JDK (por ejemplo, C:\Program Files\Java\jdk1.7.0_75).
+
+## Instalar el SDK de Android
+
+Instalar las [herramientas de Android SDK independiente][5] o [Android Studio][6]. Proceder con el `Estudio de Android` si tiene previsto desarrollar nueva Córdoba para Android plugins o utilizando herramientas nativas para ejecutar y depurar la plataforma Android. De lo contrario, `Stand-alone Android SDK Tools` son suficientes para construir e implementar aplicaciones Android.
+
+ [5]: http://developer.android.com/sdk/installing/index.html?pkg=tools
+ [6]: http://developer.android.com/sdk/installing/index.html?pkg=studio
+
+Instrucciones de instalación detalladas están disponibles como parte de los enlaces de la instalación anteriores.
+
+Cordova Herramientas de línea de comandos para trabajar, o la CLI que se basa en ellos, necesita incluir directorios `Herramientas` y `herramientas de la plataforma` de la SDK en tu `camino`. En un Mac o Linux, puede utilizar un editor de texto para crear o modificar la `~/.bash_profile` archivo, agregar una línea como la siguiente, dependiendo de donde se instala el SDK:
+
+        export PATH=${PATH}:/Development/android-sdk/platform-tools:/Development/android-sdk/tools
+    
+
+Esta línea en `~/.bash_profile` expone estas herramientas en windows terminales recién inauguradas. Si tu ventana de terminal ya está abierto en OSX o para evitar un cierre de sesión/inicio de sesión en Linux, ejecute esto para que estén disponibles en la ventana de terminal actual:
+
+        $ source ~/.bash_profile
+    
+
+Para modificar el entorno `PATH` en Windows:
+
+1.  Haga clic en el menú de **Inicio** en la esquina inferior izquierda del escritorio, haga clic derecho sobre **equipo**y seleccione **Propiedades**.
+
+2.  Seleccione **Configuración avanzada del sistema** en la columna de la izquierda.
+
+3.  En el cuadro de diálogo resultante, presione **Environment Variables**.
+
+4.  Seleccione la variable **PATH** y pulse **Editar**.
+
+5.  Añadir lo siguiente a la `PATH` basada en donde se ha instalado el SDK, por ejemplo:
+    
+        ;C:\Development\android-sdk\platform-tools;C:\Development\android-sdk\tools
+        
+
+6.  El valor de guardar y cerrar ambos cuadros de diálogo.
+
+## Instalar paquetes SDK
+
+Abrir el administrador de Android SDK (por ejemplo, a través de terminal: `android`) e instalar:
+
+1.  5.1.1 Android (API 22) platform SDK
+2.  Android SDK Build-tools versión 19.1.0 o superior
+3.  Repositorio de Android soporte (Extras)
+
+Ver [Instalar paquetes SDK][7] para obtener más detalles.
+
+ [7]: http://developer.android.com/sdk/installing/adding-packages.html
+
+## Configurar un emulador
+
+El sdk de Android no proporciona ninguna instancia de emulador predeterminada por defecto. Puede crear una nueva ejecutando `android` en la línea de comandos. La prensa **Herramientas → administrar AVDs** (Android dispositivos virtuales), luego elegir cualquier artículo de **Definiciones de dispositivos** en el cuadro de diálogo resultante:
+
+![][8]
+
+ [8]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_device.png
+
+Pulse **Crear AVD**, opcionalmente modificar el nombre, luego pulse **OK** para aceptar los cambios:
+
+![][9]
+
+ [9]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_newAVD.png
+
+La AVD entonces aparece en la lista de **Dispositivos Android Virtual** :
+
+![][10]
+
+ [10]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_avds.png
+
+Para abrir el emulador como una aplicación independiente, seleccione la AVD y presione **Start**. Se lanza como lo haría en el dispositivo, con controles adicionales disponibles para los botones de hardware:
+
+![][11]
+
+ [11]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_emulator.png
+
+Para una experiencia más rápida, puede utilizar la `Aceleración de la máquina Virtual` para mejorar la velocidad de ejecución. Muchas CPUs modernas ofrecen extensiones para ejecutar máquinas virtuales más eficientemente. Antes de usar este tipo de aceleración, es necesario determinar si CPU de su sistema actual de desarrollo, uno admite las siguientes tecnologías de virtualización:
+
+*   **Tecnología de virtualización Intel** (VT-x, vmx) → [Intel VT-x procesador lista soportada][12]
+*   **AMD Virtualization** (AMD-V, SVM), sólo se admite para Linux (desde mayo de 2006, todas las CPUs de AMD incluyen AMD-V, excepto Sempron).
+
+ [12]: http://ark.intel.com/products/virtualizationtechnology
+
+Otra forma de averiguar si su procesador Intel compatible con la tecnología VT-x, es mediante la ejecución de la `Utilidad de identificación de procesadores Intel`, para `Windows`puede descargarlo desde el [Centro de descarga][13]de Intel, o puede utilizar la [utilidad booteable][14], que es `Independiente del 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
+
+Después de instalar y ejecutar la `Utilidad de identificación de procesador Intel` sobre ventanas, obtendrá la ventana siguiente, con el fin de comprobar si su CPU es compatible con las tecnologías de virtualización:
+
+![][15]
+
+ [15]: {{ site.baseurl }}/static/img/guide/platforms/android/intel_pid_util_620px.png
+
+Para acelerar el emulador, tienes que descargar e instalar uno o más imágenes del sistema `x 86 de Intel Atom` , así como el `Intel Hardware acelerado ejecución Manager (HAXM)`.
+
+Abre tu Android SDK Manager y seleccione la imagen del sistema `x 86 de Intel Atom` , para cualquier versión que desea probar. Luego ir a `Extras` `Acelerador Intel x 86 de emulador (HAXM)`y seleccione instalar los paquetes:
+
+![][16]
+
+ [16]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_man_intel_image_haxm.png
+
+Después de la descarga, ejecute al instalador de Intel, que está disponible en el SDK de Android en `extras/intel/Hardware_Accelerated_Execution_Manager`. **Nota**:`si tienes algún problema al instalar el paquete, usted puede encontrar más información y orientación paso a paso revise este` [Artículo de Intel][17].
+
+ [17]: http://software.intel.com/en-us/android/articles/speeding-up-the-android-emulator-on-intel-architecture
+
+1.  Instalar una o más imágenes del sistema `x 86 de Intel Atom` , así como la `Acelerada ejecución administrador de Hardware de Intel`, disponible bajo **Extras**.
+
+2.  Ejecute al instalador de Intel, que está disponible en el SDK de Android en `extras/intel/Hardware_Accelerated_Execution_Manager`.
+
+3.  Crear un nuevo AVD con el objetivo fijado a una imagen de Intel.
+
+4.  Al iniciar el emulador, asegúrese que no hay error mensajes indicando la imposibilidad de cargar módulos HAX.
+
+## Crear un nuevo proyecto
+
+En este punto, para crear un nuevo proyecto puede elegir entre la herramienta de la cruz-plataforma CLI que se describe en la interfaz de línea de comandos, o el conjunto de herramientas de shell específicas para Android. Desde dentro de un directorio del código fuente, aquí es el enfoque CLI:
+
+        $ cordova create hello com.example.hello HelloWorld
+        $ cd hello
+        $ cordova platform add android
+        $ ccordova prepare              # or "cordova build"
+    
+
+Aquí es el enfoque de shell-herramienta de nivel inferior correspondiente para Unix y 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
+    
+
+## Construcción del proyecto
+
+Si utilizas la CLI en desarrollo, directorio de nivel superior `www` del directorio proyecto contiene los archivos de origen. Ejecutar cualquiera de éstos dentro del directorio del proyecto para la reconstrucción de la aplicación:
+
+        $ 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
+    
+
+Si está utilizando las herramientas de shell específicas para Android en desarrollo, hay un enfoque diferente. Una vez que se genera el proyecto, fuente de la aplicación por defecto está disponible en el subdirectorio de `activos/www` . Los comandos están disponibles en su subdirectorio `cordova` .
+
+El comando `build` limpia archivos de proyecto y reconstruye la aplicación. Aquí está la sintaxis para Mac y Windows. El primer par de ejemplos generará información de depuración, y la segunda crea las aplicaciones para el lanzamiento:
+
+        $ /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
+    
+
+## Desplegar la aplicación
+
+Puede utilizar la utilidad CLI `cordova` para desplegar la aplicación en el emulador o el dispositivo desde la línea de comandos:
+
+        $ cordova emulate android       #to deploy the app on a default android emulator
+        $ cordova run android --device  #to deploy the app on a connected device
+    
+
+De lo contrario, utilice la interfaz de shell alterno:
+
+        $ /path/to/project/cordova/run --emulator
+        $ /path/to/project/cordova/run --device
+    
+
+Puede utilizar **cordova run android --list** para ver todos los destinos disponibles y **cordova run android --target = target_name** para ejecutar la aplicación en un dispositivo específico o un emulador (por ejemplo, `cordova run android --target = "Nexus4_emulator"`).
+
+También puede utilizar **cordova run --help** para ver opciones adicionales para construir y correr.
+
+Esto empuja la aplicación a la pantalla de inicio y lo lanza:
+
+![][18]
+
+ [18]: {{ site.baseurl }}/static/img/guide/platforms/android/emulator2x.png
+
+Cuando se `ejecuta` la aplicación, también se `construye` . Puede anexar adicional `--debug`, `--release`y `--nobuild` banderas para controlar cómo se construye, o incluso si es necesaria una reconstrucción:
+
+        $ /path/to/project/cordova/run --emulator --nobuild
+    
+
+## Otros comandos
+
+Los siguientes genera un registro detallado de la aplicación que se ejecuta:
+
+        $ /path/to/project/cordova/log
+        C:\path\to\project\cordova\log.bat
+    
+
+A continuación limpia los archivos del proyecto:
+
+        $ /path/to/project/cordova/clean
+        C:\path\to\project\cordova\clean.bat
+    
+
+## Abra un nuevo proyecto en el SDK
+
+Una vez que la plataforma android se agrega a su proyecto, puede abrir desde dentro de [Android Studio][6]:
+
+1.  Inicie la aplicación **Android Studio** .
+
+2.  Seleccione **Importar proyecto (Eclipse ADT, Gradle, etc.)**.
+    
+    ![][19]
+
+3.  Seleccione la ubicación donde la plataforma android es almacenado (`su/proyecto/platform/android`).
+    
+    ![][20]
+
+4.  Para la pregunta `Gradle Sync` puede responder simplemente **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
+
+Listo ahora y puede construir y ejecutar la aplicación directamente desde `Android Studio`.
+
+![][21]
+
+ [21]: {{ site.baseurl }}/static/img/guide/platforms/android/asdk_import_done.png
+
+Ver [Resumen estudio Android][22] y [construcción y huyendo de Android Studio][23] para más detalles.
+
+ [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/a201cf64/www/docs/es/6.0.0/guide/platforms/android/plugin.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/android/plugin.md b/www/docs/es/6.0.0/guide/platforms/android/plugin.md
new file mode 100644
index 0000000..5521d0d
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/platforms/android/plugin.md
@@ -0,0 +1,182 @@
+---
+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: Android Plugins
+---
+
+# Android Plugins
+
+Esta sección proporciona información sobre cómo implementar código plugin nativo en la plataforma Android. Antes de leer esto, vea aplicación Plugins para tener una visión general de la estructura del plugin y su interfaz común de JavaScript. Esta sección sigue demostrando el plugin *Eco* muestra que comunica desde la webview Cordova a la plataforma nativa y de regreso. Otro ejemplo, vea también los comentarios en [CordovaPlugin.java][1].
+
+ [1]: https://github.com/apache/cordova-android/blob/master/framework/src/org/apache/cordova/CordovaPlugin.java
+
+Android plugins se basan en Córdoba-Android, el cual consiste en un WebView androide con ganchos conectados a él. Plugins son representados como asignaciones de clase en el `config.xml` archivo. Un plugin consiste en por lo menos una clase Java que extiende la `CordovaPlugin` clase, reemplazando a uno de sus `execute` métodos. Como mejor práctica, el plugin debe también manejar `[pause](../../../cordova/events/events.pause.html)` y `[resume](../../../cordova/events/events.resume.html)` eventos, junto con cualquier mensaje pasando entre plugins. Plugins con solicitudes de larga duración, actividad de fondo como medios de reproducción, los oyentes o estado interno debe implementar el `onReset()` método también. Se ejecuta cuando el `WebView` se desplaza a una nueva página o actualizaciones, que vuelve a cargar el JavaScript.
+
+## Asignación de clase plugin
+
+Interfaz de JavaScript del plugin utiliza el `cordova.exec` método de la siguiente manera:
+
+        exec (< successFunction >, < failFunction >, < service >, < acción > [< args >]);
+    
+
+Esto mariscales una petición desde el WebView al lado nativo Android, llamando con eficacia el `action` método de la `service` clase, con argumentos adicionales en el `args` matriz.
+
+Si usted distribuye un plugin como archivo de Java o como un archivo *jar* de su propio, el plugin debe especificarse en la aplicación Cordova-Android `res/xml/config.xml` archivo. Ver aplicación Plugins para obtener más información sobre cómo utilizar el `plugin.xml` archivo para inyectar este `feature` elemento:
+
+        <feature name="<service_name>">
+            <param name="android-package" value="<full_name_including_namespace>" />
+        </feature>
+    
+
+El nombre de servicio coincide con la utilizada en el JavaScript `exec` llamar. El valor es el identificador de la clase Java de nombres completos. De lo contrario, el plugin puede compilar pero todavía estar disponible a Córdoba.
+
+## Vida e inicialización de Plugin
+
+Para la vida de cada uno se crea una instancia de un objeto plugin `WebView` . Plugins no se instancian hasta que primero se hace referencia mediante una llamada desde JavaScript, a menos que `<param>` con un `onload` `name` atributo se establece en `"true"` en `config.xml` . Por ejemplo:
+
+    <feature name="Echo">
+        <param name="android-package" value="<full_name_including_namespace>" />
+        <param name="onload" value="true" />
+    </feature>
+    
+
+Plugins deberían utilizar el `initialize` método para su lógica puesta en marcha.
+
+    @Override
+    public void initialize(CordovaInterface cordova, CordovaWebView webView) {
+        super.initialize(cordova, webView);
+        // your init code here
+    }
+    
+
+## Escribir un Plugin de Java Android
+
+Una llamada JavaScript dispara una solicitud plugin nativo al lado, y el plugin de Java correspondiente se asigna correctamente en el `config.xml` archivo, pero ¿qué aspecto tiene el final Android Java Plugin clase? Lo que es enviado al plugin de JavaScript `exec` función se pasa a la clase plugin `execute` método. La mayoría de las implementaciones de `execute` este aspecto:
+
+        @Override public boolean ejecutar (acción de las cuerdas, JSONArray args, CallbackContext callbackContext) lanza JSONException {si ("beep".equals(action)) {this.beep(args.getLong(0));
+                callbackContext.success();
+                devuelve true;
+            } devolver false;  / / Devolver resultados falsos en un error de "MethodNotFound".
+        }
+    
+
+El JavaScript `exec` de función `action` parámetro corresponde a un método de clase privada para despachar con parámetros opcionales.
+
+Cuando captura de excepciones y devolver errores, es importante en aras de la claridad que los errores devueltos a nombres de excepción de JavaScript partido Java tanto como sea posibles.
+
+## Threading
+
+JavaScript del plugin hace *no* ejecuta en el subproceso principal de la `WebView` interfaz; en cambio, se ejecuta en el `WebCore` del hilo de rosca, como lo hace el `execute` método. Si usted necesita interactuar con la interfaz de usuario, debe usar las siguientes variaciones:
+
+        @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 lo siguiente si no tienes que ejecutar en la interfaz principal del hilo, pero no queremos bloquear la `WebCore` o del hilo de rosca:
+
+        @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;
+        }
+    
+
+## Ejemplo de Plugin Android echo
+
+Para hacer coincidir la función de *Eco* de la interfaz JavaScript descrita en Plugins de aplicación, utilice el `plugin.xml` para inyectar un `feature` Especificación de la plataforma local `config.xml` archivo:
+
+        <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>
+    
+
+Luego agregar lo siguiente a la `src/org/apache/cordova/plugin/Echo.java` archivo:
+
+        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.");
+                }
+            }
+        }
+    
+
+Las importaciones necesarias en la parte superior del archivo amplía la clase de `CordovaPlugin` , cuyo `execute()` método reemplaza para recibir los mensajes de `exec()` . El `execute()` método primero comprueba el valor de `action` , para que en este caso hay sólo una válida `echo` valor. Cualquier otra acción devuelve `false` y resultados en un `INVALID_ACTION` error, que se traduce en un callback de error invocado en el lado de JavaScript.
+
+A continuación, el método recupera la cadena Eco usando el `args` del objeto `getString` método, especificando el primer parámetro pasado al método. Después de que el valor se pasa a un privado `echo` método es parámetro-verificar para asegurarse que no es `null` o una cadena vacía, en cuyo caso `callbackContext.error()` invoca callback de error de JavaScript. Si pasan los controles distintos, el `callbackContext.success()` pasa el original `message` cadena a callback éxito de JavaScript como un parámetro.
+
+## Integración de Android
+
+Características de Android un `Intent` sistema que permite que los procesos para comunicarse con los demás. Plugins tienen acceso a un `CordovaInterface` objeto, que puede acceder el Android `Activity` que ejecuta la aplicación. Esta es la `Context` necesaria para lanzar un nuevo Android `Intent` . El `CordovaInterface` permite plugins comenzar una `Activity` para obtener un resultado y para establecer el plugin de devolución de llamada para cuando el `Intent` devuelve a la aplicación.
+
+Desde Córdoba 2.0, Plugins directamente ya no puede acceder a la `Context` y el legado `ctx` miembro está obsoleto. Todos `ctx` , existen métodos en el `Context` , así que ambos `getContext()` y `getActivity()` puede devolver el objeto requerido.
+
+## Depuración Plugins Android
+
+Eclipse permite depurar plugins como fuente Java incluida en el proyecto. Sólo la versión más reciente de las herramientas de Desarrollador Android permite asociar código fuente a dependencias *JAR* , así que esta característica no está todavía completamente soportada.
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/platforms/android/tools.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/android/tools.md b/www/docs/es/6.0.0/guide/platforms/android/tools.md
new file mode 100644
index 0000000..a1e3179
--- /dev/null
+++ b/www/docs/es/6.0.0/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: Guía de herramientas de Shell Android
+---
+
+# Guía de herramientas de Shell Android
+
+Esta guía le muestra cómo utilizar el conjunto de Cordova de cáscara centrada en plataforma de herramientas para desarrollar aplicaciones Android. Este camino hacia el desarrollo, discutido en la descripción, puede ofrecer una mayor gama de opciones de desarrollo que la herramienta CLI multiplataforma descrita en la interfaz de línea de comandos. Por ejemplo, tienes que utilizar herramientas de shell cuando se despliega una costumbre Cordova WebView junto con componentes nativos. Antes de usar cualquier camino hacia el desarrollo, primero debe configurar el entorno de SDK de Android como se describe en la guía de la plataforma Android.
+
+Para habilitar herramientas de shell para Android, descargar Cordova de [cordova.apache.org][1]. La descarga contiene los archivos separados para cada plataforma. Ampliar cada uno de destino, `android` en este caso. Las herramientas pertinentes están normalmente disponibles en el nivel superior `bin` Directorio de otra manera, consulte el archivo **Léame** para obtener direcciones más detallada.
+
+ [1]: http://cordova.apache.org
+
+Estas herramientas le permiten crear, construir y ejecutar aplicaciones Android. Para obtener información sobre la interfaz de línea de comandos adicional que permite plugin características en todas las plataformas, ver usando Plugman para gestionar Plugins. Ver aplicación Plugins para obtener más información sobre cómo desarrollar plugins.
+
+## Crear un proyecto
+
+Ejecute el comando `create`, especificando la ruta existente para el proyecto, el identificador de paquete de reversa-dominio-estilo y nombre para mostrar de la aplicación. Aquí está la sintaxis para Mac/Linux y 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
+    
+
+## construir
+
+Esto limpia entonces construye un proyecto.
+
+Depuración, en Mac/Linux o Windows:
+
+        $ /path/to/project/cordova/build --debug
+    
+        C:\>\path\to\project\cordova\build.bat --debug
+    
+
+Lanzamiento, el Mac/Linux o Windows:
+
+        $ /path/to/project/cordova/build --release
+    
+        C:\>\path\to\project\cordova\build.bat --release
+    
+
+## Ejecute la aplicación
+
+El comando `run` acepta los siguientes parámetros *opcionales*:
+
+*   Especificación de destino. Esto incluye `--emulador`, `, device`, o `--target = <targetID>`.
+
+*   Especificación de construir. Esto incluye `--debug`, `--release`, o `--nobuild`.
+    
+        $ /path/to/project/cordova/run [Target] [Build]
+        
+        C:\>\path\to\project\cordova\run.bat [Target] [Build]
+        
+
+Asegúrese de que crear al menos un Virtual dispositivo Android, caso contrario se le pedirá a hacerlo con el comando `android`. Si más de una AVD está disponible como un objetivo, usted se pedirá para seleccionar uno. Por defecto el comando `run` detecta un dispositivo conectado, o ejecutando un emulador si no se encuentra ningún dispositivo.
+
+## Firmar la aplicación
+
+Usted puede revisar Android app firmando los requisitos aquí: http://developer.android.com/tools/publishing/app-signing.html
+
+Para firmar una aplicación, usted necesita los siguientes parámetros:
+
+*   Almacén de claves ( `--keystore` ): ruta de acceso a un archivo binario que puede contener un conjunto de claves.
+
+*   Contraseña del almacén de claves ( `--storePassword` ): contraseña para el almacén de claves
+
+*   Alias ( `--alias` ): el identificador especifica la clave privada utilizada para cantar.
+
+*   Contraseña ( `--password` ): contraseña de la clave privada especificada.
+
+*   Tipo del almacén de claves ( `--keystoreType` ): pkcs12, jks (por defecto: auto-detect basado en la extensión del archivo)
+
+Estos parámetros pueden especificarse usando los argumentos de línea de comandos arriba a `build` o `run` secuencias de comandos.
+
+Alternativamente, usted puede especificar en un archivo (build.json) de configuración construir ( `--buildConfig` ) argumento. Este es un ejemplo de un archivo de configuración de build:
+
+    {
+         "android": {
+             "debug": {
+                 "keystore": "..\android.keystore",
+                 "storePassword": "android",
+                 "alias": "mykey1",
+                 "password" : "password",
+                 "keystoreType": ""
+             },
+             "release": {
+                 "keystore": "..\android.keystore",
+                 "storePassword": "",
+                 "alias": "mykey2",
+                 "password" : "password",
+                 "keystoreType": ""
+             }
+         }
+     }
+    
+
+Para la firma de la liberación, las contraseñas pueden ser excluidas y el sistema emitirá un mensaje solicitando la contraseña.
+
+También hay soporte para mezclar y combinar los argumentos de línea de comandos y parámetros en el archivo build.json. Valores de los argumentos de línea de comandos tendrá prioridad. Esto puede ser útil para especificar contraseñas en la línea de comandos.
+
+## Registro
+
+        $ /path/to/project/cordova/log
+    
+        C:\>\path\to\project\cordova\log.bat
+    
+
+## Limpieza
+
+        $ /path/to/project/cordova/clean
+    
+        C:\>\path\to\project\cordova\clean.bat
+    
+
+## Construcción con Gradle
+
+A partir de cordova-android@4.0.0, proyecto construir usando [Gradle][2]. Para instrucciones sobre la construcción con ANT, consulte las versiones más antiguas de la documentación.
+
+ [2]: http://www.gradle.org/
+
+### Propiedades de Gradle
+
+Estas [propiedades][3] se pueden establecer para personalizar el build:
+
+ [3]: http://www.gradle.org/docs/current/userguide/tutorial_this_and_that.html
+
+*   **cdvBuildMultipleApks** (por defecto: false)
+    
+    Si se establece, a continuación, se generará varios archivos APK: uno por cada plataforma nativa admite proyectos de biblioteca (x 86, ARM, etc.). Esto puede ser importante si su proyecto utiliza grandes bibliotecas nativas, que pueden aumentar drásticamente el tamaño del APK generado.
+    
+    Si no, entonces se generará una sola APK que se pueden utilizar en todos los dispositivos.
+
+*   **cdvVersionCode**
+    
+    Reemplaza el versionCode en`AndroidManifest.xml`
+
+*   **cdvReleaseSigningPropertiesFile** (por defecto: liberación-signing.properties)
+    
+    Construye la ruta a un archivo .properties que contiene información de firma para el lanzamiento. El archivo debe parecerse:
+    
+        storeFile=relative/path/to/keystore.p12
+        storePassword=SECRET1
+        storeType=pkcs12
+        keyAlias=DebugSigningKey
+        keyPassword=SECRET2
+        
+    
+    `storePassword`y `keyPassword` son opcionales y se solicitará si se omite.
+
+*   **cdvDebugSigningPropertiesFile** (por defecto: debug-signing.properties)
+    
+    Se construye igual que cdvReleaseSigningPropertiesFile, pero para depuración. Útil cuando se necesita compartir una clave con otros desarrolladores.
+
+*   **cdvMinSdkVersion**
+    
+    Reemplaza el valor de `minSdkVersion` en `AndroidManifest.xml` . Útil cuando se crean múltiples fuente basado en versión de SDK.
+
+*   **cdvBuildToolsVersion**
+    
+    Reemplazar automáticamente detectado `android.buildToolsVersion` valor.
+
+*   **cdvCompileSdkVersion**
+    
+    Reemplazar automáticamente detectado `android.compileSdkVersion` valor.
+
+### Extendiendo build.gradle
+
+Si necesita personalizar `build.gradle` , algo que editar directamente, debe crear un archivo hermano llamado `build-extras.gradle` . Este archivo se incluirán por el principal `build.gradle` al presente. Aquí está un ejemplo:
+
+    # 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'
+    }
+    
+
+Tenga en cuenta que también puede incluir plugins `build-extras.gradle` archivos a través de:
+
+    <framework src="some.gradle" custom="true" type="gradleReference" />
+    
+
+### Ejemplo de construcción
+
+    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/a201cf64/www/docs/es/6.0.0/guide/platforms/android/upgrade.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/android/upgrade.md b/www/docs/es/6.0.0/guide/platforms/android/upgrade.md
new file mode 100644
index 0000000..55b6e4a
--- /dev/null
+++ b/www/docs/es/6.0.0/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: Actualizar Android
+---
+
+# Actualizar Android
+
+Esta guía le muestra cómo modificar proyectos Android para actualizar desde versiones anteriores de Cordova. La mayoría de estas instrucciones se aplica a proyectos creados con un conjunto mayor de herramientas de línea de comandos que preceden a la utilidad de la CLI de `cordova`. Vea la interfaz de línea de comandos para información de cómo actualizar la versión de la CLI.
+
+## Actualización a 4.0.0
+
+Hay pasos específicos la actualización necesarias para aprovechar los cambios significativos en 4.0.0. En primer lugar, los pasos de actualización común son necesarios como abajo.
+
+Proyectos no-CLI, ejecute:
+
+        bin/update path/to/project
+    
+
+Para proyectos de CLI:
+
+1.  Actualización de la `cordova` versión CLI. Vea la interfaz de línea de comandos.
+
+2.  Ejecute `cordova platform update android` en tus proyectos ya existentes.
+
+### Actualización de la lista blanca
+
+Todas las funcionalidades de lista blanca es implementada mediante plugin. Sin un plugin, su aplicación no está protegida por una lista blanca después de actualizar a 4.0.0. Córdoba tiene dos plugins de lista blanca, que proporcionan diferentes niveles de protección.
+
+1.  El plugin de `cordova-plugin-whitelist` *(recomendado)*
+    
+    *   Este plugin es muy recomendable, ya que es más seguro y configurable que la lista blanca en las versiones anteriores
+    *   Ver [cordova-plugin-whitelist][1] para obtener más información sobre los cambios de configuración necesarios
+    *   Run: `cordova plugin add cordova-plugin-crosswalk-webview`
+
+2.  El plugin `cordova-plugin-legacy-whitelist`
+    
+    *   Este plugin proporciona el mismo comportamiento de lista blanca como las versiones anteriores. Ver [cordova-plugin-legacy-whitelist][2]
+    *   No hay cambios en la configuración se requieren, pero ofrece menos protección que el plugin recomendado
+    *   Run: `cordova plugin add cordova-plugin-legacy-whitelist`
+
+ [1]: https://github.com/apache/cordova-plugin-whitelist
+ [2]: https://github.com/apache/cordova-plugin-legacy-whitelist
+
+### Utilizando el Crosswalk WebView
+
+De forma predeterminada, su aplicación continuará utilizando el sistema WebView proporcionado por el dispositivo. Si desea utilizar el paso de peatones WebView en lugar de eso, simplemente añada el plugin de cruce de peatones:
+
+    cordova plugin add cordova-plugin-crosswalk-webview
+    
+
+Al agregar el plugin, su aplicación tendrá el paso de peatones WebView instalado y configurado correctamente.
+
+### Actualización al Splashscreen Plugin
+
+Si su aplicación hace uso de una pantalla de bienvenida, que funcionalidad ha sido trasladado a un plugin. Las opciones de configuración para salpicadura pantallas son invariables. El actualización sólo paso necesario es añadir el plugin:
+
+    cordova plugin add cordova-plugin-splashscreen
+    
+
+## Actualización a 3.7.1 de 3.6.0
+
+Proyectos no-CLI, ejecute:
+
+        bin/update path/to/project
+    
+
+Para proyectos de CLI:
+
+1.  Actualización de la `cordova` versión CLI. Vea la interfaz de línea de comandos.
+
+2.  Ejecutar `cordova platform update android` en tus proyectos ya existentes.
+
+## Actualización a 3.3.0 de 3.2.0
+
+Siga las mismas instrucciones en cuanto a `3.2.0`.
+
+Comenzando con 3.3.0, el runtime Cordova ahora está compilado como una biblioteca de Android en vez de un frasco. Esto debería no tienen ningún efecto para el uso de línea de comandos, pero IDE los usuarios tendrán que importar el proyecto `MyProject-CordovaLib` recién agregado a su lugar de trabajo.
+
+## Actualización a 3.2.0 de 3.1.0
+
+Para los proyectos que se crearon con la Córdoba CLI:
+
+1.  Actualización de la `cordova` versión CLI. Vea la interfaz de línea de comandos.
+
+2.  Run `cordova platform update android`
+
+Para proyectos no creados con el cordova CLI, ejecute:
+
+        bin/update <project_path>
+    
+
+**ADVERTENCIA:** En 4.4 Android - Android 4.4.3, creando un archivo de entrada elemento con type="file" no abrirá el cuadro de diálogo selector de archivos. Esto es una regresión con cromo en Android y el problema puede ser reproducido en el navegador Chrome independiente en Android (véase http://code.google.com/p/android/issues/detail?id=62220) la solución sugerida es utilizar los plugins File Transfer y archivo para Android 4.4. Puedes escuchar para un evento onClick del tipo de entrada = "file" y luego aparecer un selector de archivos UI. Para atar los datos del formulario con la carga, puede utilizar JavaScript para fijar los valores del formulario a la solicitud POST multi-partes que hace File Transfer.
+
+## Actualización a 3.1.0 de 3.0.0
+
+Para los proyectos que se crearon con la Córdoba CLI:
+
+1.  Actualización de la `cordova` versión CLI. Vea la interfaz de línea de comandos.
+
+2.  Run `cordova platform update android`
+
+Para proyectos no creados con el cordova CLI, ejecute:
+
+        bin/update <project_path>
+    
+
+## Actualización a la CLI (3.0.0) de 2.9.0
+
+1.  Cree un nuevo proyecto de Apache Cordova 3.0.0 con cordova CLI, como se describe en la interfaz de línea de comandos.
+
+2.  Agregar tus plataformas el proyecto cordova, por ejemplo: `cordova platform add android`.
+
+3.  Copiar el contenido del directorio `www` de su proyecto al directorio `www` en la raíz del proyecto cordova que acaba de crear.
+
+4.  Copie cualquier activo nativo de su viejo proyecto en los directorios apropiados bajo `platforms/android`: este directorio es donde existe su proyecto cordova-android nativo.
+
+5.  Utilice la herramienta CLI cordova instalar algún plugin que necesita. Tenga en cuenta que la CLI maneja todo núcleo APIs como plugins, así pueden necesitar ser agregado. Sólo 3.0.0 plugins son compatibles con la CLI.
+
+## Actualizar a 3.0.0 desde 2.9.0
+
+1.  Crear un nuevo proyecto Apache Cordova Android.
+
+2.  Copie el contenido del directorio `www` al nuevo proyecto.
+
+3.  Copie cualquier nativos Android activos desde el directorio de `res` al nuevo proyecto.
+
+4.  Copiar algún plugin que instaló desde los subdirectorios `src` en el nuevo proyecto.
+
+5.  Asegúrese de actualizar cualquiera obsoleto `< plugin >` referencias desde el antiguo archivo `config.xml` para la nueva especificación `de <feature>` .
+
+6.  Actualice cualquier referencia al paquete `org.apache.cordova.api` para ser `org.apache.cordova`.
+    
+    **Nota**: todo núcleo APIs se han eliminado y deben instalarse como plugins. Para detalles, véase el Plugman usando para gestionar Plugins guía.
+
+## Actualizar a 2.9.0 2.8.0
+
+1.  Run `bin/update <project_path>`.
+
+## Actualizar a 2.8.0 desde 2.7.0
+
+1.  Quitar `cordova-2.7.0.jar` del directorio de `bibliotecas` del proyecto.
+
+2.  Añadir `cordova-2.8.0.jar` al directorio de `bibliotecas` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+<!-- SS Eclipse -->
+
+1.  Copie el nuevo `cordova.js` en su proyecto.
+
+2.  Actualizar el código HTML para usar el nuevo archivo `cordova.js` .
+
+3.  Copie el archivo `res/xml/config.xml` para que coincida con `framework/res/xml/config.xml`.
+
+4.  Actualización `framework/res/xml/config.xml` tener configuración similar como lo hizo anteriormente.
+
+5.  Copiar archivos de `bin/templates/cordova` del proyecto `cordova` directorio.
+
+## Actualizar a 2.7.0 desde 2.6.0
+
+1.  Quitar `cordova-2.6.0.jar` del directorio de `bibliotecas` del proyecto.
+
+2.  Añadir `cordova-2.7.0.jar` al directorio de `bibliotecas` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-2.7.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `cordova-2.7.0.js` .
+
+6.  Copiar el `res/xml/config.xml` para que coincida con el `framework/res/xml/config.xml`.
+
+7.  Actualización `framework/res/xml/config.xml` tener configuraciones similares como lo hizo anteriormente.
+
+8.  Copiar los archivos de `bin/templates/cordova` para el proyecto `cordova` Directorio.
+
+## Actualizar a 2.6.0 2.5.0
+
+1.  Quitar `cordova-2.5.0.jar` del directorio de `bibliotecas` del proyecto.
+
+2.  Añadir `cordova-2.6.0.jar` al directorio de `bibliotecas` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.6.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.6.0.js` archivo.
+
+6.  Copiar el `res/xml/config.xml` para que coincida con el `framework/res/xml/config.xml`.
+
+7.  Actualización `framework/res/xml/config.xml` tener configuración similar como lo hizo anteriormente.
+
+8.  Copiar archivos de `bin/templates/cordova` del proyecto `cordova` directorio.
+
+Ejecute `bin/update <project>` con la ruta del proyecto figuran en el directorio fuente Cordova.
+
+## Actualizar a 2.5.0 desde 2.4.0
+
+1.  Quitar `cordova-2.4.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-2.5.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.5.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.5.0.js` archivo.
+
+6.  Copiar el `res/xml/config.xml` para que coincida con el `framework/res/xml/config.xml`.
+
+7.  Actualización `framework/res/xml/config.xml` tener configuración similar como lo hizo anteriormente.
+
+8.  Copiar archivos de `bin/templates/cordova` del proyecto `cordova` directorio.
+
+## Actualizar a 2.4.0 de 2.3.0
+
+1.  Quitar `cordova-2.3.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-2.4.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.4.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.4.0.js` archivo.
+
+6.  Copiar el `res/xml/config.xml` para que coincida con el `framework/res/xml/config.xml`.
+
+7.  Copiar los archivos de `bin/templates/cordova` para el proyecto `cordova` Directorio.
+
+## Actualizar a 2.3.0 2.2.0
+
+1.  Quitar `cordova-2.2.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-2.3.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.3.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.3.0.js` archivo.
+
+6.  Copiar el `res/xml/config.xml` para que coincida con el `framework/res/xml/config.xml`.
+
+7.  Copiar los archivos de `bin/templates/cordova` para el proyecto `cordova` Directorio.
+
+## Actualizar a 2.2.0 de 2.1.0
+
+1.  Quitar `cordova-2.1.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-2.2.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.2.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.2.0.js` archivo.
+
+6.  Copia el `res/xml/config.xml` para que coincida con`framework/res/xml/config.xml`.
+
+7.  Copiar archivos de `bin/templates/cordova` del proyecto `cordova` directorio.
+
+## Actualizar a 2.1.0 desde 2.0.0
+
+1.  Quitar `cordova-2.0.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-2.1.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.1.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.1.0.js` archivo.
+
+6.  Copia el `res/xml/config.xml` para que coincida con`framework/res/xml/config.xml`.
+
+7.  Copiar archivos de `bin/templates/cordova` del proyecto `cordova` directorio.
+
+## Actualizar a 2.0.0 desde 1.9.0
+
+1.  Quitar `cordova-1.9.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-2.0.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-2.0.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-2.0.0.js` archivo.
+
+6.  Copia el `res/xml/config.xml` para que coincida con`framework/res/xml/config.xml`.
+
+En la 2.0.0 versión, el archivo `config.xml` combina y reemplaza `cordova.xml` y `plugins.xml`. Los archivos son desaprobados y mientras que aún trabajan en 2.0.0, dejarán de funcionar en una futura versión.
+
+## Actualizar a 1.9.0 desde 1.8.1
+
+1.  Quitar `cordova-1.8.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-1.9.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-1.9.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `cordova-1.9.0.js` .
+
+6.  Actualización de `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+Debido a la introducción de la `CordovaWebView` en la 1.9.0 liberación, plugins de terceros pueden no funcionar. Estos plugins necesita para obtener un contexto de la `CordovaInterface` usando `getContext()` o `getActivity()`. Si no eres un experimentado Desarrollador Android, por favor póngase en contacto con el mantenedor del plugin y añadir esta tarea a su localizador de fallas.
+
+## Actualizar a 1.8.0 desde 1.8.0
+
+1.  Quitar `cordova-1.8.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-1.8.1.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-1.8.1.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `cordova-1.8.1.js` .
+
+6.  Actualización de `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+## Actualizar a 1.8.0 de 1.7.0
+
+1.  Quitar `cordova-1.7.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-1.8.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-1.8.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-1.8.0.js` archivo.
+
+6.  Actualización `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+## Actualizar a 1.8.0 de 1.7.0
+
+1.  Quitar `cordova-1.7.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-1.8.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copiar el nuevo `cordova-1.8.0.js` en su proyecto.
+
+5.  Actualiza su HTML para usar el nuevo `cordova-1.8.0.js` archivo.
+
+6.  Actualización `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+## Actualizar a 1.7.0 desde 1.6.1
+
+1.  Quitar `cordova-1.6.1.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-1.7.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-1.7.0.js` en su proyecto.
+
+5.  Actualización `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+## Actualizar a 1.6.1 desde 1.6.0
+
+1.  Quitar `cordova-1.6.0.jar` del directorio de `bibliotecas` del proyecto.
+
+2.  Añadir `cordova-1.6.1.jar` al directorio de `bibliotecas` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-1.6.1.js` en su proyecto.
+
+5.  Actualización `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+## Actualizar a 1.6.0 desde 1.5.0
+
+1.  Quitar `cordova-1.5.0.jar` del directorio de `libs` del proyecto.
+
+2.  Añadir `cordova-1.6.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-1.6.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `cordova-1.6.0.js` .
+
+6.  Actualización de `res/xml/plugins.xml` para que coincida con el `framework/res/xml/plugins.xml`.
+
+7.  Reemplazar `res/xml/phonegap.xml` por `res/xml/cordova.xml` hasta `framework/res/xml/cordova.xml`.
+
+## Actualizar a 1.5.0 desde 1.4.0
+
+1.  Retire `phonegap-1.4.0.jar` del directorio del proyecto `libs` .
+
+2.  Añadir `cordova-1.5.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `cordova-1.5.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `cordova-1.5.0.js` .
+
+6.  Actualización de `res/xml/plugins.xml` para que coincida con `framework/res/xml/plugins.xml`.
+
+7.  Reemplazar `res/xml/phonegap.xml` por `res/xml/cordova.xml` hasta `framework/res/xml/cordova.xml`.
+
+## Actualizar a 1.4.0 de 1.3.0
+
+1.  Retire `phonegap-1.3.0.jar` del directorio del proyecto `libs` .
+
+2.  Añadir `phonegap-1.4.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `phonegap-1.4.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `phonegap-1.4.0.js` .
+
+6.  Actualización de `res/xml/plugins.xml` para que coincida con el `framework/res/xml/plugins.xml`.
+
+7.  Actualización de `res/xml/phonegap.xml` para que coincida con`framework/res/xml/phonegap.xml`.
+
+## Actualizar a 1.3.0 desde 1.2.0
+
+1.  Retire `phonegap-1.2.0.jar` del directorio del proyecto `libs` .
+
+2.  Añadir `phonegap-1.3.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `phonegap-1.3.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `phonegap-1.2.0.js` .
+
+6.  Actualización de `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+7.  Actualización `res/xml/phonegap.xml` para que coincida con`framework/res/xml/phonegap.xml`.
+
+## Actualizar a 1.2.0 desde 1.1.0
+
+1.  Retire `phonegap-1.1.0.jar` del directorio del proyecto `libs` .
+
+2.  Añadir `phonegap-1.2.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si usas Eclipse, por favor actualice su proyecto en Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `phonegap-1.2.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `phonegap-1.2.0.js` .
+
+6.  Actualización `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+7.  Actualización `res/xml/phonegap.xml` para que coincida con`framework/res/xml/phonegap.xml`.
+
+## Actualizar a 1.1.0 desde 1.0.0
+
+1.  Retire `phonegap-1.0.0.jar` del directorio del proyecto `libs` .
+
+2.  Añadir `phonegap-1.1.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si utilizas Eclipse, por favor actualizar su proyecto de Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `phonegap-1.1.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `phonegap-1.1.0.js` .
+
+6.  Actualización `res/xml/plugins.xml` para que coincida con`framework/res/xml/plugins.xml`.
+
+## Actualizar a 1.0.0 desde 0.9.6
+
+1.  Retire `phonegap-0.9.6.jar` del directorio del proyecto `libs` .
+
+2.  Añadir `phonegap-1.0.0.jar` al directorio de `libs` del proyecto.
+
+3.  Si utilizas Eclipse, por favor actualizar su proyecto de Eclipse y hacer una limpia.
+
+4.  Copie el nuevo `phonegap-1.0.0.js` en su proyecto.
+
+5.  Actualizar el código HTML para usar el nuevo archivo `phonegap-1.0.0.js` .
+
+6.  Agregar el `res/xml/plugins.xml` para que coincida con `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