cordova-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From ste...@apache.org
Subject [31/51] [abbrv] [partial] docs commit: added cordova 6.0.0 docs
Date Thu, 28 Jan 2016 18:11:08 GMT
http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/cli/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/cli/index.md b/www/docs/es/6.0.0/guide/cli/index.md
new file mode 100644
index 0000000..f573471
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/cli/index.md
@@ -0,0 +1,419 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: La interfaz de linea de comandos
+---
+
+# La interfaz de linea de comandos
+
+Esta guía le muestra cómo crear aplicaciones y exportarlas para varias plataformas móviles nativas mediante la interfaz de línea de comandos de `cordova` (CLI). Esta herramienta le permite crear nuevos proyectos, construirlas en diferentes plataformas y ejecutar en dispositivos reales o dentro de los emuladores. El CLI es la herramienta principal para el flujo de trabajo multiplataforma descrito en la sección principal. Sin embargo, también puede utilizar el CLI para inicializar el código del proyecto, para lo cual utiliza diversas plataformas SDK y herramientas de consola para el desarrollo continuo.
+
+## Pre-requisitos
+
+Antes de ejecutar cualquiera de las herramientas de línea de comandos, necesita instalar el SDK para cada plataforma. (Vea las guías de la plataforma para más detalles)
+
+Para añadir soporte o reconstruir un proyecto para cualquier plataforma, necesitará ejecutar la interfaz de línea de comandos desde la misma máquina que soporta el SDK de la plataforma. La CLI admite las siguientes combinaciones:
+
+*   iOS (Mac)
+*   Amazon Fire OS (Mac, Linux, Windows)
+*   Android (Mac, Linux, Windows)
+*   BlackBerry 10 (Mac, Linux, Windows)
+*   Windows Phone 8 (Windows)
+*   Windows (Windows)
+*   Firefox OS (Mac, Linux, Windows)
+
+En el Mac, es disponible a través de la aplicación de la *Terminal de* la línea de comandos. En el PC, está disponible como *Command Prompt* bajo *Accessories*.
+
+**Nota**: para las plataformas Windows, todavía puedes desarrollar en equipos Mac ejecutando Windows en una máquina virtual o en modo de arranque dual. Para las opciones disponibles, consulte la guía de la plataforma de Windows Phone 8 o la guía de la plataforma Windows.
+
+Lo más probable es que ejecute la CLI de diferentes máquinas, más tiene sentido mantener un repositorio de código fuente remota, cuyos activos tire hacia abajo para directorios de trabajo local.
+
+## Instalar la CLI de Cordova
+
+La herramienta de línea de comandos de Cordova se distribuye como un paquete de npm en un formato listo para usar. No es necesario compilarlo desde su código fuente.
+
+Para instalar la herramienta de línea de comandos de `cordova`, siga estos pasos:
+
+1.  Descargue e instale [Node.js][1]. Después de la instalación, usted debe ser capaz de ejecutar `node` y `npm` en la línea de comandos. Si lo desea, opcionalmente puede utilizar una herramienta como `nvm` o `nave` para manejar la instalación de Node.js.
+
+2.  Descarga e instala un [cliente de git][2], si ya no tienes uno. Después de la instalación, usted debe ser capaz de ejecutar a `git` en la línea de comandos. Aunque no utilices `git` manualmente, la CLI usa de fondo para descargar algunos archivos cuando se crea un nuevo proyecto.
+
+3.  Instale el módulo `cordova` utilizando el manejador de paquetes de Node.js `npm`. El módulo `cordova` sera descargado automáticamente por `npm`.
+
+ [1]: http://nodejs.org/
+ [2]: http://git-scm.com/
+
+*   en OS X y Linux:
+    
+            $ sudo npm install -g cordova
+        
+    
+    En OS X y Linux, prefijando la `npm` mando con `sudo` puede ser necesario instalar este desarrollo utilidad en otro modo restringido directorios tales como `/usr/local/share` . Si usted está utilizando la herramienta opcional nvm/nave o tener acceso de escritura al directorio de instalación, podrá omitir el `sudo` prefijo. Hay [más consejos][3] sobre el uso de `npm` sin `sudo` , si desea hacerlo.
+
+*   en Windows:
+    
+            C:\>npm install -g cordova
+        
+    
+    El `-g` bandera arriba dice `npm` instalar `cordova` en todo el mundo. De lo contrario será instalado en el `node_modules` subdirectorio del directorio de trabajo actual.
+    
+    Puede que necesites añadir el `npm` Directorio a su `PATH` para invocar a nivel mundial instalada `npm` módulos. En Windows, `npm` generalmente se puede encontrar en `C:\Users\username\AppData\Roaming\npm` . En OS X y Linux se puede encontrar generalmente en`/usr/local/share/npm`.
+    
+    El registro de instalación puede producir errores para cualquier plataforma desinstalado SDK.
+    
+    Después de la instalación, usted debe ser capaz de ejecutar `cordova` en la línea de comandos sin argumentos y debe imprimir el texto de ayuda.
+
+ [3]: http://justjs.com/posts/npm-link-developing-your-own-npm-modules-without-tears
+
+## Crear la aplicación
+
+Vaya al directorio donde mantener su código fuente y ejecutar un comando como el siguiente:
+
+        $ cordova create hello com.example.hello HelloWorld
+    
+
+Puede tomar algún tiempo para que el comando completar, así que tenga paciencia. Ejecutar el comando con el `-d` opción muestra información acerca de su progreso.
+
+El primer argumento *Hola* especifica un directorio que se generen para su proyecto. Este directorio ya no debería existir, Córdoba lo creará para usted. Página de inicio de su aplicación, junto con diversos recursos bajo `css`, `js` y `img`, que seguir común web convenciones de nomenclatura de archivos de desarrollo las casas su subdirectorio `www`. Estos activos se almacenarán en el sistema de archivos local del dispositivo, no sirve de forma remota. El archivo `config.xml` contiene metadatos importantes necesarios para generar y distribuir la aplicación.
+
+El segundo argumento `com.example.hello` proporciona un identificador de dominio reverso-estilo su proyecto. Este argumento es opcional, pero sólo si también omite el tercer argumento, puesto que los argumentos son posicionales. Puede editar este valor más adelante en el `config.xml` de archivos, pero tenga en cuenta que puede haber código generado fuera de `config.xml` utilizando este valor, tales como nombres de paquetes Java. El valor predeterminado es `io.cordova.hellocordova` , pero se recomienda que seleccione un valor apropiado.
+
+El tercer argumento `HelloWorld` da título de pantalla de la aplicación. Este argumento es opcional. Puede editar este valor más adelante en el `config.xml` de archivos, pero tenga en cuenta que puede haber código generado fuera de `config.xml` utilizando este valor, tales como nombres de clase de Java. El valor predeterminado es `HelloCordova` , pero se recomienda que seleccione un valor apropiado.
+
+## Añadir plataformas
+
+Todos los comandos posteriores necesitan ejecutarse en el directorio del proyecto, o cualquier subdirectorios dentro de su ámbito de aplicación:
+
+        $ cd hello
+    
+
+Antes de poder construir el proyecto, tienes que especificar un conjunto de plataformas de destino. Su capacidad para ejecutar estos comandos depende de si tu maquina soporta cada SDK, y si ya tienes instalación cada SDK. Ejecutar cualquiera de éstos desde un Mac:
+
+        $ cordova platform add ios
+        $ cordova platform add amazon-fireos
+        $ cordova platform add android
+        $ cordova platform add blackberry10
+        $ cordova platform add firefoxos
+    
+
+Ejecutar cualquiera de éstos desde una máquina Windows, donde *wp* se refiere a las diferentes versiones del sistema operativo Windows Phone:
+
+        plataforma $ cordova agregar $ wp8 cordova plataforma añadir windows plataforma $ cordova añadir plataforma amazon-fireos $ cordova añadir android $ cordova plataforma añadir $ blackberry10 cordova plataforma agregar firefoxos
+    
+
+Ejecutar esto para comprobar su sistema actual de plataformas:
+
+        $ cordova platforms ls
+    
+
+(Tenga en cuenta que los comandos `platform` y `platforms` son sinónimos).
+
+Ejecutar cualquiera de los siguientes comandos sinónimos para quitar una plataforma:
+
+        $ cordova platform remove blackberry10
+        $ cordova platform rm amazon-fireos
+        $ cordova platform rm android
+    
+
+Ejecución de comandos para agregar o quitar afecta a plataformas el contenido del directorio de *platforms* del proyecto, donde cada plataforma especificado aparece como un subdirectorio. El directorio de origen *www* se reproduce dentro del subdirectorio de cada plataforma, que aparece por ejemplo en `platforms/ios/www` o `platforms/android/assets/www`. Porque la CLI constantemente copia archivos desde la carpeta *www* fuente, sólo debe editar estos archivos y no los ubicado debajo de los subdirectorios de *plataformas* . Si utilizas software de control de versión, debe agregar esta carpeta *www* fuente, junto con la carpeta *se funde* , a su sistema de control de versión. (Puede encontrarse más información sobre la carpeta *se funde* en la sección de personalizar cada plataforma abajo).
+
+**ADVERTENCIA**: cuando se usa la CLI para construir su solicitud, usted debe *no* editar cualquiera de los archivos en el `/platforms/` Directorio si no sabes lo que estás haciendo, o si documentación especifica lo contrario. Los archivos de este directorio se sobrescriben rutinariamente al preparar las aplicaciones para la construcción, o cuando son instalar plugins.
+
+Si lo desea en este punto, puede utilizar un SDK como Eclipse o Xcode para abrir el proyecto que ha creado. Usted necesitará abrir el conjunto derivado de los activos de la `/platforms/` Directorio para desarrollar con un SDK. Esto es porque los archivos de metadatos específicos del SDK se almacenan dentro de la correspondiente `/platform/` subdirectorio. (Vea a las guías de plataforma para obtener información sobre cómo desarrollar aplicaciones dentro de cada IDE). Utilice este enfoque si simplemente quieres inicializar un proyecto mediante la CLI y luego cambiar a un SDK para trabajo nativo.
+
+Lea sobre si desea utilizar el enfoque de flujo de trabajo multiplataforma (CLI) para el ciclo completo de desarrollo.
+
+## Construir la aplicación
+
+De forma predeterminada, la secuencia de comandos `cordova create` genera una esquelética aplicación basada en web cuya página de inicio es el archivo del proyecto `www/index.html`. Editar esta aplicación que quieras, pero cualquier inicialización debe especificarse como parte de la `[deviceready](../../cordova/events/events.deviceready.html)` controlador de eventos, que se hace referencia por defecto de`www/js/index.js`.
+
+Ejecute el siguiente comando para crear iterativamente el proyecto:
+
+        $ cordova build
+    
+
+Esto genera un código específico de plataforma dentro del subdirectorio del proyecto `platforms`. Opcionalmente puede limitar el alcance de cada build a plataformas específicas:
+
+        $ cordova build ios
+    
+
+El comando `cordova build` es una abreviatura para el siguiente, que en este ejemplo también está orientado a una única plataforma:
+
+        $ cordova prepare ios
+        $ cordova compile ios
+    
+
+En este caso, una vez que `prepare`, puede utilizar Xcode SDK de Apple como alternativa para modificar y compilar el código específico de plataforma que Córdoba se genera dentro de `platforms/ios`. Puede utilizar el mismo enfoque con SDK de otras plataformas.
+
+## Probar la aplicación en un emulador o dispositivo
+
+SDK para plataformas móviles vienen a menudo incluidos con emuladores que ejecutan una imagen del dispositivo, así que usted puede lanzar la aplicación desde la pantalla principal y ver cómo interactúa con muchas características de la plataforma. Ejecutar un comando como el siguiente para reconstruir la app y visualizarlo en un emulador de una plataforma específica:
+
+        $ cordova emulate android
+    
+
+Algunas plataformas móviles emulan un dispositivo especial de forma predeterminada, como el iPhone iOS proyectos. Para otras plataformas, necesitará primero asociado a un dispositivo con un emulador.
+
+**Nota**: apoyo emulador no está actualmente disponible para Amazon fuego OS.
+
+(Vea a las guías de la plataforma para más detalles). Por ejemplo, usted puede ejecuta el comando `android` para lanzar el SDK de Android, luego ejecute una imagen del dispositivo en particular, que inicia según su comportamiento predeterminado:
+
+![][4]
+
+ [4]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_init.png
+
+Siguiendo con el comando `cordova emulate` refresca la imagen de emulador para mostrar la última aplicación, que ahora está disponible para el lanzamiento de la pantalla de Inicio:
+
+![][5]
+
+ [5]: {{ site.baseurl }}/static/img/guide/cli/android_emulate_install.png
+
+Alternativamente, puedes enchufe del auricular en el ordenador y probar la aplicación directamente:
+
+        $ cordova run android
+    
+
+Antes de ejecutar este comando, tienes que configurar el dispositivo para la prueba, siguiendo los procedimientos que varían para cada plataforma. En los dispositivos Android y Amazon fuego OS, tendrías que activar una opción de **depuración USB** en el dispositivo y quizás añadir un controlador USB dependiendo de su entorno de desarrollo. Ver a las guias de plataforma para obtener más información sobre los requisitos de cada plataforma.
+
+## Añadir funciones Plugin
+
+Cuando construyes y ver un nuevo proyecto, la aplicación predeterminada que aparece no hace mucho. Puede modificar la aplicación de muchas maneras a aprovechar las tecnologías web estándar, pero para que la aplicación para comunicar estrechamente con varias características de nivel de dispositivo, necesitará añadir plugins que proporcionan acceso a núcleo Cordova APIs.
+
+Un *plugin* es un poco de código adicional que proporciona una interfaz para componentes nativos. Usted puede diseñar su propia interfaz plugin, por ejemplo al diseñar una aplicación híbrida que combina un Cordova WebView con componentes nativos. (Véase WebViews incrustar y [Plugin Development Guide][6] para obtener más detalles). Más comúnmente, debe agregar un plugin para activar uno de los rasgos básicos de nivel de dispositivo de Cordova detallados en la referencia de la API.
+
+ [6]: guide_hybrid_plugins_index.md.html#Plugin%20Development%20Guide
+
+A partir de la versión 3.0, cuando se crea un proyecto de Córdoba no tiene presente algún plugin. Este es el nuevo comportamiento predeterminado. Algún plugin que desee, incluso los plugins del núcleo, debe agregarse explícitamente.
+
+Puede encontrarse una lista de estos plugins, plugins de terceros adicionales proporcionados por la comunidad, incluyendo en el registro en [plugins.cordova.io][7]. Puede utilizar la CLI para buscar plugins de este registro. Por ejemplo, buscando `bar` y `code` produce un solo resultado que coincide con ambos términos como subcadenas entre mayúsculas y minúsculas:
+
+ [7]: http://plugins.cordova.io/
+
+        $ cordova plugin search bar code
+    
+        com.phonegap.plugins.barcodescanner - Scans Barcodes
+    
+
+Buscando solamente el `bar` término rendimientos y resultados adicionales:
+
+        cordova-plugin-statusbar - Cordova StatusBar Plugin
+    
+
+El `cordova plugin add` comando requiere especificar el repositorio para el código del plugin. Estos son ejemplos de cómo puede usar la CLI para agregar funciones a la aplicación:
+
+*   Información básica del dispositivo (dispositivo API):
+    
+        $ cordova plugin add cordova-plugin-device
+        
+
+*   Conexión de red y eventos de batería:
+    
+        $ cordova plugin add cordova-plugin-network-information
+        $ cordova plugin add cordova-plugin-battery-status
+        
+
+*   Acelerómetro, brújula y geolocalización:
+    
+        $ cordova plugin add cordova-plugin-device-motion
+        $ cordova plugin add cordova-plugin-device-orientation
+        $ cordova plugin add cordova-plugin-geolocation
+        
+
+*   Cámara, reproducción multimedia y captura:
+    
+        $ cordova plugin add cordova-plugin-camera
+        $ cordova plugin add cordova-plugin-media-capture
+        $ cordova plugin add cordova-plugin-media
+        
+
+*   Acceder a archivos en el dispositivo o red (archivo API):
+    
+        $ cordova plugin add cordova-plugin-file
+        $ cordova plugin add cordova-plugin-file-transfer
+        
+
+*   Notificación mediante vibración o cuadro de diálogo:
+    
+        $ cordova plugin add cordova-plugin-dialogs
+        $ cordova plugin add cordova-plugin-vibration
+        
+
+*   Contactos:
+    
+        $ cordova plugin add cordova-plugin-contacts
+        
+
+*   Globalización:
+    
+        $ cordova plugin add cordova-plugin-globalization
+        
+
+*   SplashScreen:
+    
+        $ cordova plugin add cordova-plugin-splashscreen
+        
+
+*   Abrir nuevas ventanas del navegador (InAppBrowser):
+    
+        $ cordova plugin add cordova-plugin-inappbrowser
+        
+
+*   Consola de depuración:
+    
+        $ cordova plugin add cordova-plugin-console
+        
+
+**Nota**: el CLI agrega plugin código según proceda para cada plataforma. Si usted quiere desarrollar con las herramientas de nivel inferior cáscara o plataforma SDK como se indica en el [Resumen](../overview/index.html), tienes que ejecutar la utilidad Plugman para añadir plugins por separado para cada plataforma. (Para obtener más información, véase Plugman usando a gestionar Plugins).
+
+Uso `plugin ls` (o `plugin list` , o `plugin` por sí mismo) ver actualmente instalado plugins. Cada muestra por su identificador:
+
+        $ cordova plugin ls    # or 'plugin list'
+        [ 'cordova-plugin-console' ]
+    
+
+Para quitar un plugin, referirse a él por el mismo identificador que aparece en el listado. Por ejemplo, aquí es cómo quitaría apoyo para una consola de depuración de una versión:
+
+        $ cordova plugin rm cordova-plugin-console
+        $ cordova plugin remove cordova-plugin-console    # same
+    
+
+Puede lote-quitar o agregar plugins por especificar más de un argumento para cada comando:
+
+        $ cordova plugin add cordova-plugin-console cordova-plugin-device
+    
+
+## Opciones avanzadas Plugin
+
+Al agregar un plugin, varias opciones permiten especificar de dónde buscar el plugin. Los ejemplos anteriores utilizan una conocida `registry.cordova.io` del registro y el plugin es especificada por el `id` :
+
+        $ cordova plugin add cordova-plugin-console
+    
+
+El `id` también puede incluir el número de versión del plugin, anexado después de un `@` personaje. El `latest` versión es un alias para la versión más reciente. Por ejemplo:
+
+        $ cordova plugin add cordova-plugin-console@latest
+        $ cordova plugin add cordova-plugin-console@0.2.1
+    
+
+Si el plugin no está registrado en `registry.cordova.io` , pero se encuentra en otro repositorio git, puede especificar una URL alternativa:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git
+    
+
+El ejemplo de git anterior recupera el plugin desde el final de la rama principal, pero una alternativa git-ref como una etiqueta o rama puede ser añadido después de un `#` personaje:
+
+Instalar desde una etiqueta:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#r0.2.0
+    
+
+o sucursal:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#CB-8438cordova-plugin-console
+    
+
+o git-ref también podría ser una confirmación particular:
+
+        $ cordova plugin add https://github.com/apache/cordova-plugin-console.git#f055daec45575bf08538f885e09c85a0eba363ff
+    
+
+Si el plugin (y su `plugin.xml` archivo) está en un subdirectorio dentro del repositorio git, puede especificarlo con un `:` personaje. Tenga en cuenta que el `#` personaje es necesario:
+
+        $ cordova plugin add https://github.com/someone/aplugin.git#:/my/sub/dir
+    
+
+También puedes combinar el git-ref y el subdirectorio:
+
+        $ cordova plugin add https://github.com/someone/aplugin.git#r0.0.1:/my/sub/dir
+    
+
+Como alternativa, especifique una ruta de acceso local para el directorio que contiene el `plugin.xml` archivo:
+
+        $ cordova plugin add ../my_plugin_dir
+    
+
+## Usando *fusiona* a personalizar cada plataforma
+
+Mientras que Córdoba le permite implementar fácilmente una aplicación para muchas plataformas diferentes, a veces es necesario añadir personalizaciones. En ese caso, no desee modificar los archivos de código fuente en varios `www` directorios dentro del nivel superior `platforms` directorio, ya que regularmente son reemplazados con el nivel superior `www` fuente de la cruz-plataforma del directorio.
+
+En cambio, el nivel superior `merges` directorio ofrece un lugar para especificar activos a desplegar en plataformas específicas. Cada subdirectorio específico de la plataforma dentro de `merges` refleja la estructura del directorio de la `www` árbol de código fuente, lo que le permite reemplazar o agregar archivos según sea necesario. Por ejemplo, aquí es cómo usted utiliza `merges` para aumentar el tamaño de fuente predeterminado para dispositivos Android y Amazon fuego OS:
+
+*   Editar el `www/index.html` archivo, añadir un enlace a un archivo CSS adicional, `overrides.css` en este caso:
+    
+        <link rel="stylesheet" type="text/css" href="css/overrides.css" />
+        
+
+*   Opcionalmente crear un vacío `www/css/overrides.css` archivo, que se aplicaría para todas las versiones no-Android, evitando un error de archivo que falta.
+
+*   Crear un `css` subdirectorio dentro de `merges/android` , luego añadir un correspondiente `overrides.css` archivo. Especificar CSS que reemplaza el tamaño de letra de 12 puntos por defecto especificado dentro de `www/css/index.css` , por ejemplo:
+    
+        body { font-size:14px; }
+        
+
+Al reconstruir el proyecto, la versión de Android incluye el tamaño de fuente personalizado, mientras que otros permanecen sin cambios.
+
+También se puede utilizar `merges` para agregar archivos no presentan en el original `www` directorio. Por ejemplo, una aplicación puede incorporar un gráfico de *botón* en la interfaz de iOS, en `merges/ios/img/back_button.png` , mientras que la versión de Android en lugar de otro puede capturar `[backbutton](../../cordova/events/events.backbutton.html)` eventos desde el botón de hardware correspondiente.
+
+## Comandos de ayuda
+
+Córdoba cuenta con un par de comandos globales, que pueden ayudar si se atranca o experimenta un problema. El `help` comando muestra todos los comandos disponibles de Córdoba y su sintaxis:
+
+    $ cordova help
+    $ cordova        # same
+    
+
+Además, puede obtener ayuda más detallada sobre un comando específico. Por ejemplo:
+
+    $ cordova run --help
+    
+
+El `info` comando produce un listado de información potencialmente útiles, como instaladas plataformas, plugins, versiones SDK para cada plataforma y versiones de CLI y `node.js` :
+
+    $ cordova info
+    
+
+Tanto presenta la información en pantalla y captura la salida de un local `info.txt` archivo.
+
+**Nota**: Actualmente, sólo detalles en plataformas Android y iOS están disponibles.
+
+## Actualización de Córdoba y su proyecto
+
+Después de instalar el `cordova` utilidad, usted puede siempre actualizarlo a la última versión ejecutando el siguiente comando:
+
+        $ sudo npm update -g cordova
+    
+
+Para instalar una versión específica, utilice esta sintaxis:
+
+        $ sudo npm install -g cordova@3.1.0-0.2.0
+    
+
+Ejecute `cordova -v` para ver qué versión se está ejecutando actualmente. Ejecutar el `npm
+info` comando para una lista más larga que incluye la versión actual junto a otros números de versión:
+
+        $ npm info cordova
+    
+
+Cordova 3.0 es la primera versión para compatibles con la interfaz de línea de comandos descrita en esta sección. Si está actualizando desde una versión anterior a 3.0, necesita crear un nuevo proyecto como se describe arriba, entonces copia activos la mayor aplicación en el nivel superior `www` directorio. En su caso, más detalles sobre la actualización a 3.0 están disponibles en las guías de la plataforma. Una vez que se actualiza a la `cordova` interfaz de línea de comandos y uso `npm update` para permanecer vigente, los procedimientos más desperdiciadores de tiempo descritos allí ya no son relevantes.
+
+Cordova 3.0 + todavía puede requerir varios cambios a las estructuras de directorios a nivel de proyecto y otras dependencias. Después de ejecutar el `npm` comando arriba actualizar Cordova sí mismo, usted puede necesitar garantizar recursos de su proyecto se ajustan a los requisitos de la versión más reciente. Ejecutar un comando como el siguiente para cada plataforma vas a compilar:
+
+        $ cordova platform update android
+        $ cordova platform update ios
+        ...etc.

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/hybrid/plugins/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/hybrid/plugins/index.md b/www/docs/es/6.0.0/guide/hybrid/plugins/index.md
new file mode 100644
index 0000000..e6f22ef
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/hybrid/plugins/index.md
@@ -0,0 +1,177 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Guía de desarrollo de plugin
+---
+
+# Guía de desarrollo de plugin
+
+Un *plugin* es un paquete de código que permite la webview Cordova dentro de la cual hace que la aplicación para comunicarse con la plataforma nativa en la que se ejecuta. Plugins proporcionan acceso a la funcionalidad de plataforma y dispositivo que está normalmente disponible para aplicaciones basadas en web. Las principales características de Cordova API se implementan como plugins, y muchos otros están disponibles que permiten funciones tales como escáneres de código de barras, comunicación NFC, o adaptar el calendario interfaces. Hay un [registro][1] de extensiones disponibles.
+
+ [1]: http://plugins.cordova.io
+
+Plugins comprenden una única interfaz JavaScript junto con bibliotecas de código nativo correspondiente para cada plataforma soportada. En esencia esto esconde las diversas implementaciones de código nativo detrás de una interfaz común de JavaScript.
+
+A unos pasos esta sección a través de un plugin simple *Eco* que pasa una cadena de JavaScript a la plataforma nativa y posterior, que puede utilizar como modelo para construir características mucho más complejas. Esta sección analiza la estructura básica del plugin y la interfaz JavaScript de exteriores. Para cada interfaz nativa correspondiente, consulte la lista al final de esta sección.
+
+Además de estas instrucciones, cuando se prepara para escribir un plugin es mejor mirar sobre [plugins existentes][2] para orientación.
+
+ [2]: http://cordova.apache.org/#contribute
+
+## Construyendo un Plugin
+
+Los programadores de aplicaciones utilizan la CLI `plugin add` comando (discutido en la interfaz de línea de comandos) para aplicar un plugin para un proyecto. El argumento de este comando es la dirección URL de un repositorio *git* que contiene el código del plugin. Este ejemplo implementa dispositivo API de Cordova:
+
+        $ cordova plugin add https://git-wip-us.apache.org/repos/asf/cordova-plugin-device.git
+    
+
+El repositorio plugin debe cuentan con un alto nivel `plugin.xml` archivo de manifiesto. Hay muchas maneras de configurar este archivo, los detalles para los que están disponibles en la especificación del Plugin. Esta versión abreviada de la `Device` plugin proporciona un ejemplo sencillo de usar como un modelo:
+
+        <?xml version="1.0" encoding="UTF-8"?>
+        <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
+                id="cordova-plugin-device" version="0.2.3">
+            <name>Device</name>
+            <description>Cordova Device Plugin</description>
+            <license>Apache 2.0</license>
+            <keywords>cordova,device</keywords>
+            <js-module src="www/device.js" name="device">
+                <clobbers target="device" />
+            </js-module>
+            <platform name="ios">
+                <config-file target="config.xml" parent="/*">
+                    <feature name="Device">
+                        <param name="ios-package" value="CDVDevice"/>
+                    </feature>
+                </config-file>
+                <header-file src="src/ios/CDVDevice.h" />
+                <source-file src="src/ios/CDVDevice.m" />
+            </platform>
+        </plugin>
+    
+
+El nivel superior `plugin` de etiqueta `id` atributo utiliza el mismo formato de dominio reverso para identificar el paquete plugin como las aplicaciones que están agregadas. El `js-module` etiqueta especifica la ruta de acceso a la interfaz común de JavaScript. El `platform` etiqueta especifica un conjunto correspondiente de código nativo para la `ios` plataforma en este caso. El `config-file` etiqueta encapsula un `feature` etiqueta que se inyecta en la específica de la plataforma `config.xml` archivo a la plataforma de la biblioteca de código adicional. El `header-file` y `source-file` etiquetas especifican la ruta de acceso a archivos de la biblioteca componentes.
+
+## Validación de un Plugin
+
+Puede utilizar la `plugman` utilidad para comprobar si el plugin se instala correctamente para cada plataforma. Instalar `plugman` con el siguiente comando de [nodo][3] :
+
+ [3]: http://nodejs.org/
+
+        $ npm install -g plugman
+    
+
+Necesita un directorio fuente válida de la aplicación, tales como el nivel superior `www` directorio incluido en un proyecto generado por CLI predeterminado como se describe en la interfaz de línea de comandos. Asegúrese de que la aplicación de `index.html` página de inicio de referencia el nombre de JavaScript interfaz del plugin, como si estuviera en el mismo directorio fuente:
+
+        <script src="myplugin.js"></script>
+    
+
+Luego ejecutar un comando como el siguiente para comprobar las dependencias iOS carguen adecuadamente:
+
+         $ plugman install --platform ios --project /path/to/my/project/www --plugin /path/to/my/plugin
+    
+
+Para obtener más información sobre `plugman` Opciones, vea usando Plugman para gestionar Plugins. Para obtener información sobre cómo realmente *depurar* plugins, consulte interfaz nativa de cada plataforma enumerado en la parte inferior de esta página.
+
+## La interfaz de JavaScript
+
+El JavaScript proporciona la interfaz de frente, por lo que es quizás la parte más importante del plugin. Usted puede estructurar JavaScript de tu plugin sin embargo te gusta, pero tiene que llamar a `cordova.exec` para comunicarse con la plataforma nativa, usando la siguiente sintaxis:
+
+        cordova.exec(function(winParam) {},
+                     function(error) {},
+                     "service",
+                     "action",
+                     ["firstArgument", "secondArgument", 42, false]);
+    
+
+Aquí está cómo funciona cada parámetro:
+
+*   `function(winParam) {}`: Una función de devolución de llamada de éxito. Asumiendo que tu `exec` llamada se realiza correctamente, esta función se ejecuta junto con cualquiera de los parámetros pasas.
+
+*   `function(error) {}`: Una función de callback de error. Si la operación no se completa correctamente, esta función se ejecuta con un parámetro opcional de error.
+
+*   `"service"`: El nombre del servicio que llame al lado nativo. Esto corresponde a una clase nativa, para lo cual existe más información en las guías nativas enumeradas a continuación.
+
+*   `"action"`: El nombre de acción para llamar al lado nativo. Esto generalmente corresponde al método de la clase nativa. Consulte a las guías nativos enumerados a continuación.
+
+*   `[/* arguments */]`: Un conjunto de argumentos que se pasarán en el entorno nativo.
+
+## Muestra JavaScript
+
+Este ejemplo muestra una forma de implementar interfaz del plugin JavaScript:
+
+        window.echo = function(str, callback) {
+            cordova.exec(callback, function(err) {
+                callback('Nothing to echo.');
+            }, "Echo", "echo", [str]);
+        };
+    
+
+En este ejemplo, el plugin se adhiere a la `window` objeto como la `echo` la función, que llamarían a los usuarios plugin como sigue:
+
+        window.echo("echome", function(echoValue) {
+            alert(echoValue == "echome"); // should alert true.
+        });
+    
+
+Mira a los tres últimos argumentos de la `cordova.exec` función. Las primeras convocatorias del `Echo` *servicio*, un nombre de clase. El segundo pide la `echo` *acción*, un método dentro de esa clase. La tercera es una matriz de argumentos que contengan la cadena Eco, que es el `window.echo` función es el primer parámetro.
+
+El callback de éxito pasó a `exec` es simplemente una referencia a la función de callback `window.echo` toma. Si la plataforma nativa despide el callback de error, simplemente pide la devolución de llamada de éxito y pasa una cadena predeterminada.
+
+## Interfaces nativas
+
+Una vez se define JavaScript para tu plugin, debes complementarlo con por lo menos una aplicación nativa. Los datos de cada plataforma se enumeran a continuación, y cada uno se basa en el simple ejemplo Eco Plugin anterior:
+
+*   [Amazon fuego OS Plugins](../../platforms/amazonfireos/plugin.html)
+*   [Android Plugins](../../platforms/android/plugin.html)
+*   [iOS Plugins](../../platforms/ios/plugin.html)
+*   [BlackBerry 10 Plugins](../../platforms/blackberry10/plugin.html)
+*   [Windows Phone 8 Plugins](../../platforms/wp8/plugin.html)
+*   [Windows Plugins](../../platforms/win8/plugin.html)
+
+La plataforma Tizen no admite plugins.
+
+## Editorial Plugins
+
+Una vez que desarrollas tu plugin, quizá quieras publicar y compartir con la comunidad. Puedes publicar tu plugin a cualquier `npmjs` -base de registro, pero el recomendado es el [registro de la nueva gestión pública][4]. Lea nuestro [editorial plugins guía del MNP][5].
+
+ [4]: https://www.npmjs.com
+ [5]: http://plugins.cordova.io/npm/developers.html
+
+**Nota**: [registro de plugin de Córdoba][6] se está moviendo a un estado de sólo lectura. `publish`/ `unpublish` se han eliminado los comandos de `plugman` , así que necesitarás usar correspondiente `npm` comandos.
+
+ [6]: https://plugins.cordova.io
+
+Otros desarrolladores pueden instalar el plugin automáticamente mediante `plugman` o CLI Cordova. (Para más detalles sobre cada paso del desarrollo, ver Plugman utilizando para administrar Plugins y la interfaz de línea de comandos).
+
+Para publicar un plugin para registro de MNP necesita seguir los siguientes pasos:
+
+*   crear `package.json` archivo de tu plugin:
+    
+        $ plugman createpackagejson /path/to/your/plugin
+        
+
+*   publicarla:
+    
+        $ npm adduser # that is if you don't have an account yet
+        $ npm publish /path/to/your/plugin
+        
+
+Eso es todo!
+
+Ejecutando `plugman --help` enumera otros basados en el registro de los comandos disponibles.
\ 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/hybrid/webviews/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/hybrid/webviews/index.md b/www/docs/es/6.0.0/guide/hybrid/webviews/index.md
new file mode 100644
index 0000000..d276abe
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/hybrid/webviews/index.md
@@ -0,0 +1,32 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Incrustar WebViews
+---
+
+# Incrustar WebViews
+
+Cordova aplicaciones se implementan normalmente como un navegador *WebView* dentro de la plataforma móvil de nativa. Esta sección le muestra cómo, para apoyar las plataformas, para crear tu propio WebView componentes que hacen pleno usan de Cordova APIs. Entonces puede implementar estos componentes de la aplicación de Córdoba junto con componentes nativos en una aplicación híbrida.
+
+Para implementar un WebView, necesitas estar familiarizado con cada entorno de programación nativa. A continuación proporciona instrucciones para plataformas soportadas:
+
+*   [Amazon fuego OS WebViews](../../platforms/amazonfireos/webview.html)
+*   [Android WebViews](../../platforms/android/webview.html)
+*   [iOS WebViews](../../platforms/ios/webview.html)
+*   [Windows Phone 8,0 WebViews](../../platforms/wp8/webview.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/next/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/next/index.md b/www/docs/es/6.0.0/guide/next/index.md
new file mode 100644
index 0000000..b64ee16
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/next/index.md
@@ -0,0 +1,258 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Próximos pasos
+---
+
+# Próximos pasos
+
+Para los desarrolladores que tienen una comprensión de cómo utilizar el CLI Cordova y hacer uso de plugins, hay algunas cosas que usted puede desear considerar investigar junto a construir mejor, más performantes Cordova aplicaciones. El siguiente documento ofrece consejos sobre diversos temas relativos a las mejores prácticas, pruebas, actualizaciones y otros temas, pero no está destinado a ser prescriptivo. Considera esto como su punta de lanza para su crecimiento como desarrollador de Córdoba. Además, si ves algo que se puede mejorar, por favor [contribuir][1]!
+
+ [1]: http://cordova.apache.org/#contribute
+
+Esta guía contiene los siguientes temas:
+
+*   Mejores prácticas
+*   Manejo de actualizaciones
+*   Prueba aplicaciones de Cordova
+*   Depurar aplicaciones de Cordova
+*   Interfaz de usuario
+*   Consideraciones especiales
+*   Mantenerse al día
+*   Cómo obtener ayuda 
+
+# Mejor desarrollo de aplicaciones prácticas Córdoba
+
+## 1) SPA es tu amigo
+
+Primero y más importante - sus aplicaciones Cordova deberían adoptar el diseño SPA (sola página aplicación). Vagamente definido, un SPA es una aplicación de cliente que se ejecuta desde una petición de una página web. El usuario carga un conjunto inicial de recursos (HTML, CSS y JavaScript) y más actualizaciones (mostrando una nueva vista, carga de datos) se realiza mediante AJAX. Balnearios comúnmente se utilizan para aplicaciones más complejas del lado del cliente. GMail es un gran ejemplo de esto. Después de cargar GMail, correo vistas, edición y organización se realizan mediante la actualización del DOM en lugar de en realidad dejar la página actual para cargar uno completamente nuevo.
+
+Usando un SPA puede ayudarle a organizar su solicitud de una manera más eficiente, pero también tiene beneficios específicos para aplicaciones de Córdoba. Una aplicación de Córdoba debe esperar para que el evento [deviceready](../../cordova/events/events.deviceready.html) disparar antes de que puede utilizarse cualquier plugins. Si usted no utiliza un SPA, y el usuario hace clic en ir de una página a otra, tendrás que esperar a que [deviceready](../../cordova/events/events.deviceready.html) disparar otra vez antes de hacer uso de un plugin. Esto es fácil de olvidar como su aplicación consigue más grande.
+
+Incluso si usted decide no utilizar Cordova, creando una aplicación móvil sin necesidad de utilizar una arquitectura única página tendrá consecuencias graves rendimiento. Esto es porque navegando entre páginas requerirá guiones, activos, etc., para ser recargadas. Incluso si estos activos se almacenan en caché, todavía habrá problemas de performance.
+
+Son ejemplos de bibliotecas SPA que se pueden utilizar en sus aplicaciones de Córdoba:
+
+*   [AngularJS][2]
+*   [EmberJS][3]
+*   [Columna vertebral][4]
+*   [Kendo UI][5]
+*   [Monaca][6]
+*   [ReactJS][7]
+*   [Sencha Touch][8]
+*   [jQuery Mobile][9]
+
+ [2]: http://angularjs.org
+ [3]: http://emberjs.com
+ [4]: http://backbonejs.org
+ [5]: http://www.telerik.com/kendo-ui
+ [6]: http://monaca.mobi/en/
+ [7]: http://facebook.github.io/react/
+ [8]: http://www.sencha.com/products/touch/
+ [9]: http://jquerymobile.com
+
+Y muchos, muchos más.
+
+## 2) consideraciones de rendimiento
+
+Uno de los mayores errores que puede hacer un nuevo desarrollador Cordova es suponer que el rendimiento que sacan de una máquina de escritorio es el mismo que van a salir en un dispositivo móvil. Mientras que nuestros dispositivos móviles han conseguido más de gran alcance cada año, todavía carecen de la potencia y el rendimiento de un ordenador de sobremesa. Dispositivos móviles suelen tienen mucho menos memoria RAM y una GPU que dista mucho de su escritorio (o incluso portátil) hermanos. Una lista completa de sugerencias aquí sería demasiado, pero aquí están algunas cosas a tener en cuenta (con una lista de más recursos al final para futuras investigaciones).
+
+**Haga clic en comparación con tacto** - el error más grande y más simple que usted puede hacer es utilizar eventos de clic. Mientras estos "trabajaren" muy bien en el móvil, mayoría de los dispositivos impone un retraso de 300ms sobre ellos con el fin de distinguir entre un toque y un toque "hold" evento. Usando `touchstart` , o `touchend` , resultará en una mejora dramática - 300ms no parece mucho, pero puede resultar en un desigual comportamiento y las actualizaciones de la interfaz de usuario. También debe considerar el hecho de que "tocar" eventos no son compatibles en los navegadores no-webkit, ver [CanIUse][10]. Con el fin de hacer frente a estas limitaciones, puedes retirada varias bibliotecas como HandJS y Fastouch.
+
+ [10]: http://caniuse.com/#search=touch
+
+**Las transiciones CSS versus manipulación DOM** - usando las transiciones CSS hardware acelerado será significativamente mejor que usando JavaScript para crear animaciones. Ver la lista de recursos al final de esta sección para ver ejemplos.
+
+**Redes chupa** - Ok, redes no siempre apestan, pero la latencia de las redes móviles, redes móviles incluso buenas, es peor que ustedes piensan. Una aplicación de escritorio que sorbe abajo 500 filas de datos JSON, cada 30 segundos, será más lento en un dispositivo móvil, así como un cerdo de batería. Tenga en cuenta que las apps Cordova tienen múltiples maneras de conservar los datos en la aplicación (LocalStorage y el sistema de archivos por ejemplo). Almacenar en caché datos localmente y ser consciente de la cantidad de datos que envía hacia adelante y hacia atrás. Esta es una consideración especialmente importante cuando la aplicación está conectada en una red celular.
+
+**Recursos y artículos de rendimiento adicional**
+
+*   ["Usted medio culos"][11]
+*   ["Los mejores diez consejos de rendimiento para aplicaciones híbridas y PhoneGap"][12]
+*   ["Rápidas aplicaciones y sitios con JavaScript"][13]
+
+ [11]: http://sintaxi.com/you-half-assed-it
+ [12]: http://coenraets.org/blog/2013/10/top-10-performance-techniques-for-phonegap-and-hybrid-apps-slides-available/
+ [13]: https://channel9.msdn.com/Events/Build/2013/4-313
+
+## 3) reconocer y manejar el estado Offline
+
+Ver los consejos anteriores sobre redes. No sólo puede ser una red lenta, es totalmente posible para su aplicación a estar completamente fuera de servicio. Su aplicación debe manejarlo de una manera inteligente. Si su aplicación no, la gente pensará que su aplicación está rota. Teniendo en cuenta lo fácil que es manejar (Cordova soporta ambos un evento offline y online), no hay ninguna razón para que su aplicación no responden bien cuando se ejecuta fuera de línea. Asegúrese de probar (véase la sección de pruebas) la aplicación y asegúrese de probar cómo maneja su aplicación al iniciar en un estado y luego cambiar a la otra.
+
+Tenga en cuenta que los eventos online y offline, así como la API de conexión de red no es perfecta. Puede que necesites recurrir a mediante una petición XHR para ver si el dispositivo está verdaderamente fuera de línea o en línea. Al final del día, ser seguro que añadir algún tipo de ayuda para problemas de la red - de hecho, la tienda de Apple (y probablemente otras tiendas) rechazará apps que no manejarán adecuadamente los Estados offline y online. Para más información sobre este tema, vea ["Está esta cosa?"][14]
+
+ [14]: http://blogs.telerik.com/appbuilder/posts/13-04-23/is-this-thing-on-%28part-1%29
+
+# Manejo de actualizaciones
+
+## Cordova proyectos de mejora
+
+Si su proyecto existente fue creado usando Cordova 3.x, puede actualizar el proyecto mediante la emisión de los siguientes:
+
+    Cordova plataforma actualización plataforma-nombre ios, android, etc..
+    
+
+Si su proyecto existente se creó en una versión anterior Cordova 3.x, probablemente sería mejor crear un nuevo proyecto de Cordova 3.x y luego copiar código y activos existentes de su proyecto para el nuevo proyecto. Pasos habituales:
+
+*   Crear un nuevo proyecto de Cordova 3.x (cordova crear...)
+*   Copia la carpeta www de su viejo proyecto para el nuevo proyecto
+*   Copiar cualquier configuración del viejo proyecto para el nuevo proyecto
+*   Añadir algún plugin usado en el viejo proyecto para el nuevo proyecto
+*   Construya su proyecto
+*   Prueba, prueba, prueba!
+
+Independientemente de la versión anterior del proyecto, es imprescindible que lea sobre lo que cambió en la versión actualizada, ya que la actualización puede romper su código. Será el mejor lugar para encontrar esta información en las notas publicadas en el blog de Cordova tanto en los repositorios. Usted querrá probar su aplicación cuidadosamente para verificar que está funcionando correctamente después de realizar la actualización.
+
+Nota: algunos plugins no sean compatibles con la nueva versión de Córdoba. Si un plugin no es compatible, usted puede ser capaz de encontrar un plugin de reemplazo que hace lo que usted necesita, o puede que necesites retrasar la actualización de su proyecto. Alternativamente, alterar el plugin para que funcione bajo la nueva versión y contribuir a la comunidad.
+
+## Actualizaciones del plugin
+
+A partir de 3.4 Cordova, no hay ningún mecanismo para actualizar plugins cambiante utilizando un único comando. En cambio, quitar el plugin y agregar nuevamente a su proyecto, y se instalará la nueva versión:
+
+    Cordova plugin rm com.some.plugin cordova plugin agregar com.some.plugin
+    
+
+Asegúrese de consultar la documentación del plugin actualizado, como puede que deba ajustar el código para trabajar con la nueva versión. También, asegurate de que la nueva versión del plugin funciona con la versión de su proyecto de Córdoba.
+
+Siempre pruebe sus aplicaciones para asegurarse de que instalar el nuevo plugin no ha roto algo que no previó.
+
+Si su proyecto tiene un montón de plugins que necesitas actualizar, puede salvar tiempo para crear un script de shell o lote que quita y agrega los plugins con un solo mando.
+
+# Prueba aplicaciones de Cordova
+
+Prueba de sus aplicaciones es súper importante. El equipo de Córdoba utiliza jazmín pero hará ninguna solución prueba web unidad amigable.
+
+## Pruebas en un simulador de vs en un dispositivo real
+
+No es infrecuente usar los navegadores de escritorio y dispositivos simuladores/emuladores al desarrollar una aplicación de Córdoba. Sin embargo, es muy importante que pruebe su aplicación en dispositivos físicos tantos como puedas:
+
+*   Simuladores son sólo eso: simuladores. Por ejemplo, su aplicación puede trabajar en el simulador de iOS sin problema, pero no puede fallar en un dispositivo real (especialmente en determinadas circunstancias, como un estado bajo de memoria). O bien, su aplicación puede fallar en realidad en el simulador mientras que funciona bien en un dispositivo real. 
+*   Emuladores son sólo eso: emuladores. No representan así su aplicación se ejecuta en un dispositivo físico. Por ejemplo, algunos emuladores pueden procesar su aplicación con una pantalla de confusa, mientras que un dispositivo real no tiene ningún problema. (Si encuentra este problema, deshabilite el anfitrión GPU en el emulador).
+*   Simuladores son generalmente más rápidos que su dispositivo físico. Emuladores, por el contrario, son generalmente más lentos. No juzgo el rendimiento de su aplicación por cómo se realiza en un simulador o un emulador. Juzgar el rendimiento de su aplicación por cómo se ejecuta en un espectro de dispositivos reales.
+*   Es imposible conseguir una buena sensación de cómo su aplicación responde al tacto mediante el uso de un simulador o un emulador. En cambio, ejecutando la aplicación en un dispositivo real puede señalar problemas con los tamaños de los elementos de la interfaz de usuario, capacidad de respuesta, etc..
+*   Aunque sería agradable poder probar solamente en un dispositivo por plataforma, es mejor poner a prueba en muchos dispositivos deportivos muchas versiones diferentes del sistema operativo. Por ejemplo, lo que funciona en tu smartphone Android particular puede fallar en otro dispositivo Android. Lo que funciona en un dispositivo iOS 7 puede fallar en un dispositivo iOS 6.
+
+Es, por supuesto, imposible de probar en todos los dispositivos posibles en el mercado. Por este motivo, es aconsejable reclutar muchos probadores que tienen diferentes dispositivos. Aunque no cogerán todos los problemas, más probable es que descubrirán rarezas y temas que nunca encontrarás solo buena.
+
+Sugerencia: Es posible en dispositivos Android Nexus a flash fácilmente distintas versiones de Android en el dispositivo. Este simple proceso le permitirá probar fácilmente su aplicación en diferentes niveles de Android con un solo dispositivo, sin anular su garantía o necesidad para "jailbreak" o "raíz" de su dispositivo. Las imágenes de fábrica de Google Android y las instrucciones se encuentran en: https://developers.google.com/android/nexus/images#instructions
+
+# Depurar aplicaciones de Cordova
+
+Depuración Cordova requiere una configuración. A diferencia de una aplicación de escritorio, no puedes simplemente open dev herramientas del dispositivo móvil y empezar a depurar, por suerte hay algunas grandes alternativas.
+
+## iOS depuración
+
+### Xcode
+
+Con Xcode puede depurar el lado nativo iOS de la aplicación de Córdoba. Asegúrese de que la zona de depuración está mostrando (vista-> área de depuración). Una vez que su aplicación se ejecuta en el dispositivo (o simulador), usted puede ver registro de salida en la zona de depuración. Esto es donde se imprimirán los errores o advertencias. También puede establecer puntos de interrupción en los archivos fuente. Esto le permitirá dar un paso a través de la línea de un código en un momento y ver el estado de las variables en aquel momento. El estado de las variables se muestra en el área de depuración cuando se alcanza un punto de interrupción. Una vez que su aplicación está en marcha en el dispositivo, puede traer a inspector de Safari web (como se describe a continuación) para depurar el lado webview y js de su aplicación. Para más información y ayuda, consulte la guía de Xcode: [Guía de depuración de Xcode][15]
+
+ [15]: https://developer.apple.com/library/mac/documentation/ToolsLanguages/Conceptual/Xcode_Overview/DebugYourApp/DebugYourApp.html#//apple_ref/doc/uid/TP40010215-CH18-SW1
+
+### Safari remoto depuración con Web Inspector
+
+Con el inspector web de Safari puede depurar el código webview y js en su aplicación de Córdoba. Esto funciona sólo en OSX y sólo con iOS 6 (o superior). Utiliza Safari para conectarse a su dispositivo (o el simulador) y conectará herramientas del revelador del navegador con la aplicación de Córdoba. Obtienes lo que esperas de dev tools - DOM inspección/manipulación, un depurador de JavaScript, inspección de la red, la consola y mucho más. Como Xcode, con inspector de Safari web puede establecer puntos de interrupción en el código JavaScript y ver el estado de las variables en aquel momento. Usted puede ver los errores, advertencias o mensajes que aparecen en la consola. También puede ejecutar comandos JavaScript directamente desde la consola como su aplicación se está ejecutando. Para más detalles sobre cómo ponerlo en marcha y lo que puedes hacer, ver este excelente blog post: <http://moduscreate.com/enable-remote-web-inspector-in-ios-6/> y esta guía: [Guía de
  Safari Web Inspector][16]
+
+ [16]: https://developer.apple.com/library/safari/documentation/AppleApplications/Conceptual/Safari_Developer_Guide/Introduction/Introduction.html
+
+## Depuración remota de cromo
+
+Prácticamente lo mismo que la versión de Safari, esto sólo funciona con Android pero puede ser utilizada desde cualquier sistema operativo de escritorio. Se requiere un mínimo de Android 4.4 (KitKat), mínimo nivel de API de 19 y cromo 30 + (en el escritorio). Una vez conectado, obtendrá la misma experiencia de Chrome Dev Tools para sus aplicaciones móviles como haces con tus aplicaciones de escritorio. Mejor aún, el Chrome Dev Tools tener una opción de espejo que muestra su aplicación en el dispositivo móvil. Esto es más que una visión - puede desplazarse y haga clic en herramientas dev y se actualiza en el dispositivo móvil. Más información sobre la depuración remota de cromo puede encontrarse aquí: <https://developers.google.com/chrome/mobile/docs/debugging>
+
+Es posible usar Chrome Dev Tools para inspeccionar las apps iOS, a través de un proxy de WebKit: <https://github.com/google/ios-webkit-debug-proxy/>
+
+## Ripple
+
+Ripple es un emulador basado en escritorio para proyectos de Córdoba. Esencialmente le permite ejecutar una aplicación Cordova en su aplicación de escritorio y falsos varias características de Córdoba. Por ejemplo, le permite simular el acelerómetro para probar el batido de eventos. Simula la cámara API le permite seleccionar una imagen desde tu disco duro. Ondulación le permite que enfocarse más en tu código personalizado en lugar de preocuparse por Cordova plugins. Usted puede encontrar más información acerca de ondulación aquí: <http://ripple.incubator.apache.org/>
+
+## Weinre
+
+Weinre crea un servidor local que puede albergar a un cliente depuración remota para sus aplicaciones de Córdoba. Después de haber instalado y puso en marcha, copie una línea de código en la aplicación de Cordova y reinícielo. Luego puedes abrir un panel de la herramienta dev en tu escritorio para trabajar con la aplicación. Weinre no es bastante tan elegante como cromo y depuración remota de Safari, pero tiene la ventaja de trabajar con una gama más amplia de plataformas y sistemas operativos. Puede encontrar más información aquí: <http://people.apache.org/~pmuellr/weinre/docs/latest/>
+
+## Otras opciones
+
+*   BlackBerry 10 soporta depuración así como: [documentación][17]
+*   Puede depurar usando Firefox App Manager así, vea [esta entrada de blog][18] y este [artículo MDN][19].
+*   Para más ejemplos y explicación de los anteriores consejos de depuración, vea: <http://developer.telerik.com/featured/a-concise-guide-to-remote-debugging-on-ios-android-and-windows-phone/>
+
+ [17]: https://developer.blackberry.com/html5/documentation/v2_0/debugging_using_web_inspector.html
+ [18]: https://hacks.mozilla.org/2014/02/building-cordova-apps-for-firefox-os/
+ [19]: https://developer.mozilla.org/en-US/Apps/Tools_and_frameworks/Cordova_support_for_Firefox_OS#Testing_and_debugging
+
+# Interfaz de usuario
+
+Creación de una aplicación de Córdoba que queda bien móvil puede ser un desafío, especialmente para los desarrolladores. Mucha gente optó por usar un marco de interfaz de usuario para hacerlo más fácil. Aquí está una lista corta de las opciones que usted puede desear considerar.
+
+*   [jQuery Mobile][9] - jQuery Mobile automáticamente realza su diseño para la optimización del móvil. También maneja creando un SPA para usted automáticamente.
+*   [iónico][20] -este potente entorno de interfaz de usuario en realidad tiene su propio CLI para manejar la creación del proyecto. 
+*   [Trinquete][21] - traído a usted por la gente que creó Bootstrap. 
+*   [Kendo UI][5] - interfaz de usuario de código abierto y marco de aplicación de Telerik.
+*   [TOPCOAT][22]
+*   [ReactJS][7]
+
+ [20]: http://ionicframework.com/
+ [21]: http://goratchet.com/
+ [22]: http://topcoat.io
+
+Al construir la interfaz de usuario, es importante pensar en todas las plataformas que está atacando y las diferencias entre las expectativas del usuario. Por ejemplo, una aplicación para Android que tiene una interfaz de usuario estilo iOS probablemente no va bien con los usuarios. Esto a veces es incluso aplicada por las diferentes tiendas de aplicaciones. Debido a esto, es importante que respeten las convenciones de cada plataforma y por lo tanto están familiarizados con las diversas directrices de interfaz humana:
+
+*   [iOS][23]
+*   [Android][24]
+*   [Windows Phone][25]
+
+ [23]: https://developer.apple.com/library/ios/documentation/userexperience/conceptual/MobileHIG/index.html
+ [24]: https://developer.android.com/designWP8
+ [25]: http://dev.windowsphone.com/en-us/design/library
+
+## Recursos y artículos adicionales UI
+
+Aunque los motores navegador convertido en queja estándares cada vez más, vivimos en un mundo con prefijo (-webkit y - la Sra.) el siguiente artículo es valioso en el desarrollo de interfaz de usuario en cruz aplicaciones del navegador: <http://blogs.windows.com/windows_phone/b/wpdev/archive/2012/11/15/adapting-your-webkit-optimized-site-for-internet-explorer-10.aspx>
+
+# Consideraciones especiales
+
+Aunque Cordova facilita el desarrollo multiplataforma, no es posible proporcionar aislamiento 100% desde la plataforma nativo subyacente. Para ser conscientes de las restricciones.
+
+## Plataforma rarezas
+
+Al leer la documentación, busque las secciones que describen diferentes comportamientos o requisitos en múltiples plataformas. Si está presente, estos serían en una sección titulada "Rarezas Android", "iOS rarezas", etc.. Lea detenidamente estas rarezas y ser conscientes de ellas mientras trabajas con Córdoba.
+
+## Cargando contenido remoto
+
+Invocar funciones Cordova JavaScript desde una página HTML cargados remotamente (una página HTML no almacenada localmente en el dispositivo) es una configuración no admitida. Esto es porque Córdoba no fue diseñado para esto, y la comunidad Apache Cordova no hace ninguna prueba de esta configuración. Mientras que puede funcionar en algunas circunstancias, no es recomendable ni apoyado. Hay problemas con la política del mismo origen, manteniendo el JavaScript y las porciones nativas de Córdoba sincronización en la misma versión (puesto que están acoplados mediante APIs privadas que pueden cambiar), la confiabilidad del contenido remoto llamar a funciones nativas locales y potencial rechazo de app store.
+
+La visualización de contenido HTML cargados remotamente en un webview debe hacerse usando InAppBrowser de Cordova. El InAppBrowser está diseñado para que JavaScript corriendo allá no tienen acceso a las APIs de JavaScript Cordova por las razones mencionadas anteriormente. Por favor consulte la guía de seguridad.
+
+# Mantenerse al día
+
+Aquí están algunas maneras de mantenerse al día con Córdoba.
+
+*   Suscribirse al [blog de Córdoba][26].
+*   Suscribirse a la [lista de desarrolladores][27]. Nota: no se trata de un grupo de apoyo! Más bien se trata de un lugar donde se discute el desarrollo de Córdoba.
+
+ [26]: http://cordova.apache.org/#news
+ [27]: http://cordova.apache.org/#mailing-list
+
+# Cómo obtener ayuda
+
+Los siguientes enlaces son los mejores lugares para conseguir ayuda para Córdoba:
+
+*   StackOverflow: <http://stackoverflow.com/questions/tagged/cordova> mediante el uso de la etiqueta de Cordova, puede ver y examinar todas las cuestiones de Córdoba. Tenga en cuenta que StackOverflow convierte automáticamente la etiqueta de "Phonegap" a "Córdoba", para que de esta manera usted podrá acceder a preguntas históricas, así
+*   Grupo de Google de PhoneGap: [https://groups.google.com/forum/#! forum/phonegap][28] este grupo de Google fue el antiguo Foro de soporte cuando todavía se llamaba PhoneGap Cordova. Mientras que todavía hay muchos usuarios de Córdoba que frecuente este grupo, la comunidad de Córdoba ha expresado su interés en centrarse menos en este grupo y en su lugar utilizando StackOverflow para apoyo
+*   Quedada: <http://phonegap.meetup.com> - considere encontrar un grupo local de la quedada de PhoneGap/Cordova
+
+ [28]: https://groups.google.com/forum/#!forum/phonegap
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/cordova-docs/blob/a201cf64/www/docs/es/6.0.0/guide/overview/index.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/overview/index.md b/www/docs/es/6.0.0/guide/overview/index.md
new file mode 100644
index 0000000..272bd3b
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/overview/index.md
@@ -0,0 +1,77 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Resumen
+---
+
+# Resumen
+
+Apache Cordova es un marco de desarrollo móvil de código abierto. Permite utilizar las tecnologías estándar web como HTML5, CSS3 y JavaScript para desarrollo multiplataforma, evitando el lenguaje de desarrollo nativo cada plataformas móviles. Aplicaciones ejecutan dentro de envolturas para cada plataforma y dependen de enlaces estándares API para acceder a de cada dispositivo sensores, datos y estado de la red.
+
+Apache Cordova se graduó en octubre de 2012 como un proyecto de nivel superior dentro de la Apache Software Foundation (ASF). A través del ASF, futuro desarrollo Cordova asegurará administración abierta del proyecto. Siempre permanecerá libre y de código abierto bajo la licencia Apache, versión 2.0. Visite [cordova.apache.org][1] para obtener más información.
+
+ [1]: http://cordova.apache.org
+
+Usar Apache Cordova si eres:
+
+*   establecen un móvil desarrollador y desea extender una aplicación a través de más de una plataforma, sin tener que reimplementarlo con herramienta y lenguaje de cada plataforma.
+
+*   un desarrollador web y desea implementar una aplicación web que se envasa para su distribución en varias app store portales.
+
+*   un móvil desarrollador interesado en que se mezclan los componentes de la aplicación nativa con un *WebView* (ventana del navegador especial) que puede tener acceso a las API de nivel de dispositivo, o si quiere desarrollar una interfaz plugin entre componentes WebView y nativos.
+
+## Componentes básicos
+
+Apache Cordova aplicaciones se basan en un común `config.xml` archivo que proporciona información acerca de la aplicación y especifica los parámetros que afectan a cómo funciona, como si responde a la orientación cambia de puesto. Este archivo se adhiere a la especificación de [Empaquetado de la aplicación Web][2], *widget*, o de la W3C.
+
+ [2]: http://www.w3.org/TR/widgets/
+
+La misma aplicación se implementa como una página web, un archivo local llamado *index.html*, que hace referencia a cualquier CSS, JavaScript, imágenes, archivos multimedia u otros recursos son necesarios para que se ejecute de forma predeterminada. La aplicación se ejecuta como un *WebView* dentro de la envoltura de la aplicación nativa, que distribuye a tiendas de aplicaciones.
+
+El WebView Cordova-habilitado puede proporcionar la aplicación con su interfaz de usuario completa. En algunas plataformas, también puede ser un componente dentro de una aplicación híbrida más grande, que mezcla la vista Web con componentes de la aplicación nativa. (Véase WebViews incrustación para más detalles).
+
+Una interfaz *plugin* está disponible para Cordova y componentes nativos para comunicarse con los demás. Esto te permite invocar un código de JavaScript. Idealmente, las API de JavaScript para ese código nativo son consistentes a través de múltiples plataformas de dispositivos. A partir de la versión 3.0, las extensiones proporcionan enlaces a APIs estándar. Plugins de terceros proporcionan enlaces adicionales a funciones no necesariamente disponibles en todas las plataformas. Puede encontrar estos plugins de terceros en el [registro de plugin][3] y utilizarlos en su aplicación. También puedes desarrollar tus propios plugins, como se describe en la guía de desarrollo de Plugin. Plugins puede ser necesario, por ejemplo, para comunicarse entre Córdoba y componentes personalizados de nativos.
+
+ [3]: http://plugins.cordova.io
+
+**Nota**: desde la versión 3.0, cuando se crea un proyecto de Córdoba no tiene presente algún plugin. Este es el nuevo comportamiento predeterminado. Algún plugin que desee, incluso los plugins del núcleo, debe agregarse explícitamente.
+
+Córdova no proporciona ninguna widgets UI o MV * Marcos. Cordova proporciona solamente el tiempo de ejecución en el cual los pueden ejecutar. Si usted desea utilizar widgets UI o un marco MV *, usted necesitará seleccionar aquellos e incluirlos en su solicitud usted mismo como material de terceros.
+
+## Vías de desarrollo
+
+A partir de la versión 3.0, puede utilizar dos flujos de trabajo básicos para crear una aplicación móvil. Mientras que a menudo puede utilizar cualquier flujo de trabajo para realizar la misma tarea, cada uno de ellos ofrece ventajas:
+
+*   **Flujo de trabajo multiplataforma (CLI)**: Use este flujo de trabajo si quieres tu aplicación para ejecutar en los sistemas operativos móviles como sea posible, con poco necesidad específica de la plataforma desarrollo. Este flujo de trabajo se centra en la `cordova` utilidad, también conocido como el *CLI*, que fue introducido con 3.0 Cordova Cordova. El CLI es una herramienta de alto nivel que le permite construir proyectos para muchas plataformas a la vez, muy lejos de la funcionalidad de scripts de shell de bajo nivel de abstracción. La CLI copia un conjunto común de web activos en subdirectorios para cada plataforma móvil, hace que cualquier cambio de configuración necesarias para cada uno, construir secuencias de comandos para generar los binarios de la aplicación ejecuta. La CLI también proporciona una interfaz común para aplicar plugins para su aplicación. Para más detalles sobre el CLI, vea la interfaz de línea de comandos. A menos que usted tiene una nec
 esidad para el flujo de trabajo centrado en plataforma, se recomienda el flujo de trabajo multiplataforma.
+
+*   **Flujo de trabajo centrado en plataforma**: Utilice este flujo de trabajo si desea concentrarse en construir una aplicación para una sola plataforma y necesitan poder modificarlo en un nivel inferior. Tienes que utilizar este enfoque, por ejemplo, si quieres tu aplicación para mezclar los componentes nativos personalizados con componentes Cordova basados en web, como se explica en WebViews incrustación. Como regla general, utilice este flujo de trabajo si necesitas modificar el proyecto dentro del SDK. Este flujo de trabajo se basa en un conjunto de scripts de shell de nivel inferior que se adaptan para cada plataforma soportada y una utilidad de Plugman separada que le permite aplicar plugins. Mientras este flujo de trabajo puede utilizar para crear aplicaciones multiplataforma, es generalmente más difícil porque la falta de una herramienta de alto nivel significa construir diferentes ciclos y modificaciones de plugin para cada plataforma. Aún así, este flujo de trabajo
  permite un mayor acceso a opciones de desarrollo proporcionadas por cada SDK y es esencial para aplicaciones complejas híbrido. Vea a las diversas guías de plataforma para obtener más información sobre utilidades de shell disponible de cada plataforma.
+
+Cuando primero comenzando, puede ser más fácil utilizar el flujo de trabajo multiplataforma para crear una aplicación, como se describe en la interfaz de línea de comandos. Entonces tienes la opción de cambiar a un flujo de trabajo centrado en plataforma si necesitas el SDK proporciona un mayor control. Utilidades de shell de nivel inferior están disponibles en [cordova.apache.org][1] en una distribución independiente de la CLI. Para los proyectos generados inicialmente por la CLI, estas herramientas de shell también están disponibles en el proyecto de varios `platforms/*/cordova` directorios.
+
+**Nota**: una vez que se cambia de los flujos de trabajo basados en CLI a uno centrado en la específica de la plataforma SDK y herramientas de shell, no puedes volver. La CLI mantiene un conjunto común de código fuente multiplataforma, que en cada uno a construir aplicaciones para escribir código fuente específica de la plataforma. Para conservar las modificaciones en los activos específicos a una plataforma, puede necesita cambiar las herramientas de plataforma centrada en la cáscara, que ignoran el código multiplataforma, y en cambio se basa en el código fuente específica de la plataforma.
+
+## Instalación de Cordova
+
+La instalación de Córdoba será diferente dependiendo del flujo de trabajo anterior que usted elige:
+
+*   Flujo de trabajo multiplataforma: ver la interfaz de línea de comandos.
+
+*   Flujo de trabajo centrado en plataforma: ver las guias de la plataforma.
+
+Después de instalar Cordova, se recomienda que consulte a las guías de plataforma para las plataformas móviles que va a desarrollar para. También se recomienda que también revise la guía de privacidad, seguridad y próximos pasos. Para configurar Cordova, consulte el archivo config.xml. Para acceder a la función nativa en un dispositivo de JavaScript, se refieren a las APIs de Plugin. Y se refieren a las otras guías incluidas según sea necesario.
\ 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/config.md
----------------------------------------------------------------------
diff --git a/www/docs/es/6.0.0/guide/platforms/amazonfireos/config.md b/www/docs/es/6.0.0/guide/platforms/amazonfireos/config.md
new file mode 100644
index 0000000..04ebad4
--- /dev/null
+++ b/www/docs/es/6.0.0/guide/platforms/amazonfireos/config.md
@@ -0,0 +1,71 @@
+---
+license: >
+    Licensed to the Apache Software Foundation (ASF) under one
+    or more contributor license agreements.  See the NOTICE file
+    distributed with this work for additional information
+    regarding copyright ownership.  The ASF licenses this file
+    to you under the Apache License, Version 2.0 (the
+    "License"); you may not use this file except in compliance
+    with the License.  You may obtain a copy of the License at
+
+        http://www.apache.org/licenses/LICENSE-2.0
+
+    Unless required by applicable law or agreed to in writing,
+    software distributed under the License is distributed on an
+    "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+    KIND, either express or implied.  See the License for the
+    specific language governing permissions and limitations
+    under the License.
+
+title: Amazon fuego OS configuración
+---
+
+# Amazon fuego OS configuración
+
+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. Este preferencias detalles sección que sólo se aplican a Amazon fuego OS construye. 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"/>
+        
+
+*   `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="error.html"/>
+        
+
+*   `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="Please wait, the app is loading"/>
+        
+
+*   `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="Please wait, the data is loading"/>
+        
+
+*   `LoadUrlTimeoutValue` (número, el valor predeterminado es `20000`): 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`: el nombre del archivo sin su extensión en el directorio `res/drawable`. Varios activos deben compartir este nombre común en diferentes subdirectorios.
+    
+        <preference name="SplashScreen" value="splash"/>
+        
+
+*   `SplashScreenDelay` (número, el valor predeterminado de `5000`): la cantidad de tiempo que muestra la imagen en pantalla splash.
+    
+        <preference name="SplashScreenDelay" value="10000"/>
+        
+
+*   `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"/>
\ 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